blob: 5680abcc32a33c36e8f7ace9012da4fb9bf348e3 [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"
Guido van Rossumd8faa362007-04-27 19:54:29 +00007#undef Yield /* undefine macro conflicting with winbase.h */
Neal Norwitzadb69fc2005-12-17 20:54:49 +00008#include "pyarena.h"
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00009#include "pythonrun.h"
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000010#include "errcode.h"
Guido van Rossumc405b7b1991-06-04 19:39:42 +000011#include "marshal.h"
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000012#include "code.h"
Guido van Rossumc405b7b1991-06-04 19:39:42 +000013#include "compile.h"
Guido van Rossumff4949e1992-08-05 19:58:53 +000014#include "eval.h"
Guido van Rossumd8bac6d1992-02-26 15:19:13 +000015#include "osdefs.h"
Guido van Rossum1ae940a1995-01-02 19:04:15 +000016#include "importdl.h"
Guido van Rossumc405b7b1991-06-04 19:39:42 +000017
Guido van Rossum55a83382000-09-20 20:31:38 +000018#ifdef HAVE_FCNTL_H
19#include <fcntl.h>
20#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000021#ifdef __cplusplus
22extern "C" {
23#endif
Guido van Rossum55a83382000-09-20 20:31:38 +000024
Thomas Woutersf70ef4f2000-07-22 18:47:25 +000025extern time_t PyOS_GetLastModificationTime(char *, FILE *);
26 /* In getmtime.c */
Guido van Rossum21d335e1993-10-15 13:01:11 +000027
Jeremy Hyltond4ceb312004-04-01 02:45:22 +000028/* Magic word to reject .pyc files generated by other Python versions.
29 It should change for each incompatible change to the bytecode.
30
31 The value of CR and LF is incorporated so if you ever read or write
Guido van Rossum7faeab31995-07-07 22:50:36 +000032 a .pyc file in text mode the magic number will be wrong; also, the
Tim Peters36515e22001-11-18 04:06:29 +000033 Apple MPW compiler swaps their values, botching string constants.
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000034
Guido van Rossum45aecf42006-03-15 04:58:47 +000035 The magic numbers must be spaced apart at least 2 values, as the
Martin v. Löwisef82d2f2004-06-27 16:51:46 +000036 -U interpeter flag will cause MAGIC+1 being used. They have been
37 odd numbers for some time now.
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000038
Jeremy Hyltond4ceb312004-04-01 02:45:22 +000039 There were a variety of old schemes for setting the magic number.
40 The current working scheme is to increment the previous value by
41 10.
Guido van Rossumf6894922002-08-31 15:16:14 +000042
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000043 Known values:
44 Python 1.5: 20121
45 Python 1.5.1: 20121
46 Python 1.5.2: 20121
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000047 Python 1.6: 50428
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000048 Python 2.0: 50823
49 Python 2.0.1: 50823
50 Python 2.1: 60202
51 Python 2.1.1: 60202
52 Python 2.1.2: 60202
53 Python 2.2: 60717
Neal Norwitz7fdcb412002-06-14 01:07:39 +000054 Python 2.3a0: 62011
Michael W. Hudsondd32a912002-08-15 14:59:02 +000055 Python 2.3a0: 62021
Guido van Rossumf6894922002-08-31 15:16:14 +000056 Python 2.3a0: 62011 (!)
Martin v. Löwisef82d2f2004-06-27 16:51:46 +000057 Python 2.4a0: 62041
Raymond Hettingerfd2d1f72004-08-23 23:37:48 +000058 Python 2.4a3: 62051
Raymond Hettinger2c31a052004-09-22 18:44:21 +000059 Python 2.4b1: 62061
Michael W. Hudsondf888462005-06-03 14:41:55 +000060 Python 2.5a0: 62071
Michael W. Hudsonaee2e282005-10-21 11:32:20 +000061 Python 2.5a0: 62081 (ast-branch)
Guido van Rossumc2e20742006-02-27 22:32:47 +000062 Python 2.5a0: 62091 (with)
Guido van Rossumf6694362006-03-10 02:28:35 +000063 Python 2.5a0: 62092 (changed WITH_CLEANUP opcode)
Thomas Wouters0e3f5912006-08-11 14:57:12 +000064 Python 2.5b3: 62101 (fix wrong code: for x, in ...)
65 Python 2.5b3: 62111 (fix wrong code: x += yield)
66 Python 2.5c1: 62121 (fix wrong lnotab with for loops and
67 storing constants that should have been removed)
Thomas Wouters89f507f2006-12-13 04:49:30 +000068 Python 2.5c2: 62131 (fix wrong code: for x, in ... in listcomp/genexp)
69 Python 2.6a0: 62141 (peephole optimizations)
Guido van Rossum45aecf42006-03-15 04:58:47 +000070 Python 3000: 3000
Brett Cannone2e23ef2006-08-25 05:05:30 +000071 3010 (removed UNARY_CONVERT)
Guido van Rossum86e58e22006-08-28 15:27:34 +000072 3020 (added BUILD_SET)
Guido van Rossum4f72a782006-10-27 23:31:49 +000073 3030 (added keyword-only parameters)
Guido van Rossum3203bdc2006-12-28 21:03:31 +000074 3040 (added signature annotations)
Guido van Rossum452bf512007-02-09 05:32:43 +000075 3050 (print becomes a function)
Guido van Rossum52cc1d82007-03-18 15:41:51 +000076 3060 (PEP 3115 metaclass syntax)
Michael W. Hudsonaee2e282005-10-21 11:32:20 +000077.
Tim Peters36515e22001-11-18 04:06:29 +000078*/
Guido van Rossum52cc1d82007-03-18 15:41:51 +000079#define MAGIC (3060 | ((long)'\r'<<16) | ((long)'\n'<<24))
Guido van Rossum3ddee711991-12-16 13:06:34 +000080
Guido van Rossum96774c12000-05-01 20:19:08 +000081/* Magic word as global; note that _PyImport_Init() can change the
Jeremy Hylton9262b8a2000-06-30 04:59:17 +000082 value of this global to accommodate for alterations of how the
Guido van Rossum96774c12000-05-01 20:19:08 +000083 compiler works which are enabled by command line switches. */
84static long pyc_magic = MAGIC;
85
Guido van Rossum25ce5661997-08-02 03:10:38 +000086/* See _PyImport_FixupExtension() below */
87static PyObject *extensions = NULL;
Guido van Rossum3f5da241990-12-20 15:06:42 +000088
Guido van Rossum771c6c81997-10-31 18:37:24 +000089/* This table is defined in config.c: */
90extern struct _inittab _PyImport_Inittab[];
91
92struct _inittab *PyImport_Inittab = _PyImport_Inittab;
Guido van Rossum66f1fa81991-04-03 19:03:52 +000093
Guido van Rossumed1170e1999-12-20 21:23:41 +000094/* these tables define the module suffixes that Python recognizes */
95struct filedescr * _PyImport_Filetab = NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +000096
97#ifdef RISCOS
98static const struct filedescr _PyImport_StandardFiletab[] = {
Jack Jansenc88da1f2002-05-28 10:58:19 +000099 {"/py", "U", PY_SOURCE},
Guido van Rossum48a680c2001-03-02 06:34:14 +0000100 {"/pyc", "rb", PY_COMPILED},
101 {0, 0}
102};
103#else
Guido van Rossumed1170e1999-12-20 21:23:41 +0000104static const struct filedescr _PyImport_StandardFiletab[] = {
Jack Jansenc88da1f2002-05-28 10:58:19 +0000105 {".py", "U", PY_SOURCE},
Martin v. Löwis6238d2b2002-06-30 15:26:10 +0000106#ifdef MS_WINDOWS
Jack Jansenc88da1f2002-05-28 10:58:19 +0000107 {".pyw", "U", PY_SOURCE},
Tim Peters36515e22001-11-18 04:06:29 +0000108#endif
Guido van Rossumed1170e1999-12-20 21:23:41 +0000109 {".pyc", "rb", PY_COMPILED},
110 {0, 0}
111};
Guido van Rossum48a680c2001-03-02 06:34:14 +0000112#endif
Guido van Rossumed1170e1999-12-20 21:23:41 +0000113
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000114static PyTypeObject NullImporterType; /* Forward reference */
115
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000116/* Initialize things */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000117
118void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000119_PyImport_Init(void)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000120{
Guido van Rossumed1170e1999-12-20 21:23:41 +0000121 const struct filedescr *scan;
122 struct filedescr *filetab;
123 int countD = 0;
124 int countS = 0;
125
126 /* prepare _PyImport_Filetab: copy entries from
127 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
128 */
129 for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)
130 ++countD;
131 for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
132 ++countS;
Guido van Rossumb18618d2000-05-03 23:44:39 +0000133 filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000134 if (filetab == NULL)
135 Py_FatalError("Can't initialize import file table.");
Guido van Rossumed1170e1999-12-20 21:23:41 +0000136 memcpy(filetab, _PyImport_DynLoadFiletab,
137 countD * sizeof(struct filedescr));
138 memcpy(filetab + countD, _PyImport_StandardFiletab,
139 countS * sizeof(struct filedescr));
140 filetab[countD + countS].suffix = NULL;
141
142 _PyImport_Filetab = filetab;
143
Guido van Rossum0824f631997-03-11 18:37:35 +0000144 if (Py_OptimizeFlag) {
Guido van Rossumed1170e1999-12-20 21:23:41 +0000145 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
146 for (; filetab->suffix != NULL; filetab++) {
Guido van Rossum48a680c2001-03-02 06:34:14 +0000147#ifndef RISCOS
Guido van Rossumed1170e1999-12-20 21:23:41 +0000148 if (strcmp(filetab->suffix, ".pyc") == 0)
149 filetab->suffix = ".pyo";
Guido van Rossum48a680c2001-03-02 06:34:14 +0000150#else
151 if (strcmp(filetab->suffix, "/pyc") == 0)
152 filetab->suffix = "/pyo";
153#endif
Guido van Rossum0824f631997-03-11 18:37:35 +0000154 }
155 }
Guido van Rossum96774c12000-05-01 20:19:08 +0000156
Guido van Rossum572dbf82007-04-27 23:53:51 +0000157 {
Guido van Rossum96774c12000-05-01 20:19:08 +0000158 /* Fix the pyc_magic so that byte compiled code created
159 using the all-Unicode method doesn't interfere with
160 code created in normal operation mode. */
161 pyc_magic = MAGIC + 1;
162 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000163}
164
Guido van Rossum25ce5661997-08-02 03:10:38 +0000165void
Just van Rossum52e14d62002-12-30 22:08:05 +0000166_PyImportHooks_Init(void)
167{
168 PyObject *v, *path_hooks = NULL, *zimpimport;
169 int err = 0;
170
171 /* adding sys.path_hooks and sys.path_importer_cache, setting up
172 zipimport */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000173 if (PyType_Ready(&NullImporterType) < 0)
174 goto error;
Just van Rossum52e14d62002-12-30 22:08:05 +0000175
176 if (Py_VerboseFlag)
177 PySys_WriteStderr("# installing zipimport hook\n");
178
179 v = PyList_New(0);
180 if (v == NULL)
181 goto error;
182 err = PySys_SetObject("meta_path", v);
183 Py_DECREF(v);
184 if (err)
185 goto error;
186 v = PyDict_New();
187 if (v == NULL)
188 goto error;
189 err = PySys_SetObject("path_importer_cache", v);
190 Py_DECREF(v);
191 if (err)
192 goto error;
193 path_hooks = PyList_New(0);
194 if (path_hooks == NULL)
195 goto error;
196 err = PySys_SetObject("path_hooks", path_hooks);
197 if (err) {
198 error:
199 PyErr_Print();
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000200 Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
201 "path_importer_cache, or NullImporter failed"
202 );
Just van Rossum52e14d62002-12-30 22:08:05 +0000203 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000204
Just van Rossum52e14d62002-12-30 22:08:05 +0000205 zimpimport = PyImport_ImportModule("zipimport");
206 if (zimpimport == NULL) {
207 PyErr_Clear(); /* No zip import module -- okay */
208 if (Py_VerboseFlag)
209 PySys_WriteStderr("# can't import zipimport\n");
210 }
211 else {
212 PyObject *zipimporter = PyObject_GetAttrString(zimpimport,
213 "zipimporter");
214 Py_DECREF(zimpimport);
215 if (zipimporter == NULL) {
216 PyErr_Clear(); /* No zipimporter object -- okay */
217 if (Py_VerboseFlag)
218 PySys_WriteStderr(
Fred Drake1e5fc552003-07-11 15:01:02 +0000219 "# can't import zipimport.zipimporter\n");
Just van Rossum52e14d62002-12-30 22:08:05 +0000220 }
221 else {
222 /* sys.path_hooks.append(zipimporter) */
223 err = PyList_Append(path_hooks, zipimporter);
224 Py_DECREF(zipimporter);
225 if (err)
226 goto error;
227 if (Py_VerboseFlag)
228 PySys_WriteStderr(
229 "# installed zipimport hook\n");
230 }
231 }
232 Py_DECREF(path_hooks);
233}
234
235void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000236_PyImport_Fini(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000237{
238 Py_XDECREF(extensions);
239 extensions = NULL;
Barry Warsaw84294482000-10-03 16:02:05 +0000240 PyMem_DEL(_PyImport_Filetab);
241 _PyImport_Filetab = NULL;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000242}
243
244
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000245/* Locking primitives to prevent parallel imports of the same module
246 in different threads to return with a partially loaded module.
247 These calls are serialized by the global interpreter lock. */
248
249#ifdef WITH_THREAD
250
Guido van Rossum49b56061998-10-01 20:42:43 +0000251#include "pythread.h"
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000252
Guido van Rossum65d5b571998-12-21 19:32:43 +0000253static PyThread_type_lock import_lock = 0;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000254static long import_lock_thread = -1;
255static int import_lock_level = 0;
256
257static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000258lock_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)
262 return; /* Too bad */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000263 if (import_lock == NULL) {
Guido van Rossum65d5b571998-12-21 19:32:43 +0000264 import_lock = PyThread_allocate_lock();
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000265 if (import_lock == NULL)
266 return; /* Nothing much we can do. */
267 }
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000268 if (import_lock_thread == me) {
269 import_lock_level++;
270 return;
271 }
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000272 if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
273 {
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000274 PyThreadState *tstate = PyEval_SaveThread();
Guido van Rossum65d5b571998-12-21 19:32:43 +0000275 PyThread_acquire_lock(import_lock, 1);
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000276 PyEval_RestoreThread(tstate);
277 }
278 import_lock_thread = me;
279 import_lock_level = 1;
280}
281
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000282static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000283unlock_import(void)
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000284{
Guido van Rossum65d5b571998-12-21 19:32:43 +0000285 long me = PyThread_get_thread_ident();
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000286 if (me == -1 || import_lock == NULL)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000287 return 0; /* Too bad */
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000288 if (import_lock_thread != me)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000289 return -1;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000290 import_lock_level--;
291 if (import_lock_level == 0) {
292 import_lock_thread = -1;
Guido van Rossum65d5b571998-12-21 19:32:43 +0000293 PyThread_release_lock(import_lock);
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000294 }
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000295 return 1;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000296}
297
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +0000298/* This function is called from PyOS_AfterFork to ensure that newly
299 created child processes do not share locks with the parent. */
300
301void
302_PyImport_ReInitLock(void)
303{
304#ifdef _AIX
305 if (import_lock != NULL)
306 import_lock = PyThread_allocate_lock();
307#endif
308}
309
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000310#else
311
312#define lock_import()
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000313#define unlock_import() 0
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000314
315#endif
316
Tim Peters69232342001-08-30 05:16:13 +0000317static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000318imp_lock_held(PyObject *self, PyObject *noargs)
Tim Peters69232342001-08-30 05:16:13 +0000319{
Tim Peters69232342001-08-30 05:16:13 +0000320#ifdef WITH_THREAD
Guido van Rossumb8bff3f2002-04-07 06:34:38 +0000321 return PyBool_FromLong(import_lock_thread != -1);
Tim Peters69232342001-08-30 05:16:13 +0000322#else
Guido van Rossumb8bff3f2002-04-07 06:34:38 +0000323 return PyBool_FromLong(0);
Tim Peters69232342001-08-30 05:16:13 +0000324#endif
325}
326
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000327static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000328imp_acquire_lock(PyObject *self, PyObject *noargs)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000329{
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000330#ifdef WITH_THREAD
331 lock_import();
332#endif
Neal Norwitz2294c0d2003-02-12 23:02:21 +0000333 Py_INCREF(Py_None);
334 return Py_None;
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000335}
336
337static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000338imp_release_lock(PyObject *self, PyObject *noargs)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000339{
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000340#ifdef WITH_THREAD
341 if (unlock_import() < 0) {
342 PyErr_SetString(PyExc_RuntimeError,
343 "not holding the import lock");
344 return NULL;
345 }
346#endif
Neal Norwitz2294c0d2003-02-12 23:02:21 +0000347 Py_INCREF(Py_None);
348 return Py_None;
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000349}
350
Guido van Rossumd8faa362007-04-27 19:54:29 +0000351static void
352imp_modules_reloading_clear(void)
353{
354 PyInterpreterState *interp = PyThreadState_Get()->interp;
355 if (interp->modules_reloading != NULL)
356 PyDict_Clear(interp->modules_reloading);
357}
358
Guido van Rossum25ce5661997-08-02 03:10:38 +0000359/* Helper for sys */
360
361PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000362PyImport_GetModuleDict(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000363{
Nicholas Bastine5662ae2004-03-24 22:22:12 +0000364 PyInterpreterState *interp = PyThreadState_GET()->interp;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000365 if (interp->modules == NULL)
366 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
367 return interp->modules;
368}
369
Guido van Rossum3f5da241990-12-20 15:06:42 +0000370
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000371/* List of names to clear in sys */
372static char* sys_deletes[] = {
Collin Winter670e6922007-03-21 02:57:17 +0000373 "path", "argv", "ps1", "ps2",
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000374 "last_type", "last_value", "last_traceback",
Just van Rossum52e14d62002-12-30 22:08:05 +0000375 "path_hooks", "path_importer_cache", "meta_path",
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000376 NULL
377};
378
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000379static char* sys_files[] = {
380 "stdin", "__stdin__",
381 "stdout", "__stdout__",
382 "stderr", "__stderr__",
383 NULL
384};
385
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000386
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000387/* Un-initialize things, as good as we can */
Guido van Rossum3f5da241990-12-20 15:06:42 +0000388
Guido van Rossum3f5da241990-12-20 15:06:42 +0000389void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000390PyImport_Cleanup(void)
Guido van Rossum3f5da241990-12-20 15:06:42 +0000391{
Martin v. Löwis18e16552006-02-15 17:27:45 +0000392 Py_ssize_t pos, ndone;
Guido van Rossum758eec01998-01-19 21:58:26 +0000393 char *name;
394 PyObject *key, *value, *dict;
Nicholas Bastine5662ae2004-03-24 22:22:12 +0000395 PyInterpreterState *interp = PyThreadState_GET()->interp;
Guido van Rossum758eec01998-01-19 21:58:26 +0000396 PyObject *modules = interp->modules;
397
398 if (modules == NULL)
399 return; /* Already done */
400
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000401 /* Delete some special variables first. These are common
402 places where user values hide and people complain when their
403 destructors fail. Since the modules containing them are
404 deleted *last* of all, they would come too late in the normal
405 destruction order. Sigh. */
406
407 value = PyDict_GetItemString(modules, "__builtin__");
408 if (value != NULL && PyModule_Check(value)) {
409 dict = PyModule_GetDict(value);
410 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000411 PySys_WriteStderr("# clear __builtin__._\n");
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000412 PyDict_SetItemString(dict, "_", Py_None);
413 }
414 value = PyDict_GetItemString(modules, "sys");
415 if (value != NULL && PyModule_Check(value)) {
416 char **p;
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000417 PyObject *v;
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000418 dict = PyModule_GetDict(value);
419 for (p = sys_deletes; *p != NULL; p++) {
420 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000421 PySys_WriteStderr("# clear sys.%s\n", *p);
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000422 PyDict_SetItemString(dict, *p, Py_None);
423 }
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000424 for (p = sys_files; *p != NULL; p+=2) {
425 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000426 PySys_WriteStderr("# restore sys.%s\n", *p);
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000427 v = PyDict_GetItemString(dict, *(p+1));
428 if (v == NULL)
429 v = Py_None;
430 PyDict_SetItemString(dict, *p, v);
431 }
432 }
433
434 /* First, delete __main__ */
435 value = PyDict_GetItemString(modules, "__main__");
436 if (value != NULL && PyModule_Check(value)) {
437 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000438 PySys_WriteStderr("# cleanup __main__\n");
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000439 _PyModule_Clear(value);
440 PyDict_SetItemString(modules, "__main__", Py_None);
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000441 }
442
Guido van Rossum758eec01998-01-19 21:58:26 +0000443 /* The special treatment of __builtin__ here is because even
444 when it's not referenced as a module, its dictionary is
445 referenced by almost every module's __builtins__. Since
446 deleting a module clears its dictionary (even if there are
447 references left to it), we need to delete the __builtin__
448 module last. Likewise, we don't delete sys until the very
449 end because it is implicitly referenced (e.g. by print).
450
451 Also note that we 'delete' modules by replacing their entry
452 in the modules dict with None, rather than really deleting
453 them; this avoids a rehash of the modules dictionary and
454 also marks them as "non existent" so they won't be
455 re-imported. */
456
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000457 /* Next, repeatedly delete modules with a reference count of
Guido van Rossum758eec01998-01-19 21:58:26 +0000458 one (skipping __builtin__ and sys) and delete them */
459 do {
460 ndone = 0;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000461 pos = 0;
Guido van Rossum758eec01998-01-19 21:58:26 +0000462 while (PyDict_Next(modules, &pos, &key, &value)) {
463 if (value->ob_refcnt != 1)
464 continue;
Guido van Rossum566373e1998-10-01 15:24:50 +0000465 if (PyString_Check(key) && PyModule_Check(value)) {
466 name = PyString_AS_STRING(key);
Guido van Rossum758eec01998-01-19 21:58:26 +0000467 if (strcmp(name, "__builtin__") == 0)
468 continue;
469 if (strcmp(name, "sys") == 0)
470 continue;
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000471 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000472 PySys_WriteStderr(
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000473 "# cleanup[1] %s\n", name);
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000474 _PyModule_Clear(value);
Guido van Rossum758eec01998-01-19 21:58:26 +0000475 PyDict_SetItem(modules, key, Py_None);
476 ndone++;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000477 }
478 }
Guido van Rossum758eec01998-01-19 21:58:26 +0000479 } while (ndone > 0);
480
Guido van Rossum758eec01998-01-19 21:58:26 +0000481 /* Next, delete all modules (still skipping __builtin__ and sys) */
482 pos = 0;
483 while (PyDict_Next(modules, &pos, &key, &value)) {
Guido van Rossum566373e1998-10-01 15:24:50 +0000484 if (PyString_Check(key) && PyModule_Check(value)) {
485 name = PyString_AS_STRING(key);
Guido van Rossum758eec01998-01-19 21:58:26 +0000486 if (strcmp(name, "__builtin__") == 0)
487 continue;
488 if (strcmp(name, "sys") == 0)
489 continue;
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000490 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000491 PySys_WriteStderr("# cleanup[2] %s\n", name);
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000492 _PyModule_Clear(value);
Guido van Rossum758eec01998-01-19 21:58:26 +0000493 PyDict_SetItem(modules, key, Py_None);
494 }
495 }
496
497 /* Next, delete sys and __builtin__ (in that order) */
498 value = PyDict_GetItemString(modules, "sys");
499 if (value != NULL && PyModule_Check(value)) {
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000500 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000501 PySys_WriteStderr("# cleanup sys\n");
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000502 _PyModule_Clear(value);
Guido van Rossum758eec01998-01-19 21:58:26 +0000503 PyDict_SetItemString(modules, "sys", Py_None);
504 }
505 value = PyDict_GetItemString(modules, "__builtin__");
506 if (value != NULL && PyModule_Check(value)) {
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000507 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000508 PySys_WriteStderr("# cleanup __builtin__\n");
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000509 _PyModule_Clear(value);
Guido van Rossum758eec01998-01-19 21:58:26 +0000510 PyDict_SetItemString(modules, "__builtin__", Py_None);
511 }
512
513 /* Finally, clear and delete the modules directory */
514 PyDict_Clear(modules);
515 interp->modules = NULL;
516 Py_DECREF(modules);
Guido van Rossumd8faa362007-04-27 19:54:29 +0000517 Py_CLEAR(interp->modules_reloading);
Guido van Rossum8d15b5d1990-10-26 14:58:58 +0000518}
Guido van Rossum7f133ed1991-02-19 12:23:57 +0000519
520
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000521/* Helper for pythonrun.c -- return magic number */
522
523long
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000524PyImport_GetMagicNumber(void)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000525{
Guido van Rossum96774c12000-05-01 20:19:08 +0000526 return pyc_magic;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000527}
528
529
Guido van Rossum25ce5661997-08-02 03:10:38 +0000530/* Magic for extension modules (built-in as well as dynamically
531 loaded). To prevent initializing an extension module more than
532 once, we keep a static dictionary 'extensions' keyed by module name
533 (for built-in modules) or by filename (for dynamically loaded
Barry Warsaw92883382001-08-13 23:05:44 +0000534 modules), containing these modules. A copy of the module's
Guido van Rossum25ce5661997-08-02 03:10:38 +0000535 dictionary is stored by calling _PyImport_FixupExtension()
536 immediately after the module initialization function succeeds. A
537 copy can be retrieved from there by calling
538 _PyImport_FindExtension(). */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000539
Guido van Rossum79f25d91997-04-29 20:08:16 +0000540PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000541_PyImport_FixupExtension(char *name, char *filename)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000542{
Guido van Rossum25ce5661997-08-02 03:10:38 +0000543 PyObject *modules, *mod, *dict, *copy;
544 if (extensions == NULL) {
545 extensions = PyDict_New();
546 if (extensions == NULL)
547 return NULL;
548 }
549 modules = PyImport_GetModuleDict();
550 mod = PyDict_GetItemString(modules, name);
551 if (mod == NULL || !PyModule_Check(mod)) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000552 PyErr_Format(PyExc_SystemError,
553 "_PyImport_FixupExtension: module %.200s not loaded", name);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000554 return NULL;
555 }
556 dict = PyModule_GetDict(mod);
557 if (dict == NULL)
558 return NULL;
Fred Drake9cd0efc2001-10-25 21:38:59 +0000559 copy = PyDict_Copy(dict);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000560 if (copy == NULL)
561 return NULL;
562 PyDict_SetItemString(extensions, filename, copy);
563 Py_DECREF(copy);
564 return copy;
565}
566
567PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000568_PyImport_FindExtension(char *name, char *filename)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000569{
Fred Drake9cd0efc2001-10-25 21:38:59 +0000570 PyObject *dict, *mod, *mdict;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000571 if (extensions == NULL)
572 return NULL;
573 dict = PyDict_GetItemString(extensions, filename);
574 if (dict == NULL)
575 return NULL;
576 mod = PyImport_AddModule(name);
577 if (mod == NULL)
578 return NULL;
579 mdict = PyModule_GetDict(mod);
580 if (mdict == NULL)
581 return NULL;
Fred Drake9cd0efc2001-10-25 21:38:59 +0000582 if (PyDict_Update(mdict, dict))
Guido van Rossum25ce5661997-08-02 03:10:38 +0000583 return NULL;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000584 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000585 PySys_WriteStderr("import %s # previously loaded (%s)\n",
Guido van Rossum25ce5661997-08-02 03:10:38 +0000586 name, filename);
587 return mod;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000588}
589
590
591/* Get the module object corresponding to a module name.
592 First check the modules dictionary if there's one there,
Walter Dörwaldf0dfc7a2003-10-20 14:01:56 +0000593 if not, create a new one and insert it in the modules dictionary.
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000594 Because the former action is most common, THIS DOES NOT RETURN A
595 'NEW' REFERENCE! */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000596
Guido van Rossum79f25d91997-04-29 20:08:16 +0000597PyObject *
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000598PyImport_AddModule(const char *name)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000599{
Guido van Rossum25ce5661997-08-02 03:10:38 +0000600 PyObject *modules = PyImport_GetModuleDict();
Guido van Rossum79f25d91997-04-29 20:08:16 +0000601 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000602
Guido van Rossum25ce5661997-08-02 03:10:38 +0000603 if ((m = PyDict_GetItemString(modules, name)) != NULL &&
Guido van Rossum79f25d91997-04-29 20:08:16 +0000604 PyModule_Check(m))
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000605 return m;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000606 m = PyModule_New(name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000607 if (m == NULL)
608 return NULL;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000609 if (PyDict_SetItemString(modules, name, m) != 0) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000610 Py_DECREF(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000611 return NULL;
612 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000613 Py_DECREF(m); /* Yes, it still exists, in modules! */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000614
615 return m;
616}
617
Tim Peters1cd70172004-08-02 03:52:12 +0000618/* Remove name from sys.modules, if it's there. */
619static void
620_RemoveModule(const char *name)
621{
622 PyObject *modules = PyImport_GetModuleDict();
623 if (PyDict_GetItemString(modules, name) == NULL)
624 return;
625 if (PyDict_DelItemString(modules, name) < 0)
626 Py_FatalError("import: deleting existing key in"
627 "sys.modules failed");
628}
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000629
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000630/* Execute a code object in a module and return the module object
Tim Peters1cd70172004-08-02 03:52:12 +0000631 * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
632 * removed from sys.modules, to avoid leaving damaged module objects
633 * in sys.modules. The caller may wish to restore the original
634 * module object (if any) in this case; PyImport_ReloadModule is an
635 * example.
636 */
Guido van Rossum79f25d91997-04-29 20:08:16 +0000637PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000638PyImport_ExecCodeModule(char *name, PyObject *co)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000639{
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000640 return PyImport_ExecCodeModuleEx(name, co, (char *)NULL);
641}
642
643PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000644PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000645{
Guido van Rossum25ce5661997-08-02 03:10:38 +0000646 PyObject *modules = PyImport_GetModuleDict();
Guido van Rossum79f25d91997-04-29 20:08:16 +0000647 PyObject *m, *d, *v;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000648
Guido van Rossum79f25d91997-04-29 20:08:16 +0000649 m = PyImport_AddModule(name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000650 if (m == NULL)
651 return NULL;
Jeremy Hyltonecd91292004-01-02 23:25:32 +0000652 /* If the module is being reloaded, we get the old module back
653 and re-use its dict to exec the new code. */
Guido van Rossum79f25d91997-04-29 20:08:16 +0000654 d = PyModule_GetDict(m);
655 if (PyDict_GetItemString(d, "__builtins__") == NULL) {
656 if (PyDict_SetItemString(d, "__builtins__",
657 PyEval_GetBuiltins()) != 0)
Tim Peters1cd70172004-08-02 03:52:12 +0000658 goto error;
Guido van Rossum6135a871995-01-09 17:53:26 +0000659 }
Guido van Rossum9c9a07c1996-05-16 20:43:40 +0000660 /* Remember the filename as the __file__ attribute */
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000661 v = NULL;
662 if (pathname != NULL) {
663 v = PyString_FromString(pathname);
664 if (v == NULL)
665 PyErr_Clear();
666 }
667 if (v == NULL) {
668 v = ((PyCodeObject *)co)->co_filename;
669 Py_INCREF(v);
670 }
671 if (PyDict_SetItemString(d, "__file__", v) != 0)
Guido van Rossum79f25d91997-04-29 20:08:16 +0000672 PyErr_Clear(); /* Not important enough to report */
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000673 Py_DECREF(v);
674
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000675 v = PyEval_EvalCode((PyCodeObject *)co, d, d);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000676 if (v == NULL)
Tim Peters1cd70172004-08-02 03:52:12 +0000677 goto error;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000678 Py_DECREF(v);
Guido van Rossumb65e85c1997-07-10 18:00:45 +0000679
Guido van Rossum25ce5661997-08-02 03:10:38 +0000680 if ((m = PyDict_GetItemString(modules, name)) == NULL) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000681 PyErr_Format(PyExc_ImportError,
682 "Loaded module %.200s not found in sys.modules",
683 name);
Guido van Rossumb65e85c1997-07-10 18:00:45 +0000684 return NULL;
685 }
686
Guido van Rossum79f25d91997-04-29 20:08:16 +0000687 Py_INCREF(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000688
689 return m;
Tim Peters1cd70172004-08-02 03:52:12 +0000690
691 error:
692 _RemoveModule(name);
693 return NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000694}
695
696
697/* Given a pathname for a Python source file, fill a buffer with the
698 pathname for the corresponding compiled file. Return the pathname
699 for the compiled file, or NULL if there's no space in the buffer.
700 Doesn't set an exception. */
701
702static char *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000703make_compiled_pathname(char *pathname, char *buf, size_t buflen)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000704{
Tim Petersc1731372001-08-04 08:12:36 +0000705 size_t len = strlen(pathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000706 if (len+2 > buflen)
707 return NULL;
Tim Petersc1731372001-08-04 08:12:36 +0000708
Martin v. Löwis6238d2b2002-06-30 15:26:10 +0000709#ifdef MS_WINDOWS
Tim Petersc1731372001-08-04 08:12:36 +0000710 /* Treat .pyw as if it were .py. The case of ".pyw" must match
711 that used in _PyImport_StandardFiletab. */
712 if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0)
713 --len; /* pretend 'w' isn't there */
714#endif
715 memcpy(buf, pathname, len);
716 buf[len] = Py_OptimizeFlag ? 'o' : 'c';
717 buf[len+1] = '\0';
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000718
719 return buf;
720}
721
722
723/* Given a pathname for a Python source file, its time of last
724 modification, and a pathname for a compiled file, check whether the
725 compiled file represents the same version of the source. If so,
726 return a FILE pointer for the compiled file, positioned just after
727 the header; if not, return NULL.
728 Doesn't set an exception. */
729
730static FILE *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000731check_compiled_module(char *pathname, time_t mtime, char *cpathname)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000732{
733 FILE *fp;
734 long magic;
735 long pyc_mtime;
736
737 fp = fopen(cpathname, "rb");
738 if (fp == NULL)
739 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000740 magic = PyMarshal_ReadLongFromFile(fp);
Guido van Rossum96774c12000-05-01 20:19:08 +0000741 if (magic != pyc_magic) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000742 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000743 PySys_WriteStderr("# %s has bad magic\n", cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000744 fclose(fp);
745 return NULL;
746 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000747 pyc_mtime = PyMarshal_ReadLongFromFile(fp);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000748 if (pyc_mtime != mtime) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000749 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000750 PySys_WriteStderr("# %s has bad mtime\n", cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000751 fclose(fp);
752 return NULL;
753 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000754 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000755 PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000756 return fp;
757}
758
759
760/* Read a code object from a file and check it for validity */
761
Guido van Rossum79f25d91997-04-29 20:08:16 +0000762static PyCodeObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000763read_compiled_module(char *cpathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000764{
Guido van Rossum79f25d91997-04-29 20:08:16 +0000765 PyObject *co;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000766
Tim Petersd9b9ac82001-01-28 00:27:39 +0000767 co = PyMarshal_ReadLastObjectFromFile(fp);
Armin Rigo01ab2792004-03-26 15:09:27 +0000768 if (co == NULL)
769 return NULL;
770 if (!PyCode_Check(co)) {
771 PyErr_Format(PyExc_ImportError,
772 "Non-code object in %.200s", cpathname);
773 Py_DECREF(co);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000774 return NULL;
775 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000776 return (PyCodeObject *)co;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000777}
778
779
780/* Load a module from a compiled file, execute it, and return its
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000781 module object WITH INCREMENTED REFERENCE COUNT */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000782
Guido van Rossum79f25d91997-04-29 20:08:16 +0000783static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000784load_compiled_module(char *name, char *cpathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000785{
786 long magic;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000787 PyCodeObject *co;
788 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000789
Guido van Rossum79f25d91997-04-29 20:08:16 +0000790 magic = PyMarshal_ReadLongFromFile(fp);
Guido van Rossum96774c12000-05-01 20:19:08 +0000791 if (magic != pyc_magic) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000792 PyErr_Format(PyExc_ImportError,
793 "Bad magic number in %.200s", cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000794 return NULL;
795 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000796 (void) PyMarshal_ReadLongFromFile(fp);
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000797 co = read_compiled_module(cpathname, fp);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000798 if (co == NULL)
799 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000800 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000801 PySys_WriteStderr("import %s # precompiled from %s\n",
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000802 name, cpathname);
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000803 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000804 Py_DECREF(co);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000805
806 return m;
807}
808
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000809/* Parse a source file and return the corresponding code object */
810
Guido van Rossum79f25d91997-04-29 20:08:16 +0000811static PyCodeObject *
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000812parse_source_module(const char *pathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000813{
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000814 PyCodeObject *co = NULL;
815 mod_ty mod;
Thomas Wouters89f507f2006-12-13 04:49:30 +0000816 PyArena *arena = PyArena_New();
817 if (arena == NULL)
818 return NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000819
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000820 mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, 0,
Neal Norwitzadb69fc2005-12-17 20:54:49 +0000821 NULL, arena);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000822 if (mod) {
Neal Norwitzadb69fc2005-12-17 20:54:49 +0000823 co = PyAST_Compile(mod, pathname, NULL, arena);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000824 }
Thomas Wouters89f507f2006-12-13 04:49:30 +0000825 PyArena_Free(arena);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000826 return co;
827}
828
829
Guido van Rossum55a83382000-09-20 20:31:38 +0000830/* Helper to open a bytecode file for writing in exclusive mode */
831
832static FILE *
833open_exclusive(char *filename)
834{
835#if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
836 /* Use O_EXCL to avoid a race condition when another process tries to
837 write the same file. When that happens, our open() call fails,
838 which is just fine (since it's only a cache).
839 XXX If the file exists and is writable but the directory is not
840 writable, the file will never be written. Oh well.
841 */
842 int fd;
843 (void) unlink(filename);
Tim Peters42c83af2000-09-29 04:03:10 +0000844 fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC
845#ifdef O_BINARY
846 |O_BINARY /* necessary for Windows */
847#endif
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000848#ifdef __VMS
Martin v. Löwis18e16552006-02-15 17:27:45 +0000849 , 0666, "ctxt=bin", "shr=nil"
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000850#else
Martin v. Löwis18e16552006-02-15 17:27:45 +0000851 , 0666
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000852#endif
Martin v. Löwis18e16552006-02-15 17:27:45 +0000853 );
Guido van Rossum55a83382000-09-20 20:31:38 +0000854 if (fd < 0)
855 return NULL;
856 return fdopen(fd, "wb");
857#else
858 /* Best we can do -- on Windows this can't happen anyway */
859 return fopen(filename, "wb");
860#endif
861}
862
863
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000864/* Write a compiled module to a file, placing the time of last
865 modification of its source into the header.
866 Errors are ignored, if a write error occurs an attempt is made to
867 remove the file. */
868
869static void
Martin v. Löwis18e16552006-02-15 17:27:45 +0000870write_compiled_module(PyCodeObject *co, char *cpathname, time_t mtime)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000871{
872 FILE *fp;
873
Guido van Rossum55a83382000-09-20 20:31:38 +0000874 fp = open_exclusive(cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000875 if (fp == NULL) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000876 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000877 PySys_WriteStderr(
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000878 "# can't create %s\n", cpathname);
879 return;
880 }
Martin v. Löwisef82d2f2004-06-27 16:51:46 +0000881 PyMarshal_WriteLongToFile(pyc_magic, fp, Py_MARSHAL_VERSION);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000882 /* First write a 0 for mtime */
Martin v. Löwisef82d2f2004-06-27 16:51:46 +0000883 PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
884 PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
Armin Rigo01ab2792004-03-26 15:09:27 +0000885 if (fflush(fp) != 0 || ferror(fp)) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000886 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000887 PySys_WriteStderr("# can't write %s\n", cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000888 /* Don't keep partial file */
889 fclose(fp);
890 (void) unlink(cpathname);
891 return;
892 }
893 /* Now write the true mtime */
894 fseek(fp, 4L, 0);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000895 assert(mtime < LONG_MAX);
Martin v. Löwis725507b2006-03-07 12:08:51 +0000896 PyMarshal_WriteLongToFile((long)mtime, fp, Py_MARSHAL_VERSION);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000897 fflush(fp);
898 fclose(fp);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000899 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000900 PySys_WriteStderr("# wrote %s\n", cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000901}
902
903
904/* Load a source module from a given file and return its module
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000905 object WITH INCREMENTED REFERENCE COUNT. If there's a matching
906 byte-compiled file, use that instead. */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000907
Guido van Rossum79f25d91997-04-29 20:08:16 +0000908static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000909load_source_module(char *name, char *pathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000910{
Fred Drake4c82b232000-06-30 16:18:57 +0000911 time_t mtime;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000912 FILE *fpc;
913 char buf[MAXPATHLEN+1];
914 char *cpathname;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000915 PyCodeObject *co;
916 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000917
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000918 mtime = PyOS_GetLastModificationTime(pathname, fp);
Neal Norwitz708e51a2005-10-03 04:48:15 +0000919 if (mtime == (time_t)(-1)) {
920 PyErr_Format(PyExc_RuntimeError,
921 "unable to get modification time from '%s'",
922 pathname);
Fred Drake4c82b232000-06-30 16:18:57 +0000923 return NULL;
Neal Norwitz708e51a2005-10-03 04:48:15 +0000924 }
Fred Drake4c82b232000-06-30 16:18:57 +0000925#if SIZEOF_TIME_T > 4
926 /* Python's .pyc timestamp handling presumes that the timestamp fits
927 in 4 bytes. This will be fine until sometime in the year 2038,
928 when a 4-byte signed time_t will overflow.
929 */
930 if (mtime >> 32) {
931 PyErr_SetString(PyExc_OverflowError,
Fred Drakec63d3e92001-03-01 06:33:32 +0000932 "modification time overflows a 4 byte field");
Fred Drake4c82b232000-06-30 16:18:57 +0000933 return NULL;
934 }
935#endif
Tim Peters36515e22001-11-18 04:06:29 +0000936 cpathname = make_compiled_pathname(pathname, buf,
Jeremy Hylton37832f02001-04-13 17:50:20 +0000937 (size_t)MAXPATHLEN + 1);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000938 if (cpathname != NULL &&
939 (fpc = check_compiled_module(pathname, mtime, cpathname))) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000940 co = read_compiled_module(cpathname, fpc);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000941 fclose(fpc);
942 if (co == NULL)
943 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000944 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000945 PySys_WriteStderr("import %s # precompiled from %s\n",
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000946 name, cpathname);
Guido van Rossumafd3dae1998-08-25 18:44:34 +0000947 pathname = cpathname;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000948 }
949 else {
950 co = parse_source_module(pathname, fp);
951 if (co == NULL)
952 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000953 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000954 PySys_WriteStderr("import %s # from %s\n",
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000955 name, pathname);
Thomas Wouters00ee7ba2006-08-21 19:07:27 +0000956 if (cpathname)
957 write_compiled_module(co, cpathname, mtime);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000958 }
Guido van Rossumafd3dae1998-08-25 18:44:34 +0000959 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, pathname);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000960 Py_DECREF(co);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000961
962 return m;
963}
964
965
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000966/* Forward */
Just van Rossum52e14d62002-12-30 22:08:05 +0000967static PyObject *load_module(char *, FILE *, char *, int, PyObject *);
968static struct filedescr *find_module(char *, char *, PyObject *,
969 char *, size_t, FILE **, PyObject **);
Tim Petersdbd9ba62000-07-09 03:09:57 +0000970static struct _frozen *find_frozen(char *name);
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000971
972/* Load a package and return its module object WITH INCREMENTED
973 REFERENCE COUNT */
974
975static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000976load_package(char *name, char *pathname)
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000977{
Tim Peters1cd70172004-08-02 03:52:12 +0000978 PyObject *m, *d;
979 PyObject *file = NULL;
980 PyObject *path = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000981 int err;
982 char buf[MAXPATHLEN+1];
983 FILE *fp = NULL;
984 struct filedescr *fdp;
985
986 m = PyImport_AddModule(name);
987 if (m == NULL)
988 return NULL;
Guido van Rossum17fc85f1997-09-06 18:52:03 +0000989 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000990 PySys_WriteStderr("import %s # directory %s\n",
Guido van Rossum17fc85f1997-09-06 18:52:03 +0000991 name, pathname);
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000992 d = PyModule_GetDict(m);
993 file = PyString_FromString(pathname);
994 if (file == NULL)
Tim Peters1cd70172004-08-02 03:52:12 +0000995 goto error;
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000996 path = Py_BuildValue("[O]", file);
Tim Peters1cd70172004-08-02 03:52:12 +0000997 if (path == NULL)
998 goto error;
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000999 err = PyDict_SetItemString(d, "__file__", file);
1000 if (err == 0)
1001 err = PyDict_SetItemString(d, "__path__", path);
Tim Peters1cd70172004-08-02 03:52:12 +00001002 if (err != 0)
1003 goto error;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001004 buf[0] = '\0';
Just van Rossum52e14d62002-12-30 22:08:05 +00001005 fdp = find_module(name, "__init__", path, buf, sizeof(buf), &fp, NULL);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001006 if (fdp == NULL) {
1007 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1008 PyErr_Clear();
Thomas Heller25653242004-06-07 15:04:10 +00001009 Py_INCREF(m);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001010 }
1011 else
1012 m = NULL;
1013 goto cleanup;
1014 }
Just van Rossum52e14d62002-12-30 22:08:05 +00001015 m = load_module(name, fp, buf, fdp->type, NULL);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001016 if (fp != NULL)
1017 fclose(fp);
Tim Peters1cd70172004-08-02 03:52:12 +00001018 goto cleanup;
1019
1020 error:
1021 m = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001022 cleanup:
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001023 Py_XDECREF(path);
1024 Py_XDECREF(file);
1025 return m;
1026}
1027
1028
1029/* Helper to test for built-in module */
1030
1031static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001032is_builtin(char *name)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001033{
1034 int i;
Guido van Rossum771c6c81997-10-31 18:37:24 +00001035 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
1036 if (strcmp(name, PyImport_Inittab[i].name) == 0) {
1037 if (PyImport_Inittab[i].initfunc == NULL)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001038 return -1;
1039 else
1040 return 1;
1041 }
1042 }
1043 return 0;
1044}
1045
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001046
Just van Rossum52e14d62002-12-30 22:08:05 +00001047/* Return an importer object for a sys.path/pkg.__path__ item 'p',
1048 possibly by fetching it from the path_importer_cache dict. If it
Thomas Wouters89f507f2006-12-13 04:49:30 +00001049 wasn't yet cached, traverse path_hooks until a hook is found
Just van Rossum52e14d62002-12-30 22:08:05 +00001050 that can handle the path item. Return None if no hook could;
1051 this tells our caller it should fall back to the builtin
1052 import mechanism. Cache the result in path_importer_cache.
1053 Returns a borrowed reference. */
1054
1055static PyObject *
1056get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,
1057 PyObject *p)
1058{
1059 PyObject *importer;
Martin v. Löwis725507b2006-03-07 12:08:51 +00001060 Py_ssize_t j, nhooks;
Just van Rossum52e14d62002-12-30 22:08:05 +00001061
1062 /* These conditions are the caller's responsibility: */
1063 assert(PyList_Check(path_hooks));
1064 assert(PyDict_Check(path_importer_cache));
1065
1066 nhooks = PyList_Size(path_hooks);
1067 if (nhooks < 0)
1068 return NULL; /* Shouldn't happen */
1069
1070 importer = PyDict_GetItem(path_importer_cache, p);
1071 if (importer != NULL)
1072 return importer;
1073
1074 /* set path_importer_cache[p] to None to avoid recursion */
1075 if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
1076 return NULL;
1077
1078 for (j = 0; j < nhooks; j++) {
1079 PyObject *hook = PyList_GetItem(path_hooks, j);
1080 if (hook == NULL)
1081 return NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001082 importer = PyObject_CallFunctionObjArgs(hook, p, NULL);
Just van Rossum52e14d62002-12-30 22:08:05 +00001083 if (importer != NULL)
1084 break;
1085
1086 if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
1087 return NULL;
1088 }
1089 PyErr_Clear();
1090 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001091 if (importer == NULL) {
1092 importer = PyObject_CallFunctionObjArgs(
1093 (PyObject *)&NullImporterType, p, NULL
1094 );
1095 if (importer == NULL) {
1096 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1097 PyErr_Clear();
1098 return Py_None;
1099 }
1100 }
1101 }
1102 if (importer != NULL) {
Just van Rossum52e14d62002-12-30 22:08:05 +00001103 int err = PyDict_SetItem(path_importer_cache, p, importer);
1104 Py_DECREF(importer);
1105 if (err != 0)
1106 return NULL;
1107 }
1108 return importer;
1109}
1110
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001111/* Search the path (default sys.path) for a module. Return the
1112 corresponding filedescr struct, and (via return arguments) the
1113 pathname and an open file. Return NULL if the module is not found. */
1114
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001115#ifdef MS_COREDLL
Thomas Woutersb4bd21c2000-07-22 23:38:01 +00001116extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **,
Martin v. Löwis18e16552006-02-15 17:27:45 +00001117 char *, Py_ssize_t);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001118#endif
1119
Martin v. Löwis18e16552006-02-15 17:27:45 +00001120static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *);
Tim Petersdbd9ba62000-07-09 03:09:57 +00001121static int find_init_module(char *); /* Forward */
Just van Rossum52e14d62002-12-30 22:08:05 +00001122static struct filedescr importhookdescr = {"", "", IMP_HOOK};
Guido van Rossum197346f1997-10-31 18:38:52 +00001123
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001124static struct filedescr *
Just van Rossum52e14d62002-12-30 22:08:05 +00001125find_module(char *fullname, char *subname, PyObject *path, char *buf,
1126 size_t buflen, FILE **p_fp, PyObject **p_loader)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001127{
Martin v. Löwis725507b2006-03-07 12:08:51 +00001128 Py_ssize_t i, npath;
Fred Drake4c82b232000-06-30 16:18:57 +00001129 size_t len, namelen;
Guido van Rossum80bb9651996-12-05 23:27:02 +00001130 struct filedescr *fdp = NULL;
Jack Jansenc88da1f2002-05-28 10:58:19 +00001131 char *filemode;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001132 FILE *fp = NULL;
Just van Rossum52e14d62002-12-30 22:08:05 +00001133 PyObject *path_hooks, *path_importer_cache;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001134#ifndef RISCOS
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001135 struct stat statbuf;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001136#endif
Guido van Rossuma5568d31998-03-05 03:45:08 +00001137 static struct filedescr fd_frozen = {"", "", PY_FROZEN};
1138 static struct filedescr fd_builtin = {"", "", C_BUILTIN};
1139 static struct filedescr fd_package = {"", "", PKG_DIRECTORY};
Guido van Rossum0506a431998-08-11 15:07:39 +00001140 char name[MAXPATHLEN+1];
Andrew MacIntyred9400542002-02-26 11:41:34 +00001141#if defined(PYOS_OS2)
1142 size_t saved_len;
1143 size_t saved_namelen;
1144 char *saved_buf = NULL;
1145#endif
Just van Rossum52e14d62002-12-30 22:08:05 +00001146 if (p_loader != NULL)
1147 *p_loader = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001148
Just van Rossum52e14d62002-12-30 22:08:05 +00001149 if (strlen(subname) > MAXPATHLEN) {
Guido van Rossum8f4d3312001-10-18 18:54:11 +00001150 PyErr_SetString(PyExc_OverflowError,
1151 "module name is too long");
Fred Drake4c82b232000-06-30 16:18:57 +00001152 return NULL;
1153 }
Just van Rossum52e14d62002-12-30 22:08:05 +00001154 strcpy(name, subname);
1155
1156 /* sys.meta_path import hook */
1157 if (p_loader != NULL) {
1158 PyObject *meta_path;
1159
1160 meta_path = PySys_GetObject("meta_path");
1161 if (meta_path == NULL || !PyList_Check(meta_path)) {
1162 PyErr_SetString(PyExc_ImportError,
1163 "sys.meta_path must be a list of "
1164 "import hooks");
1165 return NULL;
1166 }
1167 Py_INCREF(meta_path); /* zap guard */
1168 npath = PyList_Size(meta_path);
1169 for (i = 0; i < npath; i++) {
1170 PyObject *loader;
1171 PyObject *hook = PyList_GetItem(meta_path, i);
1172 loader = PyObject_CallMethod(hook, "find_module",
1173 "sO", fullname,
1174 path != NULL ?
1175 path : Py_None);
1176 if (loader == NULL) {
1177 Py_DECREF(meta_path);
1178 return NULL; /* true error */
1179 }
1180 if (loader != Py_None) {
1181 /* a loader was found */
1182 *p_loader = loader;
1183 Py_DECREF(meta_path);
1184 return &importhookdescr;
1185 }
1186 Py_DECREF(loader);
1187 }
1188 Py_DECREF(meta_path);
1189 }
Guido van Rossum0506a431998-08-11 15:07:39 +00001190
1191 if (path != NULL && PyString_Check(path)) {
Guido van Rossum8f4d3312001-10-18 18:54:11 +00001192 /* The only type of submodule allowed inside a "frozen"
1193 package are other frozen modules or packages. */
Guido van Rossum0506a431998-08-11 15:07:39 +00001194 if (PyString_Size(path) + 1 + strlen(name) >= (size_t)buflen) {
1195 PyErr_SetString(PyExc_ImportError,
1196 "full frozen module name too long");
1197 return NULL;
1198 }
1199 strcpy(buf, PyString_AsString(path));
1200 strcat(buf, ".");
1201 strcat(buf, name);
1202 strcpy(name, buf);
Guido van Rossum8f4d3312001-10-18 18:54:11 +00001203 if (find_frozen(name) != NULL) {
1204 strcpy(buf, name);
1205 return &fd_frozen;
1206 }
1207 PyErr_Format(PyExc_ImportError,
1208 "No frozen submodule named %.200s", name);
1209 return NULL;
Guido van Rossum0506a431998-08-11 15:07:39 +00001210 }
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001211 if (path == NULL) {
1212 if (is_builtin(name)) {
Guido van Rossuma5568d31998-03-05 03:45:08 +00001213 strcpy(buf, name);
1214 return &fd_builtin;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001215 }
Greg Ward201baee2001-10-04 14:52:06 +00001216 if ((find_frozen(name)) != NULL) {
Guido van Rossuma5568d31998-03-05 03:45:08 +00001217 strcpy(buf, name);
1218 return &fd_frozen;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001219 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001220
Guido van Rossumac279101996-08-22 23:10:58 +00001221#ifdef MS_COREDLL
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001222 fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen);
1223 if (fp != NULL) {
1224 *p_fp = fp;
1225 return fdp;
1226 }
Guido van Rossuma5a3db71996-04-09 02:39:59 +00001227#endif
Guido van Rossuma5568d31998-03-05 03:45:08 +00001228 path = PySys_GetObject("path");
1229 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00001230 if (path == NULL || !PyList_Check(path)) {
1231 PyErr_SetString(PyExc_ImportError,
Guido van Rossuma5568d31998-03-05 03:45:08 +00001232 "sys.path must be a list of directory names");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001233 return NULL;
1234 }
Just van Rossum52e14d62002-12-30 22:08:05 +00001235
1236 path_hooks = PySys_GetObject("path_hooks");
1237 if (path_hooks == NULL || !PyList_Check(path_hooks)) {
1238 PyErr_SetString(PyExc_ImportError,
1239 "sys.path_hooks must be a list of "
1240 "import hooks");
1241 return NULL;
1242 }
1243 path_importer_cache = PySys_GetObject("path_importer_cache");
1244 if (path_importer_cache == NULL ||
1245 !PyDict_Check(path_importer_cache)) {
1246 PyErr_SetString(PyExc_ImportError,
1247 "sys.path_importer_cache must be a dict");
1248 return NULL;
1249 }
1250
Guido van Rossum79f25d91997-04-29 20:08:16 +00001251 npath = PyList_Size(path);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001252 namelen = strlen(name);
1253 for (i = 0; i < npath; i++) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001254 PyObject *v = PyList_GetItem(path, i);
Guido van Rossumf15a29f2007-05-04 00:41:39 +00001255 PyObject *origv = v;
Guido van Rossum6262cc72007-05-09 23:29:27 +00001256 const char *base;
Guido van Rossumf15a29f2007-05-04 00:41:39 +00001257 Py_ssize_t size;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001258 if (!v)
1259 return NULL;
Guido van Rossum6262cc72007-05-09 23:29:27 +00001260 if (PyObject_AsCharBuffer(v, &base, &size) < 0)
1261 return NULL;
Guido van Rossumf15a29f2007-05-04 00:41:39 +00001262 len = size;
Walter Dörwald3430d702002-06-17 10:43:59 +00001263 if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001264 continue; /* Too long */
Walter Dörwald3430d702002-06-17 10:43:59 +00001265 }
Guido van Rossumf15a29f2007-05-04 00:41:39 +00001266 strcpy(buf, base);
Walter Dörwald3430d702002-06-17 10:43:59 +00001267 if (strlen(buf) != len) {
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001268 continue; /* v contains '\0' */
Walter Dörwald3430d702002-06-17 10:43:59 +00001269 }
Just van Rossum52e14d62002-12-30 22:08:05 +00001270
1271 /* sys.path_hooks import hook */
1272 if (p_loader != NULL) {
1273 PyObject *importer;
1274
1275 importer = get_path_importer(path_importer_cache,
Guido van Rossumf15a29f2007-05-04 00:41:39 +00001276 path_hooks, origv);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001277 if (importer == NULL) {
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001278 return NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001279 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001280 /* Note: importer is a borrowed reference */
1281 if (importer != Py_None) {
Just van Rossum52e14d62002-12-30 22:08:05 +00001282 PyObject *loader;
1283 loader = PyObject_CallMethod(importer,
1284 "find_module",
1285 "s", fullname);
1286 if (loader == NULL)
1287 return NULL; /* error */
1288 if (loader != Py_None) {
1289 /* a loader was found */
1290 *p_loader = loader;
1291 return &importhookdescr;
1292 }
1293 Py_DECREF(loader);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001294 continue;
Just van Rossum52e14d62002-12-30 22:08:05 +00001295 }
Just van Rossum52e14d62002-12-30 22:08:05 +00001296 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00001297 /* no hook was found, use builtin import */
Just van Rossum52e14d62002-12-30 22:08:05 +00001298
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001299 if (len > 0 && buf[len-1] != SEP
1300#ifdef ALTSEP
1301 && buf[len-1] != ALTSEP
1302#endif
1303 )
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001304 buf[len++] = SEP;
Guido van Rossum215c3402000-11-13 17:26:32 +00001305 strcpy(buf+len, name);
1306 len += namelen;
Tim Peters50d8d372001-02-28 05:34:27 +00001307
1308 /* Check for package import (buf holds a directory name,
1309 and there's an __init__ module in that directory */
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001310#ifdef HAVE_STAT
Walter Dörwald3430d702002-06-17 10:43:59 +00001311 if (stat(buf, &statbuf) == 0 && /* it exists */
1312 S_ISDIR(statbuf.st_mode) && /* it's a directory */
Thomas Wouters477c8d52006-05-27 19:21:47 +00001313 case_ok(buf, len, namelen, name)) { /* case matches */
1314 if (find_init_module(buf)) { /* and has __init__.py */
Thomas Wouters477c8d52006-05-27 19:21:47 +00001315 return &fd_package;
1316 }
1317 else {
1318 char warnstr[MAXPATHLEN+80];
1319 sprintf(warnstr, "Not importing directory "
1320 "'%.*s': missing __init__.py",
1321 MAXPATHLEN, buf);
1322 if (PyErr_Warn(PyExc_ImportWarning,
1323 warnstr)) {
Thomas Wouters477c8d52006-05-27 19:21:47 +00001324 return NULL;
1325 }
1326 }
Walter Dörwald3430d702002-06-17 10:43:59 +00001327 }
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001328#else
1329 /* XXX How are you going to test for directories? */
Guido van Rossum48a680c2001-03-02 06:34:14 +00001330#ifdef RISCOS
Guido van Rossume2ae77b2001-10-24 20:42:55 +00001331 if (isdir(buf) &&
Walter Dörwald3430d702002-06-17 10:43:59 +00001332 case_ok(buf, len, namelen, name)) {
Thomas Wouters477c8d52006-05-27 19:21:47 +00001333 if (find_init_module(buf)) {
Thomas Wouters477c8d52006-05-27 19:21:47 +00001334 return &fd_package;
1335 }
1336 else {
1337 char warnstr[MAXPATHLEN+80];
1338 sprintf(warnstr, "Not importing directory "
1339 "'%.*s': missing __init__.py",
1340 MAXPATHLEN, buf);
1341 if (PyErr_Warn(PyExc_ImportWarning,
1342 warnstr)) {
Thomas Wouters477c8d52006-05-27 19:21:47 +00001343 return NULL;
1344 }
Walter Dörwald3430d702002-06-17 10:43:59 +00001345 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00001346#endif
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001347#endif
Andrew MacIntyred9400542002-02-26 11:41:34 +00001348#if defined(PYOS_OS2)
1349 /* take a snapshot of the module spec for restoration
1350 * after the 8 character DLL hackery
1351 */
1352 saved_buf = strdup(buf);
1353 saved_len = len;
1354 saved_namelen = namelen;
1355#endif /* PYOS_OS2 */
Guido van Rossum79f25d91997-04-29 20:08:16 +00001356 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
Andrew MacIntyred9400542002-02-26 11:41:34 +00001357#if defined(PYOS_OS2)
Jeremy Hylton4ae6fae2002-05-30 17:15:25 +00001358 /* OS/2 limits DLLs to 8 character names (w/o
1359 extension)
Andrew MacIntyred9400542002-02-26 11:41:34 +00001360 * so if the name is longer than that and its a
1361 * dynamically loaded module we're going to try,
1362 * truncate the name before trying
1363 */
Just van Rossum52e14d62002-12-30 22:08:05 +00001364 if (strlen(subname) > 8) {
Andrew MacIntyred9400542002-02-26 11:41:34 +00001365 /* is this an attempt to load a C extension? */
Jeremy Hylton4ae6fae2002-05-30 17:15:25 +00001366 const struct filedescr *scan;
1367 scan = _PyImport_DynLoadFiletab;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001368 while (scan->suffix != NULL) {
Jeremy Hylton4ae6fae2002-05-30 17:15:25 +00001369 if (!strcmp(scan->suffix, fdp->suffix))
Andrew MacIntyred9400542002-02-26 11:41:34 +00001370 break;
1371 else
1372 scan++;
1373 }
1374 if (scan->suffix != NULL) {
1375 /* yes, so truncate the name */
1376 namelen = 8;
Just van Rossum52e14d62002-12-30 22:08:05 +00001377 len -= strlen(subname) - namelen;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001378 buf[len] = '\0';
1379 }
1380 }
1381#endif /* PYOS_OS2 */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001382 strcpy(buf+len, fdp->suffix);
Guido van Rossum79f25d91997-04-29 20:08:16 +00001383 if (Py_VerboseFlag > 1)
Guido van Rossum2f3667a1998-10-12 18:23:55 +00001384 PySys_WriteStderr("# trying %s\n", buf);
Jack Jansenc88da1f2002-05-28 10:58:19 +00001385 filemode = fdp->mode;
Tim Peters86c7d2f2004-08-01 23:24:21 +00001386 if (filemode[0] == 'U')
Jeremy Hylton4ae6fae2002-05-30 17:15:25 +00001387 filemode = "r" PY_STDIOTEXTMODE;
Jack Jansenc88da1f2002-05-28 10:58:19 +00001388 fp = fopen(buf, filemode);
Tim Peters50d8d372001-02-28 05:34:27 +00001389 if (fp != NULL) {
1390 if (case_ok(buf, len, namelen, name))
1391 break;
1392 else { /* continue search */
1393 fclose(fp);
1394 fp = NULL;
Barry Warsaw914a0b12001-02-02 19:12:16 +00001395 }
Barry Warsaw914a0b12001-02-02 19:12:16 +00001396 }
Andrew MacIntyred9400542002-02-26 11:41:34 +00001397#if defined(PYOS_OS2)
1398 /* restore the saved snapshot */
1399 strcpy(buf, saved_buf);
1400 len = saved_len;
1401 namelen = saved_namelen;
1402#endif
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001403 }
Andrew MacIntyred9400542002-02-26 11:41:34 +00001404#if defined(PYOS_OS2)
1405 /* don't need/want the module name snapshot anymore */
1406 if (saved_buf)
1407 {
1408 free(saved_buf);
1409 saved_buf = NULL;
1410 }
1411#endif
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001412 if (fp != NULL)
1413 break;
1414 }
1415 if (fp == NULL) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001416 PyErr_Format(PyExc_ImportError,
1417 "No module named %.200s", name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001418 return NULL;
1419 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001420 *p_fp = fp;
1421 return fdp;
1422}
1423
Raymond Hettingerdb29e0f2004-10-07 06:46:25 +00001424/* Helpers for main.c
1425 * Find the source file corresponding to a named module
1426 */
1427struct filedescr *
1428_PyImport_FindModule(const char *name, PyObject *path, char *buf,
1429 size_t buflen, FILE **p_fp, PyObject **p_loader)
1430{
1431 return find_module((char *) name, (char *) name, path,
1432 buf, buflen, p_fp, p_loader);
1433}
1434
1435PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr * fd)
1436{
1437 return fd->type == PY_SOURCE || fd->type == PY_COMPILED;
1438}
1439
Martin v. Löwis18e16552006-02-15 17:27:45 +00001440/* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
Tim Petersd1e87a82001-03-01 18:12:00 +00001441 * The arguments here are tricky, best shown by example:
1442 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1443 * ^ ^ ^ ^
1444 * |--------------------- buf ---------------------|
1445 * |------------------- len ------------------|
1446 * |------ name -------|
1447 * |----- namelen -----|
1448 * buf is the full path, but len only counts up to (& exclusive of) the
1449 * extension. name is the module name, also exclusive of extension.
1450 *
1451 * We've already done a successful stat() or fopen() on buf, so know that
1452 * there's some match, possibly case-insensitive.
1453 *
Tim Peters50d8d372001-02-28 05:34:27 +00001454 * case_ok() is to return 1 if there's a case-sensitive match for
1455 * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK
1456 * exists.
Tim Petersd1e87a82001-03-01 18:12:00 +00001457 *
Tim Peters50d8d372001-02-28 05:34:27 +00001458 * case_ok() is used to implement case-sensitive import semantics even
1459 * on platforms with case-insensitive filesystems. It's trivial to implement
1460 * for case-sensitive filesystems. It's pretty much a cross-platform
1461 * nightmare for systems with case-insensitive filesystems.
1462 */
Guido van Rossum0980bd91998-02-13 17:18:36 +00001463
Tim Peters50d8d372001-02-28 05:34:27 +00001464/* First we may need a pile of platform-specific header files; the sequence
1465 * of #if's here should match the sequence in the body of case_ok().
1466 */
Jason Tishler7961aa62005-05-20 00:56:54 +00001467#if defined(MS_WINDOWS)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001468#include <windows.h>
Guido van Rossum4c3f57c2001-01-10 20:40:46 +00001469
Tim Peters50d8d372001-02-28 05:34:27 +00001470#elif defined(DJGPP)
1471#include <dir.h>
1472
Jason Tishler7961aa62005-05-20 00:56:54 +00001473#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
Tim Peters430f5d42001-03-01 01:30:56 +00001474#include <sys/types.h>
1475#include <dirent.h>
1476
Andrew MacIntyred9400542002-02-26 11:41:34 +00001477#elif defined(PYOS_OS2)
1478#define INCL_DOS
1479#define INCL_DOSERRORS
1480#define INCL_NOPMAPI
1481#include <os2.h>
1482
Guido van Rossume2ae77b2001-10-24 20:42:55 +00001483#elif defined(RISCOS)
1484#include "oslib/osfscontrol.h"
Tim Peters50d8d372001-02-28 05:34:27 +00001485#endif
1486
Guido van Rossum0980bd91998-02-13 17:18:36 +00001487static int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001488case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001489{
Tim Peters50d8d372001-02-28 05:34:27 +00001490/* Pick a platform-specific implementation; the sequence of #if's here should
1491 * match the sequence just above.
1492 */
1493
Jason Tishler7961aa62005-05-20 00:56:54 +00001494/* MS_WINDOWS */
1495#if defined(MS_WINDOWS)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001496 WIN32_FIND_DATA data;
1497 HANDLE h;
Tim Peters50d8d372001-02-28 05:34:27 +00001498
Neil Schemenauer7d4bb9f2001-07-23 16:30:27 +00001499 if (Py_GETENV("PYTHONCASEOK") != NULL)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001500 return 1;
Tim Peters50d8d372001-02-28 05:34:27 +00001501
Guido van Rossum0980bd91998-02-13 17:18:36 +00001502 h = FindFirstFile(buf, &data);
1503 if (h == INVALID_HANDLE_VALUE) {
1504 PyErr_Format(PyExc_NameError,
1505 "Can't find file for module %.100s\n(filename %.300s)",
1506 name, buf);
1507 return 0;
1508 }
1509 FindClose(h);
Tim Peters50d8d372001-02-28 05:34:27 +00001510 return strncmp(data.cFileName, name, namelen) == 0;
1511
1512/* DJGPP */
1513#elif defined(DJGPP)
1514 struct ffblk ffblk;
1515 int done;
1516
Neil Schemenauer7d4bb9f2001-07-23 16:30:27 +00001517 if (Py_GETENV("PYTHONCASEOK") != NULL)
Guido van Rossum323bf5e1998-06-24 03:54:06 +00001518 return 1;
Tim Peters50d8d372001-02-28 05:34:27 +00001519
1520 done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);
1521 if (done) {
Guido van Rossum0980bd91998-02-13 17:18:36 +00001522 PyErr_Format(PyExc_NameError,
Tim Peters50d8d372001-02-28 05:34:27 +00001523 "Can't find file for module %.100s\n(filename %.300s)",
Guido van Rossum0980bd91998-02-13 17:18:36 +00001524 name, buf);
1525 return 0;
1526 }
Tim Peters50d8d372001-02-28 05:34:27 +00001527 return strncmp(ffblk.ff_name, name, namelen) == 0;
Guido van Rossum0980bd91998-02-13 17:18:36 +00001528
Jason Tishler7961aa62005-05-20 00:56:54 +00001529/* new-fangled macintosh (macosx) or Cygwin */
1530#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
Tim Peters430f5d42001-03-01 01:30:56 +00001531 DIR *dirp;
1532 struct dirent *dp;
Tim Petersd1e87a82001-03-01 18:12:00 +00001533 char dirname[MAXPATHLEN + 1];
1534 const int dirlen = len - namelen - 1; /* don't want trailing SEP */
Tim Peters430f5d42001-03-01 01:30:56 +00001535
Neil Schemenauer7d4bb9f2001-07-23 16:30:27 +00001536 if (Py_GETENV("PYTHONCASEOK") != NULL)
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001537 return 1;
1538
Tim Petersd1e87a82001-03-01 18:12:00 +00001539 /* Copy the dir component into dirname; substitute "." if empty */
1540 if (dirlen <= 0) {
1541 dirname[0] = '.';
1542 dirname[1] = '\0';
Tim Peters430f5d42001-03-01 01:30:56 +00001543 }
1544 else {
Tim Petersd1e87a82001-03-01 18:12:00 +00001545 assert(dirlen <= MAXPATHLEN);
1546 memcpy(dirname, buf, dirlen);
1547 dirname[dirlen] = '\0';
Tim Peters430f5d42001-03-01 01:30:56 +00001548 }
1549 /* Open the directory and search the entries for an exact match. */
Tim Petersd1e87a82001-03-01 18:12:00 +00001550 dirp = opendir(dirname);
Tim Peters430f5d42001-03-01 01:30:56 +00001551 if (dirp) {
Tim Peters677898a2001-03-02 03:28:03 +00001552 char *nameWithExt = buf + len - namelen;
Tim Peters430f5d42001-03-01 01:30:56 +00001553 while ((dp = readdir(dirp)) != NULL) {
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001554 const int thislen =
Tim Peters430f5d42001-03-01 01:30:56 +00001555#ifdef _DIRENT_HAVE_D_NAMELEN
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001556 dp->d_namlen;
Tim Peters430f5d42001-03-01 01:30:56 +00001557#else
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001558 strlen(dp->d_name);
Tim Peters430f5d42001-03-01 01:30:56 +00001559#endif
Tim Petersd1e87a82001-03-01 18:12:00 +00001560 if (thislen >= namelen &&
Tim Peters677898a2001-03-02 03:28:03 +00001561 strcmp(dp->d_name, nameWithExt) == 0) {
Tim Peters430f5d42001-03-01 01:30:56 +00001562 (void)closedir(dirp);
1563 return 1; /* Found */
1564 }
1565 }
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001566 (void)closedir(dirp);
Tim Peters430f5d42001-03-01 01:30:56 +00001567 }
Tim Peters430f5d42001-03-01 01:30:56 +00001568 return 0 ; /* Not found */
Tim Peters430f5d42001-03-01 01:30:56 +00001569
Guido van Rossume2ae77b2001-10-24 20:42:55 +00001570/* RISC OS */
1571#elif defined(RISCOS)
1572 char canon[MAXPATHLEN+1]; /* buffer for the canonical form of the path */
1573 char buf2[MAXPATHLEN+2];
1574 char *nameWithExt = buf+len-namelen;
1575 int canonlen;
1576 os_error *e;
1577
1578 if (Py_GETENV("PYTHONCASEOK") != NULL)
1579 return 1;
1580
1581 /* workaround:
1582 append wildcard, otherwise case of filename wouldn't be touched */
1583 strcpy(buf2, buf);
1584 strcat(buf2, "*");
1585
1586 e = xosfscontrol_canonicalise_path(buf2,canon,0,0,MAXPATHLEN+1,&canonlen);
1587 canonlen = MAXPATHLEN+1-canonlen;
1588 if (e || canonlen<=0 || canonlen>(MAXPATHLEN+1) )
1589 return 0;
1590 if (strcmp(nameWithExt, canon+canonlen-strlen(nameWithExt))==0)
1591 return 1; /* match */
1592
1593 return 0;
1594
Andrew MacIntyred9400542002-02-26 11:41:34 +00001595/* OS/2 */
1596#elif defined(PYOS_OS2)
1597 HDIR hdir = 1;
1598 ULONG srchcnt = 1;
1599 FILEFINDBUF3 ffbuf;
1600 APIRET rc;
1601
1602 if (getenv("PYTHONCASEOK") != NULL)
1603 return 1;
1604
1605 rc = DosFindFirst(buf,
1606 &hdir,
1607 FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,
1608 &ffbuf, sizeof(ffbuf),
1609 &srchcnt,
1610 FIL_STANDARD);
1611 if (rc != NO_ERROR)
1612 return 0;
1613 return strncmp(ffbuf.achName, name, namelen) == 0;
1614
Tim Peters50d8d372001-02-28 05:34:27 +00001615/* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1616#else
Guido van Rossum0980bd91998-02-13 17:18:36 +00001617 return 1;
Guido van Rossum0980bd91998-02-13 17:18:36 +00001618
Guido van Rossum4d1b3b91998-02-13 23:27:59 +00001619#endif
Tim Peters50d8d372001-02-28 05:34:27 +00001620}
Guido van Rossum4d1b3b91998-02-13 23:27:59 +00001621
Guido van Rossum0980bd91998-02-13 17:18:36 +00001622
Guido van Rossum197346f1997-10-31 18:38:52 +00001623#ifdef HAVE_STAT
1624/* Helper to look for __init__.py or __init__.py[co] in potential package */
1625static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001626find_init_module(char *buf)
Guido van Rossum197346f1997-10-31 18:38:52 +00001627{
Tim Peters0f9431f2001-07-05 03:47:53 +00001628 const size_t save_len = strlen(buf);
Fred Drake4c82b232000-06-30 16:18:57 +00001629 size_t i = save_len;
Tim Peters0f9431f2001-07-05 03:47:53 +00001630 char *pname; /* pointer to start of __init__ */
Guido van Rossum197346f1997-10-31 18:38:52 +00001631 struct stat statbuf;
1632
Tim Peters0f9431f2001-07-05 03:47:53 +00001633/* For calling case_ok(buf, len, namelen, name):
1634 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1635 * ^ ^ ^ ^
1636 * |--------------------- buf ---------------------|
1637 * |------------------- len ------------------|
1638 * |------ name -------|
1639 * |----- namelen -----|
1640 */
Guido van Rossum197346f1997-10-31 18:38:52 +00001641 if (save_len + 13 >= MAXPATHLEN)
1642 return 0;
1643 buf[i++] = SEP;
Tim Peters0f9431f2001-07-05 03:47:53 +00001644 pname = buf + i;
1645 strcpy(pname, "__init__.py");
Guido van Rossum197346f1997-10-31 18:38:52 +00001646 if (stat(buf, &statbuf) == 0) {
Tim Peters0f9431f2001-07-05 03:47:53 +00001647 if (case_ok(buf,
1648 save_len + 9, /* len("/__init__") */
1649 8, /* len("__init__") */
1650 pname)) {
1651 buf[save_len] = '\0';
1652 return 1;
1653 }
Guido van Rossum197346f1997-10-31 18:38:52 +00001654 }
Tim Peters0f9431f2001-07-05 03:47:53 +00001655 i += strlen(pname);
1656 strcpy(buf+i, Py_OptimizeFlag ? "o" : "c");
Guido van Rossum197346f1997-10-31 18:38:52 +00001657 if (stat(buf, &statbuf) == 0) {
Tim Peters0f9431f2001-07-05 03:47:53 +00001658 if (case_ok(buf,
1659 save_len + 9, /* len("/__init__") */
1660 8, /* len("__init__") */
1661 pname)) {
1662 buf[save_len] = '\0';
1663 return 1;
1664 }
Guido van Rossum197346f1997-10-31 18:38:52 +00001665 }
1666 buf[save_len] = '\0';
1667 return 0;
1668}
Guido van Rossum48a680c2001-03-02 06:34:14 +00001669
1670#else
1671
1672#ifdef RISCOS
1673static int
1674find_init_module(buf)
1675 char *buf;
1676{
1677 int save_len = strlen(buf);
1678 int i = save_len;
1679
1680 if (save_len + 13 >= MAXPATHLEN)
1681 return 0;
1682 buf[i++] = SEP;
1683 strcpy(buf+i, "__init__/py");
1684 if (isfile(buf)) {
1685 buf[save_len] = '\0';
1686 return 1;
1687 }
1688
1689 if (Py_OptimizeFlag)
1690 strcpy(buf+i, "o");
1691 else
1692 strcpy(buf+i, "c");
1693 if (isfile(buf)) {
1694 buf[save_len] = '\0';
1695 return 1;
1696 }
1697 buf[save_len] = '\0';
1698 return 0;
1699}
1700#endif /*RISCOS*/
1701
Guido van Rossum197346f1997-10-31 18:38:52 +00001702#endif /* HAVE_STAT */
1703
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001704
Tim Petersdbd9ba62000-07-09 03:09:57 +00001705static int init_builtin(char *); /* Forward */
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001706
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001707/* Load an external module using the default search path and return
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001708 its module object WITH INCREMENTED REFERENCE COUNT */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001709
Guido van Rossum79f25d91997-04-29 20:08:16 +00001710static PyObject *
Just van Rossum52e14d62002-12-30 22:08:05 +00001711load_module(char *name, FILE *fp, char *buf, int type, PyObject *loader)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001712{
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001713 PyObject *modules;
Guido van Rossum79f25d91997-04-29 20:08:16 +00001714 PyObject *m;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001715 int err;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001716
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001717 /* First check that there's an open file (if we need one) */
1718 switch (type) {
1719 case PY_SOURCE:
1720 case PY_COMPILED:
1721 if (fp == NULL) {
1722 PyErr_Format(PyExc_ValueError,
1723 "file object required for import (type code %d)",
1724 type);
1725 return NULL;
1726 }
1727 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001728
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001729 switch (type) {
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001730
1731 case PY_SOURCE:
1732 m = load_source_module(name, buf, fp);
1733 break;
1734
1735 case PY_COMPILED:
1736 m = load_compiled_module(name, buf, fp);
1737 break;
1738
Guido van Rossum96a8fb71999-12-22 14:09:35 +00001739#ifdef HAVE_DYNAMIC_LOADING
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001740 case C_EXTENSION:
Guido van Rossum79f25d91997-04-29 20:08:16 +00001741 m = _PyImport_LoadDynamicModule(name, buf, fp);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001742 break;
Guido van Rossum96a8fb71999-12-22 14:09:35 +00001743#endif
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001744
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001745 case PKG_DIRECTORY:
1746 m = load_package(name, buf);
1747 break;
1748
1749 case C_BUILTIN:
1750 case PY_FROZEN:
Guido van Rossuma5568d31998-03-05 03:45:08 +00001751 if (buf != NULL && buf[0] != '\0')
1752 name = buf;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001753 if (type == C_BUILTIN)
1754 err = init_builtin(name);
1755 else
1756 err = PyImport_ImportFrozenModule(name);
1757 if (err < 0)
Guido van Rossuma86f77d1997-09-09 18:53:47 +00001758 return NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001759 if (err == 0) {
1760 PyErr_Format(PyExc_ImportError,
1761 "Purported %s module %.200s not found",
1762 type == C_BUILTIN ?
1763 "builtin" : "frozen",
1764 name);
Guido van Rossuma86f77d1997-09-09 18:53:47 +00001765 return NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001766 }
1767 modules = PyImport_GetModuleDict();
1768 m = PyDict_GetItemString(modules, name);
1769 if (m == NULL) {
1770 PyErr_Format(
1771 PyExc_ImportError,
1772 "%s module %.200s not properly initialized",
1773 type == C_BUILTIN ?
1774 "builtin" : "frozen",
1775 name);
Guido van Rossuma86f77d1997-09-09 18:53:47 +00001776 return NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001777 }
1778 Py_INCREF(m);
1779 break;
1780
Just van Rossum52e14d62002-12-30 22:08:05 +00001781 case IMP_HOOK: {
1782 if (loader == NULL) {
1783 PyErr_SetString(PyExc_ImportError,
1784 "import hook without loader");
1785 return NULL;
1786 }
1787 m = PyObject_CallMethod(loader, "load_module", "s", name);
1788 break;
1789 }
1790
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001791 default:
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001792 PyErr_Format(PyExc_ImportError,
1793 "Don't know how to import %.200s (type code %d)",
1794 name, type);
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001795 m = NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001796
1797 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001798
1799 return m;
1800}
1801
1802
1803/* Initialize a built-in module.
Thomas Wouters89f507f2006-12-13 04:49:30 +00001804 Return 1 for success, 0 if the module is not found, and -1 with
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001805 an exception set if the initialization failed. */
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001806
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001807static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001808init_builtin(char *name)
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001809{
Guido van Rossum25ce5661997-08-02 03:10:38 +00001810 struct _inittab *p;
Guido van Rossum25ce5661997-08-02 03:10:38 +00001811
Greg Ward201baee2001-10-04 14:52:06 +00001812 if (_PyImport_FindExtension(name, name) != NULL)
Guido van Rossum25ce5661997-08-02 03:10:38 +00001813 return 1;
1814
Guido van Rossum771c6c81997-10-31 18:37:24 +00001815 for (p = PyImport_Inittab; p->name != NULL; p++) {
Guido van Rossum25ce5661997-08-02 03:10:38 +00001816 if (strcmp(name, p->name) == 0) {
1817 if (p->initfunc == NULL) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001818 PyErr_Format(PyExc_ImportError,
1819 "Cannot re-init internal module %.200s",
1820 name);
Guido van Rossum74e6a111994-08-29 12:54:38 +00001821 return -1;
1822 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00001823 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +00001824 PySys_WriteStderr("import %s # builtin\n", name);
Guido van Rossum25ce5661997-08-02 03:10:38 +00001825 (*p->initfunc)();
Guido van Rossum79f25d91997-04-29 20:08:16 +00001826 if (PyErr_Occurred())
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001827 return -1;
Guido van Rossum25ce5661997-08-02 03:10:38 +00001828 if (_PyImport_FixupExtension(name, name) == NULL)
1829 return -1;
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001830 return 1;
1831 }
1832 }
1833 return 0;
1834}
Guido van Rossumf56e3db1993-04-01 20:59:32 +00001835
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001836
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001837/* Frozen modules */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001838
Guido van Rossumcfd0a221996-06-17 17:06:34 +00001839static struct _frozen *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001840find_frozen(char *name)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001841{
Guido van Rossumcfd0a221996-06-17 17:06:34 +00001842 struct _frozen *p;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001843
Guido van Rossum79f25d91997-04-29 20:08:16 +00001844 for (p = PyImport_FrozenModules; ; p++) {
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001845 if (p->name == NULL)
1846 return NULL;
1847 if (strcmp(p->name, name) == 0)
1848 break;
1849 }
1850 return p;
1851}
1852
Guido van Rossum79f25d91997-04-29 20:08:16 +00001853static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001854get_frozen_object(char *name)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001855{
Guido van Rossumcfd0a221996-06-17 17:06:34 +00001856 struct _frozen *p = find_frozen(name);
Guido van Rossuma5568d31998-03-05 03:45:08 +00001857 int size;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001858
1859 if (p == NULL) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001860 PyErr_Format(PyExc_ImportError,
1861 "No such frozen object named %.200s",
1862 name);
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001863 return NULL;
1864 }
Guido van Rossum8f4d3312001-10-18 18:54:11 +00001865 if (p->code == NULL) {
1866 PyErr_Format(PyExc_ImportError,
1867 "Excluded frozen object named %.200s",
1868 name);
1869 return NULL;
1870 }
Guido van Rossuma5568d31998-03-05 03:45:08 +00001871 size = p->size;
1872 if (size < 0)
1873 size = -size;
1874 return PyMarshal_ReadObjectFromString((char *)p->code, size);
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001875}
1876
1877/* Initialize a frozen module.
1878 Return 1 for succes, 0 if the module is not found, and -1 with
1879 an exception set if the initialization failed.
1880 This function is also used from frozenmain.c */
Guido van Rossum0b344901995-02-07 15:35:27 +00001881
1882int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001883PyImport_ImportFrozenModule(char *name)
Guido van Rossumf56e3db1993-04-01 20:59:32 +00001884{
Guido van Rossumcfd0a221996-06-17 17:06:34 +00001885 struct _frozen *p = find_frozen(name);
Guido van Rossum79f25d91997-04-29 20:08:16 +00001886 PyObject *co;
1887 PyObject *m;
Guido van Rossuma5568d31998-03-05 03:45:08 +00001888 int ispackage;
1889 int size;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001890
1891 if (p == NULL)
1892 return 0;
Guido van Rossum8f4d3312001-10-18 18:54:11 +00001893 if (p->code == NULL) {
1894 PyErr_Format(PyExc_ImportError,
1895 "Excluded frozen object named %.200s",
1896 name);
1897 return -1;
1898 }
Guido van Rossuma5568d31998-03-05 03:45:08 +00001899 size = p->size;
1900 ispackage = (size < 0);
1901 if (ispackage)
1902 size = -size;
Guido van Rossum79f25d91997-04-29 20:08:16 +00001903 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +00001904 PySys_WriteStderr("import %s # frozen%s\n",
Guido van Rossuma5568d31998-03-05 03:45:08 +00001905 name, ispackage ? " package" : "");
1906 co = PyMarshal_ReadObjectFromString((char *)p->code, size);
Guido van Rossumf56e3db1993-04-01 20:59:32 +00001907 if (co == NULL)
1908 return -1;
Guido van Rossum79f25d91997-04-29 20:08:16 +00001909 if (!PyCode_Check(co)) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001910 PyErr_Format(PyExc_TypeError,
1911 "frozen object %.200s is not a code object",
1912 name);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001913 goto err_return;
Guido van Rossumf56e3db1993-04-01 20:59:32 +00001914 }
Guido van Rossuma5568d31998-03-05 03:45:08 +00001915 if (ispackage) {
1916 /* Set __path__ to the package name */
1917 PyObject *d, *s;
1918 int err;
1919 m = PyImport_AddModule(name);
1920 if (m == NULL)
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001921 goto err_return;
Guido van Rossuma5568d31998-03-05 03:45:08 +00001922 d = PyModule_GetDict(m);
Martin v. Löwis5b222132007-06-10 09:51:05 +00001923 s = PyUnicode_InternFromString(name);
Guido van Rossuma5568d31998-03-05 03:45:08 +00001924 if (s == NULL)
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001925 goto err_return;
Guido van Rossuma5568d31998-03-05 03:45:08 +00001926 err = PyDict_SetItemString(d, "__path__", s);
1927 Py_DECREF(s);
1928 if (err != 0)
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001929 goto err_return;
Guido van Rossuma5568d31998-03-05 03:45:08 +00001930 }
Guido van Rossume32bf6e1998-02-11 05:53:02 +00001931 m = PyImport_ExecCodeModuleEx(name, co, "<frozen>");
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001932 if (m == NULL)
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001933 goto err_return;
1934 Py_DECREF(co);
Guido van Rossum79f25d91997-04-29 20:08:16 +00001935 Py_DECREF(m);
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001936 return 1;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001937err_return:
1938 Py_DECREF(co);
1939 return -1;
Guido van Rossumf56e3db1993-04-01 20:59:32 +00001940}
Guido van Rossum74e6a111994-08-29 12:54:38 +00001941
1942
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001943/* Import a module, either built-in, frozen, or external, and return
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001944 its module object WITH INCREMENTED REFERENCE COUNT */
Guido van Rossum74e6a111994-08-29 12:54:38 +00001945
Guido van Rossum79f25d91997-04-29 20:08:16 +00001946PyObject *
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001947PyImport_ImportModule(const char *name)
Guido van Rossum74e6a111994-08-29 12:54:38 +00001948{
Marc-André Lemburg3c61c352001-02-09 19:40:15 +00001949 PyObject *pname;
1950 PyObject *result;
1951
Martin v. Löwis5b222132007-06-10 09:51:05 +00001952 pname = PyUnicode_FromString(name);
Neal Norwitza11e4c12003-03-23 14:31:01 +00001953 if (pname == NULL)
1954 return NULL;
Marc-André Lemburg3c61c352001-02-09 19:40:15 +00001955 result = PyImport_Import(pname);
1956 Py_DECREF(pname);
1957 return result;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001958}
1959
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001960/* Forward declarations for helper routines */
Thomas Woutersf7f438b2006-02-28 16:09:29 +00001961static PyObject *get_parent(PyObject *globals, char *buf,
1962 Py_ssize_t *p_buflen, int level);
Tim Petersdbd9ba62000-07-09 03:09:57 +00001963static PyObject *load_next(PyObject *mod, PyObject *altmod,
Martin v. Löwis18e16552006-02-15 17:27:45 +00001964 char **p_name, char *buf, Py_ssize_t *p_buflen);
Tim Petersdbd9ba62000-07-09 03:09:57 +00001965static int mark_miss(char *name);
1966static int ensure_fromlist(PyObject *mod, PyObject *fromlist,
Martin v. Löwis18e16552006-02-15 17:27:45 +00001967 char *buf, Py_ssize_t buflen, int recursive);
Tim Petersdbd9ba62000-07-09 03:09:57 +00001968static PyObject * import_submodule(PyObject *mod, char *name, char *fullname);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001969
1970/* The Magnum Opus of dotted-name import :-) */
1971
Guido van Rossum75acc9c1998-03-03 22:26:50 +00001972static PyObject *
Thomas Woutersf7f438b2006-02-28 16:09:29 +00001973import_module_level(char *name, PyObject *globals, PyObject *locals,
1974 PyObject *fromlist, int level)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001975{
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001976 char buf[MAXPATHLEN+1];
Martin v. Löwis18e16552006-02-15 17:27:45 +00001977 Py_ssize_t buflen = 0;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001978 PyObject *parent, *head, *next, *tail;
1979
Thomas Woutersf7f438b2006-02-28 16:09:29 +00001980 parent = get_parent(globals, buf, &buflen, level);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001981 if (parent == NULL)
1982 return NULL;
1983
1984 head = load_next(parent, Py_None, &name, buf, &buflen);
1985 if (head == NULL)
1986 return NULL;
1987
1988 tail = head;
1989 Py_INCREF(tail);
1990 while (name) {
1991 next = load_next(tail, tail, &name, buf, &buflen);
1992 Py_DECREF(tail);
1993 if (next == NULL) {
1994 Py_DECREF(head);
1995 return NULL;
1996 }
1997 tail = next;
1998 }
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001999 if (tail == Py_None) {
2000 /* If tail is Py_None, both get_parent and load_next found
2001 an empty module name: someone called __import__("") or
2002 doctored faulty bytecode */
2003 Py_DECREF(tail);
2004 Py_DECREF(head);
2005 PyErr_SetString(PyExc_ValueError,
2006 "Empty module name");
2007 return NULL;
2008 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002009
2010 if (fromlist != NULL) {
2011 if (fromlist == Py_None || !PyObject_IsTrue(fromlist))
2012 fromlist = NULL;
2013 }
2014
2015 if (fromlist == NULL) {
2016 Py_DECREF(tail);
2017 return head;
2018 }
2019
2020 Py_DECREF(head);
Guido van Rossum9905ef91997-09-08 16:07:11 +00002021 if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002022 Py_DECREF(tail);
2023 return NULL;
2024 }
2025
2026 return tail;
2027}
2028
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002029/* For DLL compatibility */
2030#undef PyImport_ImportModuleEx
Guido van Rossum75acc9c1998-03-03 22:26:50 +00002031PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002032PyImport_ImportModuleEx(char *name, PyObject *globals, PyObject *locals,
2033 PyObject *fromlist)
Guido van Rossum75acc9c1998-03-03 22:26:50 +00002034{
2035 PyObject *result;
2036 lock_import();
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002037 result = import_module_level(name, globals, locals, fromlist, -1);
2038 if (unlock_import() < 0) {
2039 Py_XDECREF(result);
2040 PyErr_SetString(PyExc_RuntimeError,
2041 "not holding the import lock");
2042 return NULL;
2043 }
2044 return result;
2045}
2046#define PyImport_ImportModuleEx(n, g, l, f) \
2047 PyImport_ImportModuleLevel(n, g, l, f, -1);
2048
2049PyObject *
2050PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,
2051 PyObject *fromlist, int level)
2052{
2053 PyObject *result;
2054 lock_import();
2055 result = import_module_level(name, globals, locals, fromlist, level);
Guido van Rossumc4f4ca92003-02-12 21:46:11 +00002056 if (unlock_import() < 0) {
2057 Py_XDECREF(result);
2058 PyErr_SetString(PyExc_RuntimeError,
2059 "not holding the import lock");
2060 return NULL;
2061 }
Guido van Rossum75acc9c1998-03-03 22:26:50 +00002062 return result;
2063}
2064
Fred Drake87590902004-05-28 20:21:36 +00002065/* Return the package that an import is being performed in. If globals comes
2066 from the module foo.bar.bat (not itself a package), this returns the
2067 sys.modules entry for foo.bar. If globals is from a package's __init__.py,
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002068 the package's entry in sys.modules is returned, as a borrowed reference.
Fred Drake87590902004-05-28 20:21:36 +00002069
2070 The *name* of the returned package is returned in buf, with the length of
2071 the name in *p_buflen.
2072
2073 If globals doesn't come from a package or a module in a package, or a
2074 corresponding entry is not found in sys.modules, Py_None is returned.
2075*/
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002076static PyObject *
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002077get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen, int level)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002078{
2079 static PyObject *namestr = NULL;
2080 static PyObject *pathstr = NULL;
2081 PyObject *modname, *modpath, *modules, *parent;
2082
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002083 if (globals == NULL || !PyDict_Check(globals) || !level)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002084 return Py_None;
2085
2086 if (namestr == NULL) {
Martin v. Löwis5b222132007-06-10 09:51:05 +00002087 namestr = PyUnicode_InternFromString("__name__");
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002088 if (namestr == NULL)
2089 return NULL;
2090 }
2091 if (pathstr == NULL) {
Martin v. Löwis5b222132007-06-10 09:51:05 +00002092 pathstr = PyUnicode_InternFromString("__path__");
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002093 if (pathstr == NULL)
2094 return NULL;
2095 }
2096
2097 *buf = '\0';
2098 *p_buflen = 0;
2099 modname = PyDict_GetItem(globals, namestr);
Martin v. Löwis5b222132007-06-10 09:51:05 +00002100 if (modname == NULL || (!PyString_Check(modname) && !PyUnicode_Check(modname)))
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002101 return Py_None;
2102
Martin v. Löwis5b222132007-06-10 09:51:05 +00002103 if (PyUnicode_Check(modname)) {
2104 /* XXX need to support Unicode better */
2105 modname = _PyUnicode_AsDefaultEncodedString(modname, NULL);
2106 if (!modname) {
2107 PyErr_Clear();
2108 return NULL;
2109 }
2110 }
2111
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002112 modpath = PyDict_GetItem(globals, pathstr);
2113 if (modpath != NULL) {
Martin v. Löwis725507b2006-03-07 12:08:51 +00002114 Py_ssize_t len = PyString_GET_SIZE(modname);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002115 if (len > MAXPATHLEN) {
2116 PyErr_SetString(PyExc_ValueError,
2117 "Module name too long");
2118 return NULL;
2119 }
2120 strcpy(buf, PyString_AS_STRING(modname));
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002121 }
2122 else {
2123 char *start = PyString_AS_STRING(modname);
2124 char *lastdot = strrchr(start, '.');
Fred Drake4c82b232000-06-30 16:18:57 +00002125 size_t len;
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002126 if (lastdot == NULL && level > 0) {
2127 PyErr_SetString(PyExc_ValueError,
Thomas Wouters89f507f2006-12-13 04:49:30 +00002128 "Attempted relative import in non-package");
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002129 return NULL;
2130 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002131 if (lastdot == NULL)
2132 return Py_None;
2133 len = lastdot - start;
2134 if (len >= MAXPATHLEN) {
2135 PyErr_SetString(PyExc_ValueError,
2136 "Module name too long");
2137 return NULL;
2138 }
2139 strncpy(buf, start, len);
2140 buf[len] = '\0';
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002141 }
2142
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002143 while (--level > 0) {
2144 char *dot = strrchr(buf, '.');
2145 if (dot == NULL) {
2146 PyErr_SetString(PyExc_ValueError,
Thomas Wouters89f507f2006-12-13 04:49:30 +00002147 "Attempted relative import beyond "
2148 "toplevel package");
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002149 return NULL;
2150 }
2151 *dot = '\0';
2152 }
2153 *p_buflen = strlen(buf);
2154
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002155 modules = PyImport_GetModuleDict();
2156 parent = PyDict_GetItemString(modules, buf);
2157 if (parent == NULL)
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002158 PyErr_Format(PyExc_SystemError,
2159 "Parent module '%.200s' not loaded", buf);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002160 return parent;
2161 /* We expect, but can't guarantee, if parent != None, that:
2162 - parent.__name__ == buf
2163 - parent.__dict__ is globals
2164 If this is violated... Who cares? */
2165}
2166
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002167/* altmod is either None or same as mod */
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002168static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002169load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf,
Martin v. Löwis18e16552006-02-15 17:27:45 +00002170 Py_ssize_t *p_buflen)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002171{
2172 char *name = *p_name;
2173 char *dot = strchr(name, '.');
Fred Drake4c82b232000-06-30 16:18:57 +00002174 size_t len;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002175 char *p;
2176 PyObject *result;
2177
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002178 if (strlen(name) == 0) {
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002179 /* completely empty module name should only happen in
2180 'from . import' (or '__import__("")')*/
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002181 Py_INCREF(mod);
2182 *p_name = NULL;
2183 return mod;
2184 }
2185
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002186 if (dot == NULL) {
2187 *p_name = NULL;
2188 len = strlen(name);
2189 }
2190 else {
2191 *p_name = dot+1;
2192 len = dot-name;
2193 }
Guido van Rossum111c20b1998-04-11 17:38:22 +00002194 if (len == 0) {
2195 PyErr_SetString(PyExc_ValueError,
2196 "Empty module name");
2197 return NULL;
2198 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002199
2200 p = buf + *p_buflen;
2201 if (p != buf)
2202 *p++ = '.';
2203 if (p+len-buf >= MAXPATHLEN) {
2204 PyErr_SetString(PyExc_ValueError,
2205 "Module name too long");
2206 return NULL;
2207 }
2208 strncpy(p, name, len);
2209 p[len] = '\0';
2210 *p_buflen = p+len-buf;
2211
2212 result = import_submodule(mod, p, buf);
2213 if (result == Py_None && altmod != mod) {
2214 Py_DECREF(result);
Guido van Rossumf5f5fdb1997-09-06 20:29:52 +00002215 /* Here, altmod must be None and mod must not be None */
Guido van Rossum0c819451997-09-07 06:16:57 +00002216 result = import_submodule(altmod, p, p);
Guido van Rossumf5f5fdb1997-09-06 20:29:52 +00002217 if (result != NULL && result != Py_None) {
2218 if (mark_miss(buf) != 0) {
2219 Py_DECREF(result);
2220 return NULL;
2221 }
2222 strncpy(buf, name, len);
2223 buf[len] = '\0';
2224 *p_buflen = len;
2225 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002226 }
2227 if (result == NULL)
2228 return NULL;
2229
2230 if (result == Py_None) {
2231 Py_DECREF(result);
2232 PyErr_Format(PyExc_ImportError,
2233 "No module named %.200s", name);
2234 return NULL;
2235 }
2236
2237 return result;
2238}
2239
2240static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002241mark_miss(char *name)
Guido van Rossumf5f5fdb1997-09-06 20:29:52 +00002242{
2243 PyObject *modules = PyImport_GetModuleDict();
2244 return PyDict_SetItemString(modules, name, Py_None);
2245}
2246
2247static int
Martin v. Löwis18e16552006-02-15 17:27:45 +00002248ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen,
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002249 int recursive)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002250{
2251 int i;
2252
2253 if (!PyObject_HasAttrString(mod, "__path__"))
2254 return 1;
2255
2256 for (i = 0; ; i++) {
2257 PyObject *item = PySequence_GetItem(fromlist, i);
2258 int hasit;
2259 if (item == NULL) {
2260 if (PyErr_ExceptionMatches(PyExc_IndexError)) {
2261 PyErr_Clear();
2262 return 1;
2263 }
2264 return 0;
2265 }
Martin v. Löwis5b222132007-06-10 09:51:05 +00002266 if (PyString_Check(item)) {
2267 /* XXX there shouldn't be any str8 objects here */
2268 PyObject *uni = PyUnicode_DecodeASCII(PyString_AsString(item),
2269 PyString_Size(item),
2270 "strict");
2271 Py_DECREF(item);
2272 if (!uni)
2273 return 0;
2274 item = uni;
2275 }
2276 if (!PyUnicode_Check(item)) {
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002277 PyErr_SetString(PyExc_TypeError,
Martin v. Löwis5b222132007-06-10 09:51:05 +00002278 "Item in ``from list'' not a unicode string");
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002279 Py_DECREF(item);
2280 return 0;
2281 }
Martin v. Löwis5b222132007-06-10 09:51:05 +00002282 if (PyUnicode_AS_UNICODE(item)[0] == '*') {
Guido van Rossum9905ef91997-09-08 16:07:11 +00002283 PyObject *all;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002284 Py_DECREF(item);
Guido van Rossum9905ef91997-09-08 16:07:11 +00002285 /* See if the package defines __all__ */
2286 if (recursive)
2287 continue; /* Avoid endless recursion */
2288 all = PyObject_GetAttrString(mod, "__all__");
2289 if (all == NULL)
2290 PyErr_Clear();
2291 else {
Martin v. Löwis83969ee2004-03-23 16:28:13 +00002292 int ret = ensure_fromlist(mod, all, buf, buflen, 1);
Guido van Rossum9905ef91997-09-08 16:07:11 +00002293 Py_DECREF(all);
Martin v. Löwis83969ee2004-03-23 16:28:13 +00002294 if (!ret)
2295 return 0;
Guido van Rossum9905ef91997-09-08 16:07:11 +00002296 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002297 continue;
2298 }
2299 hasit = PyObject_HasAttr(mod, item);
2300 if (!hasit) {
Martin v. Löwis5b222132007-06-10 09:51:05 +00002301 PyObject *item8;
2302 char *subname;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002303 PyObject *submod;
2304 char *p;
Martin v. Löwis5b222132007-06-10 09:51:05 +00002305 if (!Py_FileSystemDefaultEncoding) {
2306 item8 = PyUnicode_EncodeASCII(PyUnicode_AsUnicode(item),
2307 PyUnicode_GetSize(item),
Martin v. Löwis427dbff2007-06-12 05:53:00 +00002308 NULL);
Martin v. Löwis5b222132007-06-10 09:51:05 +00002309 } else {
Martin v. Löwis427dbff2007-06-12 05:53:00 +00002310 item8 = PyUnicode_AsEncodedString(item,
2311 Py_FileSystemDefaultEncoding, NULL);
Martin v. Löwis5b222132007-06-10 09:51:05 +00002312 }
2313 if (!item8) {
2314 PyErr_SetString(PyExc_ValueError, "Cannot encode path item");
2315 return 0;
2316 }
2317 subname = PyBytes_AsString(item8);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002318 if (buflen + strlen(subname) >= MAXPATHLEN) {
2319 PyErr_SetString(PyExc_ValueError,
2320 "Module name too long");
2321 Py_DECREF(item);
2322 return 0;
2323 }
2324 p = buf + buflen;
2325 *p++ = '.';
2326 strcpy(p, subname);
2327 submod = import_submodule(mod, subname, buf);
Martin v. Löwis5b222132007-06-10 09:51:05 +00002328 Py_DECREF(item8);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002329 Py_XDECREF(submod);
2330 if (submod == NULL) {
2331 Py_DECREF(item);
2332 return 0;
2333 }
2334 }
2335 Py_DECREF(item);
2336 }
2337
Guido van Rossuma7f2e811997-10-03 15:33:32 +00002338 /* NOTREACHED */
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002339}
2340
Neil Schemenauer00b09662003-06-16 21:03:07 +00002341static int
2342add_submodule(PyObject *mod, PyObject *submod, char *fullname, char *subname,
2343 PyObject *modules)
2344{
2345 if (mod == Py_None)
2346 return 1;
2347 /* Irrespective of the success of this load, make a
2348 reference to it in the parent package module. A copy gets
2349 saved in the modules dictionary under the full name, so get a
2350 reference from there, if need be. (The exception is when the
2351 load failed with a SyntaxError -- then there's no trace in
2352 sys.modules. In that case, of course, do nothing extra.) */
2353 if (submod == NULL) {
2354 submod = PyDict_GetItemString(modules, fullname);
2355 if (submod == NULL)
2356 return 1;
2357 }
2358 if (PyModule_Check(mod)) {
2359 /* We can't use setattr here since it can give a
2360 * spurious warning if the submodule name shadows a
2361 * builtin name */
2362 PyObject *dict = PyModule_GetDict(mod);
2363 if (!dict)
2364 return 0;
2365 if (PyDict_SetItemString(dict, subname, submod) < 0)
2366 return 0;
2367 }
2368 else {
2369 if (PyObject_SetAttrString(mod, subname, submod) < 0)
2370 return 0;
2371 }
2372 return 1;
2373}
2374
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002375static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002376import_submodule(PyObject *mod, char *subname, char *fullname)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002377{
Guido van Rossum25ce5661997-08-02 03:10:38 +00002378 PyObject *modules = PyImport_GetModuleDict();
Neil Schemenauer00b09662003-06-16 21:03:07 +00002379 PyObject *m = NULL;
Guido van Rossum74e6a111994-08-29 12:54:38 +00002380
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002381 /* Require:
2382 if mod == None: subname == fullname
2383 else: mod.__name__ + "." + subname == fullname
2384 */
2385
Tim Peters50d8d372001-02-28 05:34:27 +00002386 if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002387 Py_INCREF(m);
Guido van Rossum7f9fa971995-01-20 16:53:12 +00002388 }
2389 else {
Just van Rossum52e14d62002-12-30 22:08:05 +00002390 PyObject *path, *loader = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002391 char buf[MAXPATHLEN+1];
2392 struct filedescr *fdp;
2393 FILE *fp = NULL;
2394
Guido van Rossum9c0afe51998-05-19 15:09:05 +00002395 if (mod == Py_None)
2396 path = NULL;
2397 else {
2398 path = PyObject_GetAttrString(mod, "__path__");
2399 if (path == NULL) {
2400 PyErr_Clear();
2401 Py_INCREF(Py_None);
2402 return Py_None;
2403 }
2404 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002405
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002406 buf[0] = '\0';
Just van Rossum52e14d62002-12-30 22:08:05 +00002407 fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
2408 &fp, &loader);
Guido van Rossumb68cd421998-07-01 17:36:26 +00002409 Py_XDECREF(path);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002410 if (fdp == NULL) {
2411 if (!PyErr_ExceptionMatches(PyExc_ImportError))
2412 return NULL;
2413 PyErr_Clear();
2414 Py_INCREF(Py_None);
2415 return Py_None;
2416 }
Just van Rossum52e14d62002-12-30 22:08:05 +00002417 m = load_module(fullname, fp, buf, fdp->type, loader);
2418 Py_XDECREF(loader);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002419 if (fp)
2420 fclose(fp);
Neil Schemenauer00b09662003-06-16 21:03:07 +00002421 if (!add_submodule(mod, m, fullname, subname, modules)) {
2422 Py_XDECREF(m);
2423 m = NULL;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002424 }
Guido van Rossum74e6a111994-08-29 12:54:38 +00002425 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002426
2427 return m;
Guido van Rossum74e6a111994-08-29 12:54:38 +00002428}
2429
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002430
2431/* Re-import a module of any kind and return its module object, WITH
2432 INCREMENTED REFERENCE COUNT */
2433
Guido van Rossum79f25d91997-04-29 20:08:16 +00002434PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002435PyImport_ReloadModule(PyObject *m)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002436{
Guido van Rossumd8faa362007-04-27 19:54:29 +00002437 PyInterpreterState *interp = PyThreadState_Get()->interp;
2438 PyObject *modules_reloading = interp->modules_reloading;
Guido van Rossum25ce5661997-08-02 03:10:38 +00002439 PyObject *modules = PyImport_GetModuleDict();
Guido van Rossumd8faa362007-04-27 19:54:29 +00002440 PyObject *path = NULL, *loader = NULL, *existing_m = NULL;
Guido van Rossum222ef561997-09-06 19:41:09 +00002441 char *name, *subname;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002442 char buf[MAXPATHLEN+1];
2443 struct filedescr *fdp;
2444 FILE *fp = NULL;
Tim Peters1cd70172004-08-02 03:52:12 +00002445 PyObject *newm;
Guido van Rossumd8faa362007-04-27 19:54:29 +00002446
2447 if (modules_reloading == NULL) {
2448 Py_FatalError("PyImport_ReloadModule: "
Guido van Rossume7ba4952007-06-06 23:52:48 +00002449 "no modules_reloading dictionary!");
Guido van Rossumd8faa362007-04-27 19:54:29 +00002450 return NULL;
2451 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002452
Guido van Rossum79f25d91997-04-29 20:08:16 +00002453 if (m == NULL || !PyModule_Check(m)) {
2454 PyErr_SetString(PyExc_TypeError,
2455 "reload() argument must be module");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002456 return NULL;
2457 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002458 name = PyModule_GetName(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002459 if (name == NULL)
2460 return NULL;
Guido van Rossum25ce5661997-08-02 03:10:38 +00002461 if (m != PyDict_GetItemString(modules, name)) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002462 PyErr_Format(PyExc_ImportError,
2463 "reload(): module %.200s not in sys.modules",
2464 name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002465 return NULL;
2466 }
Guido van Rossumd8faa362007-04-27 19:54:29 +00002467 existing_m = PyDict_GetItemString(modules_reloading, name);
2468 if (existing_m != NULL) {
2469 /* Due to a recursive reload, this module is already
2470 being reloaded. */
2471 Py_INCREF(existing_m);
2472 return existing_m;
2473 }
2474 if (PyDict_SetItemString(modules_reloading, name, m) < 0)
2475 return NULL;
2476
Guido van Rossum222ef561997-09-06 19:41:09 +00002477 subname = strrchr(name, '.');
2478 if (subname == NULL)
2479 subname = name;
2480 else {
2481 PyObject *parentname, *parent;
2482 parentname = PyString_FromStringAndSize(name, (subname-name));
Guido van Rossumd8faa362007-04-27 19:54:29 +00002483 if (parentname == NULL) {
2484 imp_modules_reloading_clear();
Guido van Rossum222ef561997-09-06 19:41:09 +00002485 return NULL;
Guido van Rossumd8faa362007-04-27 19:54:29 +00002486 }
Guido van Rossum222ef561997-09-06 19:41:09 +00002487 parent = PyDict_GetItem(modules, parentname);
2488 if (parent == NULL) {
2489 PyErr_Format(PyExc_ImportError,
2490 "reload(): parent %.200s not in sys.modules",
Georg Brandl0c55f292005-09-14 06:56:20 +00002491 PyString_AS_STRING(parentname));
2492 Py_DECREF(parentname);
Guido van Rossume7ba4952007-06-06 23:52:48 +00002493 imp_modules_reloading_clear();
Guido van Rossum222ef561997-09-06 19:41:09 +00002494 return NULL;
2495 }
Georg Brandl0c55f292005-09-14 06:56:20 +00002496 Py_DECREF(parentname);
Guido van Rossum222ef561997-09-06 19:41:09 +00002497 subname++;
2498 path = PyObject_GetAttrString(parent, "__path__");
2499 if (path == NULL)
2500 PyErr_Clear();
2501 }
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002502 buf[0] = '\0';
Phillip J. Eby7ec642a2004-09-23 04:37:36 +00002503 fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader);
Guido van Rossum222ef561997-09-06 19:41:09 +00002504 Py_XDECREF(path);
Phillip J. Eby7ec642a2004-09-23 04:37:36 +00002505
2506 if (fdp == NULL) {
2507 Py_XDECREF(loader);
Guido van Rossumd8faa362007-04-27 19:54:29 +00002508 imp_modules_reloading_clear();
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002509 return NULL;
Phillip J. Eby7ec642a2004-09-23 04:37:36 +00002510 }
2511
2512 newm = load_module(name, fp, buf, fdp->type, loader);
2513 Py_XDECREF(loader);
2514
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002515 if (fp)
2516 fclose(fp);
Tim Peters1cd70172004-08-02 03:52:12 +00002517 if (newm == NULL) {
2518 /* load_module probably removed name from modules because of
2519 * the error. Put back the original module object. We're
2520 * going to return NULL in this case regardless of whether
2521 * replacing name succeeds, so the return value is ignored.
2522 */
2523 PyDict_SetItemString(modules, name, m);
2524 }
Guido van Rossumd8faa362007-04-27 19:54:29 +00002525 imp_modules_reloading_clear();
Tim Peters1cd70172004-08-02 03:52:12 +00002526 return newm;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002527}
2528
2529
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002530/* Higher-level import emulator which emulates the "import" statement
2531 more accurately -- it invokes the __import__() function from the
2532 builtins of the current globals. This means that the import is
2533 done using whatever import hooks are installed in the current
Guido van Rossum6058eb41998-12-21 19:51:00 +00002534 environment, e.g. by "rexec".
2535 A dummy list ["__doc__"] is passed as the 4th argument so that
2536 e.g. PyImport_Import(PyString_FromString("win32com.client.gencache"))
2537 will return <module "gencache"> instead of <module "win32com">. */
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002538
2539PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002540PyImport_Import(PyObject *module_name)
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002541{
2542 static PyObject *silly_list = NULL;
2543 static PyObject *builtins_str = NULL;
2544 static PyObject *import_str = NULL;
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002545 PyObject *globals = NULL;
2546 PyObject *import = NULL;
2547 PyObject *builtins = NULL;
2548 PyObject *r = NULL;
2549
2550 /* Initialize constant string objects */
2551 if (silly_list == NULL) {
Martin v. Löwis5b222132007-06-10 09:51:05 +00002552 import_str = PyUnicode_InternFromString("__import__");
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002553 if (import_str == NULL)
2554 return NULL;
Martin v. Löwis5b222132007-06-10 09:51:05 +00002555 builtins_str = PyUnicode_InternFromString("__builtins__");
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002556 if (builtins_str == NULL)
2557 return NULL;
2558 silly_list = Py_BuildValue("[s]", "__doc__");
2559 if (silly_list == NULL)
2560 return NULL;
2561 }
2562
2563 /* Get the builtins from current globals */
2564 globals = PyEval_GetGlobals();
Guido van Rossum85cd1d62001-02-20 21:43:24 +00002565 if (globals != NULL) {
Guido van Rossum66468561998-10-22 15:46:50 +00002566 Py_INCREF(globals);
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002567 builtins = PyObject_GetItem(globals, builtins_str);
2568 if (builtins == NULL)
2569 goto err;
2570 }
2571 else {
2572 /* No globals -- use standard builtins, and fake globals */
2573 PyErr_Clear();
2574
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002575 builtins = PyImport_ImportModuleLevel("__builtin__",
2576 NULL, NULL, NULL, 0);
Guido van Rossum85cd1d62001-02-20 21:43:24 +00002577 if (builtins == NULL)
2578 return NULL;
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002579 globals = Py_BuildValue("{OO}", builtins_str, builtins);
2580 if (globals == NULL)
2581 goto err;
2582 }
2583
2584 /* Get the __import__ function from the builtins */
Tim Peters6d6c1a32001-08-02 04:15:00 +00002585 if (PyDict_Check(builtins)) {
Fred Drakea76ba6e2001-03-06 06:31:15 +00002586 import = PyObject_GetItem(builtins, import_str);
Tim Peters6d6c1a32001-08-02 04:15:00 +00002587 if (import == NULL)
2588 PyErr_SetObject(PyExc_KeyError, import_str);
2589 }
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002590 else
Fred Drakea76ba6e2001-03-06 06:31:15 +00002591 import = PyObject_GetAttr(builtins, import_str);
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002592 if (import == NULL)
2593 goto err;
2594
Guido van Rossumd8faa362007-04-27 19:54:29 +00002595 /* Call the __import__ function with the proper argument list */
Thomas Wouters477c8d52006-05-27 19:21:47 +00002596 r = PyObject_CallFunctionObjArgs(import, module_name, globals,
2597 globals, silly_list, NULL);
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002598
2599 err:
2600 Py_XDECREF(globals);
2601 Py_XDECREF(builtins);
2602 Py_XDECREF(import);
Tim Peters50d8d372001-02-28 05:34:27 +00002603
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002604 return r;
2605}
2606
2607
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002608/* Module 'imp' provides Python access to the primitives used for
2609 importing modules.
2610*/
2611
Guido van Rossum79f25d91997-04-29 20:08:16 +00002612static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +00002613imp_get_magic(PyObject *self, PyObject *noargs)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002614{
2615 char buf[4];
2616
Guido van Rossum96774c12000-05-01 20:19:08 +00002617 buf[0] = (char) ((pyc_magic >> 0) & 0xff);
2618 buf[1] = (char) ((pyc_magic >> 8) & 0xff);
2619 buf[2] = (char) ((pyc_magic >> 16) & 0xff);
2620 buf[3] = (char) ((pyc_magic >> 24) & 0xff);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002621
Guido van Rossum79f25d91997-04-29 20:08:16 +00002622 return PyString_FromStringAndSize(buf, 4);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002623}
2624
Guido van Rossum79f25d91997-04-29 20:08:16 +00002625static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +00002626imp_get_suffixes(PyObject *self, PyObject *noargs)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002627{
Guido van Rossum79f25d91997-04-29 20:08:16 +00002628 PyObject *list;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002629 struct filedescr *fdp;
2630
Guido van Rossum79f25d91997-04-29 20:08:16 +00002631 list = PyList_New(0);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002632 if (list == NULL)
2633 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002634 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
2635 PyObject *item = Py_BuildValue("ssi",
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002636 fdp->suffix, fdp->mode, fdp->type);
2637 if (item == NULL) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002638 Py_DECREF(list);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002639 return NULL;
2640 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002641 if (PyList_Append(list, item) < 0) {
2642 Py_DECREF(list);
2643 Py_DECREF(item);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002644 return NULL;
2645 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002646 Py_DECREF(item);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002647 }
2648 return list;
2649}
2650
Guido van Rossum79f25d91997-04-29 20:08:16 +00002651static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002652call_find_module(char *name, PyObject *path)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002653{
Tim Petersdbd9ba62000-07-09 03:09:57 +00002654 extern int fclose(FILE *);
Guido van Rossum79f25d91997-04-29 20:08:16 +00002655 PyObject *fob, *ret;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002656 struct filedescr *fdp;
2657 char pathname[MAXPATHLEN+1];
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002658 FILE *fp = NULL;
2659
2660 pathname[0] = '\0';
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002661 if (path == Py_None)
2662 path = NULL;
Just van Rossum52e14d62002-12-30 22:08:05 +00002663 fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002664 if (fdp == NULL)
2665 return NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002666 if (fp != NULL) {
2667 fob = PyFile_FromFile(fp, pathname, fdp->mode, fclose);
2668 if (fob == NULL) {
2669 fclose(fp);
2670 return NULL;
2671 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002672 }
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002673 else {
2674 fob = Py_None;
2675 Py_INCREF(fob);
Tim Peters50d8d372001-02-28 05:34:27 +00002676 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002677 ret = Py_BuildValue("Os(ssi)",
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002678 fob, pathname, fdp->suffix, fdp->mode, fdp->type);
Guido van Rossum79f25d91997-04-29 20:08:16 +00002679 Py_DECREF(fob);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002680 return ret;
2681}
2682
Guido van Rossum79f25d91997-04-29 20:08:16 +00002683static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002684imp_find_module(PyObject *self, PyObject *args)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002685{
2686 char *name;
2687 PyObject *path = NULL;
Guido van Rossum43713e52000-02-29 13:59:29 +00002688 if (!PyArg_ParseTuple(args, "s|O:find_module", &name, &path))
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002689 return NULL;
2690 return call_find_module(name, path);
2691}
2692
2693static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002694imp_init_builtin(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002695{
2696 char *name;
2697 int ret;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002698 PyObject *m;
Guido van Rossum43713e52000-02-29 13:59:29 +00002699 if (!PyArg_ParseTuple(args, "s:init_builtin", &name))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002700 return NULL;
2701 ret = init_builtin(name);
2702 if (ret < 0)
2703 return NULL;
2704 if (ret == 0) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002705 Py_INCREF(Py_None);
2706 return Py_None;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002707 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002708 m = PyImport_AddModule(name);
2709 Py_XINCREF(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002710 return m;
2711}
2712
Guido van Rossum79f25d91997-04-29 20:08:16 +00002713static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002714imp_init_frozen(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002715{
2716 char *name;
2717 int ret;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002718 PyObject *m;
Guido van Rossum43713e52000-02-29 13:59:29 +00002719 if (!PyArg_ParseTuple(args, "s:init_frozen", &name))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002720 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002721 ret = PyImport_ImportFrozenModule(name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002722 if (ret < 0)
2723 return NULL;
2724 if (ret == 0) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002725 Py_INCREF(Py_None);
2726 return Py_None;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002727 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002728 m = PyImport_AddModule(name);
2729 Py_XINCREF(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002730 return m;
2731}
2732
Guido van Rossum79f25d91997-04-29 20:08:16 +00002733static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002734imp_get_frozen_object(PyObject *self, PyObject *args)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002735{
2736 char *name;
Jack Jansen95ffa231995-10-03 14:38:41 +00002737
Guido van Rossum43713e52000-02-29 13:59:29 +00002738 if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name))
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002739 return NULL;
2740 return get_frozen_object(name);
2741}
2742
Guido van Rossum79f25d91997-04-29 20:08:16 +00002743static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002744imp_is_builtin(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002745{
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002746 char *name;
Guido van Rossum43713e52000-02-29 13:59:29 +00002747 if (!PyArg_ParseTuple(args, "s:is_builtin", &name))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002748 return NULL;
Guido van Rossum50ee94f2002-04-09 18:00:58 +00002749 return PyInt_FromLong(is_builtin(name));
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002750}
2751
Guido van Rossum79f25d91997-04-29 20:08:16 +00002752static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002753imp_is_frozen(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002754{
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002755 char *name;
Guido van Rossum323bf5e1998-06-24 03:54:06 +00002756 struct _frozen *p;
Guido van Rossum43713e52000-02-29 13:59:29 +00002757 if (!PyArg_ParseTuple(args, "s:is_frozen", &name))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002758 return NULL;
Guido van Rossum323bf5e1998-06-24 03:54:06 +00002759 p = find_frozen(name);
Guido van Rossumb8bff3f2002-04-07 06:34:38 +00002760 return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002761}
2762
2763static FILE *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002764get_file(char *pathname, PyObject *fob, char *mode)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002765{
2766 FILE *fp;
Guido van Rossumda5b8f22007-06-12 23:30:11 +00002767 if (mode[0] == 'U')
2768 mode = "r" PY_STDIOTEXTMODE;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002769 if (fob == NULL) {
2770 fp = fopen(pathname, mode);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002771 }
2772 else {
Guido van Rossumda5b8f22007-06-12 23:30:11 +00002773 int fd = PyObject_AsFileDescriptor(fob);
2774 if (fd == -1)
2775 return NULL;
2776 /* XXX This will leak a FILE struct. Fix this!!!!
2777 (But it doesn't leak a file descrioptor!) */
2778 fp = fdopen(fd, mode);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002779 }
Guido van Rossumda5b8f22007-06-12 23:30:11 +00002780 if (fp == NULL)
2781 PyErr_SetFromErrno(PyExc_IOError);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002782 return fp;
2783}
2784
Guido van Rossum79f25d91997-04-29 20:08:16 +00002785static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002786imp_load_compiled(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002787{
2788 char *name;
2789 char *pathname;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002790 PyObject *fob = NULL;
2791 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002792 FILE *fp;
Guido van Rossumda5b8f22007-06-12 23:30:11 +00002793 if (!PyArg_ParseTuple(args, "ss|O:load_compiled",
2794 &name, &pathname, &fob))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002795 return NULL;
2796 fp = get_file(pathname, fob, "rb");
2797 if (fp == NULL)
2798 return NULL;
2799 m = load_compiled_module(name, pathname, fp);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002800 if (fob == NULL)
2801 fclose(fp);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002802 return m;
2803}
2804
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002805#ifdef HAVE_DYNAMIC_LOADING
2806
Guido van Rossum79f25d91997-04-29 20:08:16 +00002807static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002808imp_load_dynamic(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002809{
2810 char *name;
2811 char *pathname;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002812 PyObject *fob = NULL;
2813 PyObject *m;
Guido van Rossum7faeab31995-07-07 22:50:36 +00002814 FILE *fp = NULL;
Guido van Rossumda5b8f22007-06-12 23:30:11 +00002815 if (!PyArg_ParseTuple(args, "ss|O:load_dynamic",
2816 &name, &pathname, &fob))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002817 return NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002818 if (fob) {
Guido van Rossum7faeab31995-07-07 22:50:36 +00002819 fp = get_file(pathname, fob, "r");
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002820 if (fp == NULL)
2821 return NULL;
2822 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002823 m = _PyImport_LoadDynamicModule(name, pathname, fp);
Guido van Rossum7faeab31995-07-07 22:50:36 +00002824 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002825}
2826
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002827#endif /* HAVE_DYNAMIC_LOADING */
2828
Guido van Rossum79f25d91997-04-29 20:08:16 +00002829static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002830imp_load_source(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002831{
2832 char *name;
2833 char *pathname;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002834 PyObject *fob = NULL;
2835 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002836 FILE *fp;
Guido van Rossumda5b8f22007-06-12 23:30:11 +00002837 if (!PyArg_ParseTuple(args, "ss|O:load_source",
2838 &name, &pathname, &fob))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002839 return NULL;
2840 fp = get_file(pathname, fob, "r");
2841 if (fp == NULL)
2842 return NULL;
2843 m = load_source_module(name, pathname, fp);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002844 if (fob == NULL)
2845 fclose(fp);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002846 return m;
2847}
2848
Guido van Rossum79f25d91997-04-29 20:08:16 +00002849static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002850imp_load_module(PyObject *self, PyObject *args)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002851{
2852 char *name;
2853 PyObject *fob;
2854 char *pathname;
2855 char *suffix; /* Unused */
2856 char *mode;
2857 int type;
2858 FILE *fp;
2859
Guido van Rossum43713e52000-02-29 13:59:29 +00002860 if (!PyArg_ParseTuple(args, "sOs(ssi):load_module",
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002861 &name, &fob, &pathname,
2862 &suffix, &mode, &type))
2863 return NULL;
Guido van Rossum5e2c5fa2002-05-30 17:33:07 +00002864 if (*mode) {
2865 /* Mode must start with 'r' or 'U' and must not contain '+'.
2866 Implicit in this test is the assumption that the mode
2867 may contain other modifiers like 'b' or 't'. */
2868
2869 if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) {
Jeremy Hylton4ae6fae2002-05-30 17:15:25 +00002870 PyErr_Format(PyExc_ValueError,
2871 "invalid file open mode %.200s", mode);
2872 return NULL;
Guido van Rossum5e2c5fa2002-05-30 17:33:07 +00002873 }
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002874 }
2875 if (fob == Py_None)
2876 fp = NULL;
2877 else {
Guido van Rossumda5b8f22007-06-12 23:30:11 +00002878 fp = get_file(NULL, fob, mode);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002879 if (fp == NULL)
2880 return NULL;
2881 }
Just van Rossum52e14d62002-12-30 22:08:05 +00002882 return load_module(name, fp, pathname, type, NULL);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002883}
2884
2885static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002886imp_load_package(PyObject *self, PyObject *args)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002887{
2888 char *name;
2889 char *pathname;
Guido van Rossum43713e52000-02-29 13:59:29 +00002890 if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname))
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002891 return NULL;
2892 return load_package(name, pathname);
2893}
2894
2895static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002896imp_new_module(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002897{
2898 char *name;
Guido van Rossum43713e52000-02-29 13:59:29 +00002899 if (!PyArg_ParseTuple(args, "s:new_module", &name))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002900 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002901 return PyModule_New(name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002902}
2903
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002904/* Doc strings */
2905
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002906PyDoc_STRVAR(doc_imp,
2907"This module provides the components needed to build your own\n\
2908__import__ function. Undocumented functions are obsolete.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002909
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002910PyDoc_STRVAR(doc_find_module,
2911"find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002912Search for a module. If path is omitted or None, search for a\n\
2913built-in, frozen or special module and continue search in sys.path.\n\
2914The module name cannot contain '.'; to search for a submodule of a\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002915package, pass the submodule name and the package's __path__.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002916
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002917PyDoc_STRVAR(doc_load_module,
2918"load_module(name, file, filename, (suffix, mode, type)) -> module\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002919Load a module, given information returned by find_module().\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002920The module name must include the full package name, if any.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002921
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002922PyDoc_STRVAR(doc_get_magic,
2923"get_magic() -> string\n\
2924Return the magic number for .pyc or .pyo files.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002925
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002926PyDoc_STRVAR(doc_get_suffixes,
2927"get_suffixes() -> [(suffix, mode, type), ...]\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002928Return a list of (suffix, mode, type) tuples describing the files\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002929that find_module() looks for.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002930
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002931PyDoc_STRVAR(doc_new_module,
2932"new_module(name) -> module\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002933Create a new module. Do not enter it in sys.modules.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002934The module name must include the full package name, if any.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002935
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002936PyDoc_STRVAR(doc_lock_held,
Tim Petersa7c65092004-08-01 23:26:05 +00002937"lock_held() -> boolean\n\
2938Return True if the import lock is currently held, else False.\n\
2939On platforms without threads, return False.");
Tim Peters69232342001-08-30 05:16:13 +00002940
Guido van Rossumc4f4ca92003-02-12 21:46:11 +00002941PyDoc_STRVAR(doc_acquire_lock,
2942"acquire_lock() -> None\n\
Neal Norwitz2294c0d2003-02-12 23:02:21 +00002943Acquires the interpreter's import lock for the current thread.\n\
2944This lock should be used by import hooks to ensure thread-safety\n\
2945when importing modules.\n\
Guido van Rossumc4f4ca92003-02-12 21:46:11 +00002946On platforms without threads, this function does nothing.");
2947
2948PyDoc_STRVAR(doc_release_lock,
2949"release_lock() -> None\n\
2950Release the interpreter's import lock.\n\
2951On platforms without threads, this function does nothing.");
2952
Guido van Rossum79f25d91997-04-29 20:08:16 +00002953static PyMethodDef imp_methods[] = {
Neal Norwitz08ea61a2003-02-17 18:18:00 +00002954 {"find_module", imp_find_module, METH_VARARGS, doc_find_module},
2955 {"get_magic", imp_get_magic, METH_NOARGS, doc_get_magic},
2956 {"get_suffixes", imp_get_suffixes, METH_NOARGS, doc_get_suffixes},
2957 {"load_module", imp_load_module, METH_VARARGS, doc_load_module},
2958 {"new_module", imp_new_module, METH_VARARGS, doc_new_module},
2959 {"lock_held", imp_lock_held, METH_NOARGS, doc_lock_held},
2960 {"acquire_lock", imp_acquire_lock, METH_NOARGS, doc_acquire_lock},
2961 {"release_lock", imp_release_lock, METH_NOARGS, doc_release_lock},
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002962 /* The rest are obsolete */
Neal Norwitz031829d2002-03-31 14:37:44 +00002963 {"get_frozen_object", imp_get_frozen_object, METH_VARARGS},
2964 {"init_builtin", imp_init_builtin, METH_VARARGS},
2965 {"init_frozen", imp_init_frozen, METH_VARARGS},
2966 {"is_builtin", imp_is_builtin, METH_VARARGS},
2967 {"is_frozen", imp_is_frozen, METH_VARARGS},
2968 {"load_compiled", imp_load_compiled, METH_VARARGS},
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002969#ifdef HAVE_DYNAMIC_LOADING
Neal Norwitz031829d2002-03-31 14:37:44 +00002970 {"load_dynamic", imp_load_dynamic, METH_VARARGS},
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002971#endif
Neal Norwitz031829d2002-03-31 14:37:44 +00002972 {"load_package", imp_load_package, METH_VARARGS},
Neal Norwitz031829d2002-03-31 14:37:44 +00002973 {"load_source", imp_load_source, METH_VARARGS},
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002974 {NULL, NULL} /* sentinel */
2975};
2976
Guido van Rossum1a8791e1998-08-04 22:46:29 +00002977static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002978setint(PyObject *d, char *name, int value)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002979{
2980 PyObject *v;
2981 int err;
2982
2983 v = PyInt_FromLong((long)value);
2984 err = PyDict_SetItemString(d, name, v);
2985 Py_XDECREF(v);
2986 return err;
2987}
2988
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002989typedef struct {
2990 PyObject_HEAD
2991} NullImporter;
2992
2993static int
2994NullImporter_init(NullImporter *self, PyObject *args, PyObject *kwds)
2995{
2996 char *path;
2997
2998 if (!_PyArg_NoKeywords("NullImporter()", kwds))
2999 return -1;
3000
3001 if (!PyArg_ParseTuple(args, "s:NullImporter",
3002 &path))
3003 return -1;
3004
3005 if (strlen(path) == 0) {
3006 PyErr_SetString(PyExc_ImportError, "empty pathname");
3007 return -1;
3008 } else {
3009#ifndef RISCOS
3010 struct stat statbuf;
3011 int rv;
3012
3013 rv = stat(path, &statbuf);
3014 if (rv == 0) {
3015 /* it exists */
3016 if (S_ISDIR(statbuf.st_mode)) {
3017 /* it's a directory */
3018 PyErr_SetString(PyExc_ImportError,
3019 "existing directory");
3020 return -1;
3021 }
3022 }
3023#else
3024 if (object_exists(path)) {
3025 /* it exists */
3026 if (isdir(path)) {
3027 /* it's a directory */
3028 PyErr_SetString(PyExc_ImportError,
3029 "existing directory");
3030 return -1;
3031 }
3032 }
3033#endif
3034 }
3035 return 0;
3036}
3037
3038static PyObject *
3039NullImporter_find_module(NullImporter *self, PyObject *args)
3040{
3041 Py_RETURN_NONE;
3042}
3043
3044static PyMethodDef NullImporter_methods[] = {
3045 {"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,
3046 "Always return None"
3047 },
3048 {NULL} /* Sentinel */
3049};
3050
3051
3052static PyTypeObject NullImporterType = {
3053 PyObject_HEAD_INIT(NULL)
3054 0, /*ob_size*/
3055 "imp.NullImporter", /*tp_name*/
3056 sizeof(NullImporter), /*tp_basicsize*/
3057 0, /*tp_itemsize*/
3058 0, /*tp_dealloc*/
3059 0, /*tp_print*/
3060 0, /*tp_getattr*/
3061 0, /*tp_setattr*/
3062 0, /*tp_compare*/
3063 0, /*tp_repr*/
3064 0, /*tp_as_number*/
3065 0, /*tp_as_sequence*/
3066 0, /*tp_as_mapping*/
3067 0, /*tp_hash */
3068 0, /*tp_call*/
3069 0, /*tp_str*/
3070 0, /*tp_getattro*/
3071 0, /*tp_setattro*/
3072 0, /*tp_as_buffer*/
3073 Py_TPFLAGS_DEFAULT, /*tp_flags*/
3074 "Null importer object", /* tp_doc */
3075 0, /* tp_traverse */
3076 0, /* tp_clear */
3077 0, /* tp_richcompare */
3078 0, /* tp_weaklistoffset */
3079 0, /* tp_iter */
3080 0, /* tp_iternext */
3081 NullImporter_methods, /* tp_methods */
3082 0, /* tp_members */
3083 0, /* tp_getset */
3084 0, /* tp_base */
3085 0, /* tp_dict */
3086 0, /* tp_descr_get */
3087 0, /* tp_descr_set */
3088 0, /* tp_dictoffset */
3089 (initproc)NullImporter_init, /* tp_init */
3090 0, /* tp_alloc */
3091 PyType_GenericNew /* tp_new */
3092};
3093
3094
Jason Tishler6bc06ec2003-09-04 11:59:50 +00003095PyMODINIT_FUNC
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003096initimp(void)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003097{
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003098 PyObject *m, *d;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003099
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003100 if (PyType_Ready(&NullImporterType) < 0)
3101 goto failure;
3102
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003103 m = Py_InitModule4("imp", imp_methods, doc_imp,
3104 NULL, PYTHON_API_VERSION);
Neal Norwitz1ac754f2006-01-19 06:09:39 +00003105 if (m == NULL)
3106 goto failure;
Guido van Rossum79f25d91997-04-29 20:08:16 +00003107 d = PyModule_GetDict(m);
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00003108 if (d == NULL)
3109 goto failure;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003110
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003111 if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;
3112 if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;
3113 if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;
3114 if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;
3115 if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;
3116 if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;
3117 if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;
3118 if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;
Guido van Rossum0f84a341998-08-06 13:36:01 +00003119 if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;
Just van Rossum52e14d62002-12-30 22:08:05 +00003120 if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003121
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003122 Py_INCREF(&NullImporterType);
3123 PyModule_AddObject(m, "NullImporter", (PyObject *)&NullImporterType);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003124 failure:
3125 ;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003126}
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003127
3128
Guido van Rossumb18618d2000-05-03 23:44:39 +00003129/* API for embedding applications that want to add their own entries
3130 to the table of built-in modules. This should normally be called
3131 *before* Py_Initialize(). When the table resize fails, -1 is
3132 returned and the existing table is unchanged.
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003133
3134 After a similar function by Just van Rossum. */
3135
3136int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003137PyImport_ExtendInittab(struct _inittab *newtab)
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003138{
3139 static struct _inittab *our_copy = NULL;
3140 struct _inittab *p;
3141 int i, n;
3142
3143 /* Count the number of entries in both tables */
3144 for (n = 0; newtab[n].name != NULL; n++)
3145 ;
3146 if (n == 0)
3147 return 0; /* Nothing to do */
3148 for (i = 0; PyImport_Inittab[i].name != NULL; i++)
3149 ;
3150
3151 /* Allocate new memory for the combined table */
Guido van Rossumb18618d2000-05-03 23:44:39 +00003152 p = our_copy;
3153 PyMem_RESIZE(p, struct _inittab, i+n+1);
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003154 if (p == NULL)
3155 return -1;
3156
3157 /* Copy the tables into the new memory */
3158 if (our_copy != PyImport_Inittab)
3159 memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
3160 PyImport_Inittab = our_copy = p;
3161 memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
3162
3163 return 0;
3164}
3165
3166/* Shorthand to add a single entry given a name and a function */
3167
3168int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003169PyImport_AppendInittab(char *name, void (*initfunc)(void))
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003170{
3171 struct _inittab newtab[2];
3172
3173 memset(newtab, '\0', sizeof newtab);
3174
3175 newtab[0].name = name;
3176 newtab[0].initfunc = initfunc;
3177
3178 return PyImport_ExtendInittab(newtab);
3179}
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00003180
3181#ifdef __cplusplus
3182}
3183#endif