blob: bcf6bd762215c2016c2490e4333595e8d2066bf6 [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 */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00008#include "errcode.h"
Guido van Rossumc405b7b1991-06-04 19:39:42 +00009#include "marshal.h"
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000010#include "code.h"
Guido van Rossumd8bac6d1992-02-26 15:19:13 +000011#include "osdefs.h"
Guido van Rossum1ae940a1995-01-02 19:04:15 +000012#include "importdl.h"
Guido van Rossumc405b7b1991-06-04 19:39:42 +000013
Guido van Rossum55a83382000-09-20 20:31:38 +000014#ifdef HAVE_FCNTL_H
15#include <fcntl.h>
16#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000017#ifdef __cplusplus
Brett Cannon9a5b25a2010-03-01 02:09:17 +000018extern "C" {
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000019#endif
Guido van Rossum55a83382000-09-20 20:31:38 +000020
Christian Heimesd3eb5a152008-02-24 00:38:49 +000021#ifdef MS_WINDOWS
22/* for stat.st_mode */
23typedef unsigned short mode_t;
Daniel Stutzbachc7937792010-09-09 21:18:04 +000024/* for _mkdir */
25#include <direct.h>
Christian Heimesd3eb5a152008-02-24 00:38:49 +000026#endif
27
Guido van Rossum21d335e1993-10-15 13:01:11 +000028
Jeremy Hyltond4ceb312004-04-01 02:45:22 +000029/* Magic word to reject .pyc files generated by other Python versions.
30 It should change for each incompatible change to the bytecode.
31
32 The value of CR and LF is incorporated so if you ever read or write
Guido van Rossum7faeab31995-07-07 22:50:36 +000033 a .pyc file in text mode the magic number will be wrong; also, the
Tim Peters36515e22001-11-18 04:06:29 +000034 Apple MPW compiler swaps their values, botching string constants.
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000035
Guido van Rossum45aecf42006-03-15 04:58:47 +000036 The magic numbers must be spaced apart at least 2 values, as the
Martin v. Löwisef82d2f2004-06-27 16:51:46 +000037 -U interpeter flag will cause MAGIC+1 being used. They have been
38 odd numbers for some time now.
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000039
Jeremy Hyltond4ceb312004-04-01 02:45:22 +000040 There were a variety of old schemes for setting the magic number.
41 The current working scheme is to increment the previous value by
42 10.
Guido van Rossumf6894922002-08-31 15:16:14 +000043
Barry Warsaw28a691b2010-04-17 00:19:56 +000044 Starting with the adoption of PEP 3147 in Python 3.2, every bump in magic
45 number also includes a new "magic tag", i.e. a human readable string used
46 to represent the magic number in __pycache__ directories. When you change
47 the magic number, you must also set a new unique magic tag. Generally this
48 can be named after the Python major version of the magic number bump, but
49 it can really be anything, as long as it's different than anything else
50 that's come before. The tags are included in the following table, starting
51 with Python 3.2a0.
52
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000053 Known values:
54 Python 1.5: 20121
55 Python 1.5.1: 20121
56 Python 1.5.2: 20121
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000057 Python 1.6: 50428
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000058 Python 2.0: 50823
59 Python 2.0.1: 50823
60 Python 2.1: 60202
61 Python 2.1.1: 60202
62 Python 2.1.2: 60202
63 Python 2.2: 60717
Neal Norwitz7fdcb412002-06-14 01:07:39 +000064 Python 2.3a0: 62011
Michael W. Hudsondd32a912002-08-15 14:59:02 +000065 Python 2.3a0: 62021
Guido van Rossumf6894922002-08-31 15:16:14 +000066 Python 2.3a0: 62011 (!)
Martin v. Löwisef82d2f2004-06-27 16:51:46 +000067 Python 2.4a0: 62041
Raymond Hettingerfd2d1f72004-08-23 23:37:48 +000068 Python 2.4a3: 62051
Raymond Hettinger2c31a052004-09-22 18:44:21 +000069 Python 2.4b1: 62061
Michael W. Hudsondf888462005-06-03 14:41:55 +000070 Python 2.5a0: 62071
Michael W. Hudsonaee2e282005-10-21 11:32:20 +000071 Python 2.5a0: 62081 (ast-branch)
Guido van Rossumc2e20742006-02-27 22:32:47 +000072 Python 2.5a0: 62091 (with)
Guido van Rossumf6694362006-03-10 02:28:35 +000073 Python 2.5a0: 62092 (changed WITH_CLEANUP opcode)
Thomas Wouters0e3f5912006-08-11 14:57:12 +000074 Python 2.5b3: 62101 (fix wrong code: for x, in ...)
75 Python 2.5b3: 62111 (fix wrong code: x += yield)
76 Python 2.5c1: 62121 (fix wrong lnotab with for loops and
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000077 storing constants that should have been removed)
Thomas Wouters89f507f2006-12-13 04:49:30 +000078 Python 2.5c2: 62131 (fix wrong code: for x, in ... in listcomp/genexp)
Christian Heimes99170a52007-12-19 02:07:34 +000079 Python 2.6a0: 62151 (peephole optimizations and STORE_MAP opcode)
Christian Heimesdd15f6c2008-03-16 00:07:10 +000080 Python 2.6a1: 62161 (WITH_CLEANUP optimization)
Guido van Rossum45aecf42006-03-15 04:58:47 +000081 Python 3000: 3000
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000082 3010 (removed UNARY_CONVERT)
83 3020 (added BUILD_SET)
84 3030 (added keyword-only parameters)
85 3040 (added signature annotations)
86 3050 (print becomes a function)
87 3060 (PEP 3115 metaclass syntax)
88 3061 (string literals become unicode)
89 3071 (PEP 3109 raise changes)
90 3081 (PEP 3137 make __file__ and __name__ unicode)
91 3091 (kill str8 interning)
92 3101 (merge from 2.6a0, see 62151)
93 3103 (__file__ points to source file)
Benjamin Peterson0f6cae02009-12-10 02:09:08 +000094 Python 3.0a4: 3111 (WITH_CLEANUP optimization).
95 Python 3.0a5: 3131 (lexical exception stacking, including POP_EXCEPT)
96 Python 3.1a0: 3141 (optimize list, set and dict comprehensions:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000097 change LIST_APPEND and SET_ADD, add MAP_ADD)
Benjamin Peterson0f6cae02009-12-10 02:09:08 +000098 Python 3.1a0: 3151 (optimize conditional branches:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000099 introduce POP_JUMP_IF_FALSE and POP_JUMP_IF_TRUE)
Benjamin Peterson876b2f22009-06-28 03:18:59 +0000100 Python 3.2a0: 3160 (add SETUP_WITH)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000101 tag: cpython-32
Antoine Pitrou74a69fa2010-09-04 18:43:52 +0000102 Python 3.2a1: 3170 (add DUP_TOP_TWO, remove DUP_TOPX and ROT_FOUR)
103 tag: cpython-32
Benjamin Peterson6246d6d2010-09-10 21:51:44 +0000104 Python 3.2a2 3180 (add DELETE_DEREF)
Benjamin Petersone7c15fa2011-06-19 19:54:45 -0500105 Python 3.3a0 3190 __class__ super closure changed
Antoine Pitrou86a36b52011-11-25 18:56:07 +0100106 Python 3.3a0 3200 (__qualname__ added)
Benjamin Petersonabdb5522012-03-15 15:40:37 -0500107 3210 (added size modulo 2**32 to the pyc header)
108 Python 3.3a1 3220 (changed PEP 380 implementation)
Tim Peters36515e22001-11-18 04:06:29 +0000109*/
Guido van Rossum3ddee711991-12-16 13:06:34 +0000110
Nick Coghlancd419ab2010-09-11 00:39:25 +0000111/* MAGIC must change whenever the bytecode emitted by the compiler may no
112 longer be understood by older implementations of the eval loop (usually
113 due to the addition of new opcodes)
Martin v. Löwisfadcd312011-10-23 18:08:20 +0200114 TAG must change for each major Python release. The magic number will take
115 care of any bytecode changes that occur during development.
Barry Warsaw28a691b2010-04-17 00:19:56 +0000116*/
Benjamin Peterson48deae12011-06-03 17:50:16 -0500117#define QUOTE(arg) #arg
118#define STRIFY(name) QUOTE(name)
119#define MAJOR STRIFY(PY_MAJOR_VERSION)
120#define MINOR STRIFY(PY_MINOR_VERSION)
Benjamin Petersonf53d20f2012-03-16 09:39:12 -0500121#define MAGIC (3220 | ((long)'\r'<<16) | ((long)'\n'<<24))
Benjamin Peterson48deae12011-06-03 17:50:16 -0500122#define TAG "cpython-" MAJOR MINOR;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000123#define CACHEDIR "__pycache__"
124/* Current magic word and string tag as globals. */
Guido van Rossum96774c12000-05-01 20:19:08 +0000125static long pyc_magic = MAGIC;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000126static const char *pyc_tag = TAG;
Benjamin Peterson48deae12011-06-03 17:50:16 -0500127#undef QUOTE
128#undef STRIFY
129#undef MAJOR
130#undef MINOR
Guido van Rossum96774c12000-05-01 20:19:08 +0000131
Victor Stinner95872862011-03-07 18:20:56 +0100132/* See _PyImport_FixupExtensionObject() below */
Guido van Rossum25ce5661997-08-02 03:10:38 +0000133static PyObject *extensions = NULL;
Guido van Rossum3f5da241990-12-20 15:06:42 +0000134
Victor Stinnerfe7c5b52011-04-05 01:48:03 +0200135/* Function from Parser/tokenizer.c */
136extern char * PyTokenizer_FindEncodingFilename(int, PyObject *);
137
Guido van Rossum771c6c81997-10-31 18:37:24 +0000138/* This table is defined in config.c: */
139extern struct _inittab _PyImport_Inittab[];
140
141struct _inittab *PyImport_Inittab = _PyImport_Inittab;
Guido van Rossum66f1fa81991-04-03 19:03:52 +0000142
Guido van Rossumed1170e1999-12-20 21:23:41 +0000143/* these tables define the module suffixes that Python recognizes */
144struct filedescr * _PyImport_Filetab = NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000145
Guido van Rossumed1170e1999-12-20 21:23:41 +0000146static const struct filedescr _PyImport_StandardFiletab[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000147 {".py", "U", PY_SOURCE},
Martin v. Löwis6238d2b2002-06-30 15:26:10 +0000148#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000149 {".pyw", "U", PY_SOURCE},
Tim Peters36515e22001-11-18 04:06:29 +0000150#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000151 {".pyc", "rb", PY_COMPILED},
152 {0, 0}
Guido van Rossumed1170e1999-12-20 21:23:41 +0000153};
154
Victor Stinnerd0296212011-03-14 14:04:10 -0400155static PyObject *initstr = NULL;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000156
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000157/* Initialize things */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000158
159void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000160_PyImport_Init(void)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000161{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000162 const struct filedescr *scan;
163 struct filedescr *filetab;
164 int countD = 0;
165 int countS = 0;
Guido van Rossumed1170e1999-12-20 21:23:41 +0000166
Victor Stinnerd0296212011-03-14 14:04:10 -0400167 initstr = PyUnicode_InternFromString("__init__");
168 if (initstr == NULL)
169 Py_FatalError("Can't initialize import variables");
170
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000171 /* prepare _PyImport_Filetab: copy entries from
172 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
173 */
Guido van Rossum04110fb2007-08-24 16:32:05 +0000174#ifdef HAVE_DYNAMIC_LOADING
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000175 for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)
176 ++countD;
Guido van Rossum04110fb2007-08-24 16:32:05 +0000177#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000178 for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
179 ++countS;
180 filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
181 if (filetab == NULL)
182 Py_FatalError("Can't initialize import file table.");
Guido van Rossum04110fb2007-08-24 16:32:05 +0000183#ifdef HAVE_DYNAMIC_LOADING
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000184 memcpy(filetab, _PyImport_DynLoadFiletab,
185 countD * sizeof(struct filedescr));
Guido van Rossum04110fb2007-08-24 16:32:05 +0000186#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000187 memcpy(filetab + countD, _PyImport_StandardFiletab,
188 countS * sizeof(struct filedescr));
189 filetab[countD + countS].suffix = NULL;
Guido van Rossumed1170e1999-12-20 21:23:41 +0000190
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000191 _PyImport_Filetab = filetab;
Guido van Rossumed1170e1999-12-20 21:23:41 +0000192
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000193 if (Py_OptimizeFlag) {
194 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
195 for (; filetab->suffix != NULL; filetab++) {
196 if (strcmp(filetab->suffix, ".pyc") == 0)
197 filetab->suffix = ".pyo";
198 }
199 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000200}
201
Guido van Rossum25ce5661997-08-02 03:10:38 +0000202void
Just van Rossum52e14d62002-12-30 22:08:05 +0000203_PyImportHooks_Init(void)
204{
Brett Cannonfd074152012-04-14 14:10:13 -0400205 PyObject *v, *path_hooks = NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000206 int err = 0;
Just van Rossum52e14d62002-12-30 22:08:05 +0000207
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000208 if (PyType_Ready(&PyNullImporter_Type) < 0)
209 goto error;
Just van Rossum52e14d62002-12-30 22:08:05 +0000210
Brett Cannonfd074152012-04-14 14:10:13 -0400211 /* adding sys.path_hooks and sys.path_importer_cache */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000212 v = PyList_New(0);
213 if (v == NULL)
214 goto error;
215 err = PySys_SetObject("meta_path", v);
216 Py_DECREF(v);
217 if (err)
218 goto error;
219 v = PyDict_New();
220 if (v == NULL)
221 goto error;
222 err = PySys_SetObject("path_importer_cache", v);
223 Py_DECREF(v);
224 if (err)
225 goto error;
226 path_hooks = PyList_New(0);
227 if (path_hooks == NULL)
228 goto error;
229 err = PySys_SetObject("path_hooks", path_hooks);
230 if (err) {
Just van Rossum52e14d62002-12-30 22:08:05 +0000231 error:
Brett Cannonfd074152012-04-14 14:10:13 -0400232 PyErr_Print();
233 Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
234 "path_importer_cache, or NullImporter failed"
235 );
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000236 }
Brett Cannonfd074152012-04-14 14:10:13 -0400237 Py_DECREF(path_hooks);
238}
239
240void
241_PyImportZip_Init(void)
242{
243 PyObject *path_hooks, *zimpimport;
244 int err = 0;
245
246 path_hooks = PySys_GetObject("path_hooks");
247 if (path_hooks == NULL)
248 goto error;
249
250 if (Py_VerboseFlag)
251 PySys_WriteStderr("# installing zipimport hook\n");
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000252
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000253 zimpimport = PyImport_ImportModule("zipimport");
254 if (zimpimport == NULL) {
255 PyErr_Clear(); /* No zip import module -- okay */
256 if (Py_VerboseFlag)
257 PySys_WriteStderr("# can't import zipimport\n");
258 }
259 else {
Martin v. Löwisbd928fe2011-10-14 10:20:37 +0200260 _Py_IDENTIFIER(zipimporter);
Martin v. Löwis1ee1b6f2011-10-10 18:11:30 +0200261 PyObject *zipimporter = _PyObject_GetAttrId(zimpimport,
262 &PyId_zipimporter);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000263 Py_DECREF(zimpimport);
264 if (zipimporter == NULL) {
265 PyErr_Clear(); /* No zipimporter object -- okay */
266 if (Py_VerboseFlag)
267 PySys_WriteStderr(
268 "# can't import zipimport.zipimporter\n");
269 }
270 else {
271 /* sys.path_hooks.append(zipimporter) */
272 err = PyList_Append(path_hooks, zipimporter);
273 Py_DECREF(zipimporter);
Brett Cannonfd074152012-04-14 14:10:13 -0400274 if (err < 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000275 goto error;
Brett Cannonfd074152012-04-14 14:10:13 -0400276 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000277 if (Py_VerboseFlag)
278 PySys_WriteStderr(
279 "# installed zipimport hook\n");
280 }
281 }
Brett Cannonfd074152012-04-14 14:10:13 -0400282
283 return;
284
285 error:
286 PyErr_Print();
287 Py_FatalError("initializing zipimport or NullImporter failed");
Just van Rossum52e14d62002-12-30 22:08:05 +0000288}
289
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000290/* Locking primitives to prevent parallel imports of the same module
291 in different threads to return with a partially loaded module.
292 These calls are serialized by the global interpreter lock. */
293
294#ifdef WITH_THREAD
295
Guido van Rossum49b56061998-10-01 20:42:43 +0000296#include "pythread.h"
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000297
Guido van Rossum65d5b571998-12-21 19:32:43 +0000298static PyThread_type_lock import_lock = 0;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000299static long import_lock_thread = -1;
300static int import_lock_level = 0;
301
Benjamin Peterson0df35a92009-10-04 20:32:25 +0000302void
303_PyImport_AcquireLock(void)
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000304{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000305 long me = PyThread_get_thread_ident();
306 if (me == -1)
307 return; /* Too bad */
308 if (import_lock == NULL) {
309 import_lock = PyThread_allocate_lock();
310 if (import_lock == NULL)
311 return; /* Nothing much we can do. */
312 }
313 if (import_lock_thread == me) {
314 import_lock_level++;
315 return;
316 }
317 if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
318 {
319 PyThreadState *tstate = PyEval_SaveThread();
320 PyThread_acquire_lock(import_lock, 1);
321 PyEval_RestoreThread(tstate);
322 }
323 import_lock_thread = me;
324 import_lock_level = 1;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000325}
326
Benjamin Peterson0df35a92009-10-04 20:32:25 +0000327int
328_PyImport_ReleaseLock(void)
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000329{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000330 long me = PyThread_get_thread_ident();
331 if (me == -1 || import_lock == NULL)
332 return 0; /* Too bad */
333 if (import_lock_thread != me)
334 return -1;
335 import_lock_level--;
336 if (import_lock_level == 0) {
337 import_lock_thread = -1;
338 PyThread_release_lock(import_lock);
339 }
340 return 1;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000341}
342
Gregory P. Smith24cec9f2010-03-01 06:18:41 +0000343/* This function is called from PyOS_AfterFork to ensure that newly
344 created child processes do not share locks with the parent.
345 We now acquire the import lock around fork() calls but on some platforms
346 (Solaris 9 and earlier? see isue7242) that still left us with problems. */
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +0000347
348void
349_PyImport_ReInitLock(void)
350{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000351 if (import_lock != NULL)
352 import_lock = PyThread_allocate_lock();
Nick Coghlanb2ddf792010-12-02 04:11:46 +0000353 if (import_lock_level > 1) {
354 /* Forked as a side effect of import */
355 long me = PyThread_get_thread_ident();
356 PyThread_acquire_lock(import_lock, 0);
Victor Stinner942003c2011-03-07 16:57:48 +0100357 /* XXX: can the previous line fail? */
Nick Coghlanb2ddf792010-12-02 04:11:46 +0000358 import_lock_thread = me;
359 import_lock_level--;
360 } else {
361 import_lock_thread = -1;
362 import_lock_level = 0;
363 }
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +0000364}
365
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000366#endif
367
Tim Peters69232342001-08-30 05:16:13 +0000368static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000369imp_lock_held(PyObject *self, PyObject *noargs)
Tim Peters69232342001-08-30 05:16:13 +0000370{
Tim Peters69232342001-08-30 05:16:13 +0000371#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000372 return PyBool_FromLong(import_lock_thread != -1);
Tim Peters69232342001-08-30 05:16:13 +0000373#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000374 return PyBool_FromLong(0);
Tim Peters69232342001-08-30 05:16:13 +0000375#endif
376}
377
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000378static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000379imp_acquire_lock(PyObject *self, PyObject *noargs)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000380{
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000381#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000382 _PyImport_AcquireLock();
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000383#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000384 Py_INCREF(Py_None);
385 return Py_None;
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000386}
387
388static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000389imp_release_lock(PyObject *self, PyObject *noargs)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000390{
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000391#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000392 if (_PyImport_ReleaseLock() < 0) {
393 PyErr_SetString(PyExc_RuntimeError,
394 "not holding the import lock");
395 return NULL;
396 }
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000397#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000398 Py_INCREF(Py_None);
399 return Py_None;
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000400}
401
Antoine Pitrou8db076c2011-10-30 19:13:55 +0100402void
403_PyImport_Fini(void)
404{
405 Py_XDECREF(extensions);
406 extensions = NULL;
407 PyMem_DEL(_PyImport_Filetab);
408 _PyImport_Filetab = NULL;
409#ifdef WITH_THREAD
410 if (import_lock != NULL) {
411 PyThread_free_lock(import_lock);
412 import_lock = NULL;
413 }
414#endif
415}
416
Guido van Rossumd8faa362007-04-27 19:54:29 +0000417static void
418imp_modules_reloading_clear(void)
419{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000420 PyInterpreterState *interp = PyThreadState_Get()->interp;
421 if (interp->modules_reloading != NULL)
422 PyDict_Clear(interp->modules_reloading);
Guido van Rossumd8faa362007-04-27 19:54:29 +0000423}
424
Guido van Rossum25ce5661997-08-02 03:10:38 +0000425/* Helper for sys */
426
427PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000428PyImport_GetModuleDict(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000429{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000430 PyInterpreterState *interp = PyThreadState_GET()->interp;
431 if (interp->modules == NULL)
432 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
433 return interp->modules;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000434}
435
Guido van Rossum3f5da241990-12-20 15:06:42 +0000436
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000437/* List of names to clear in sys */
438static char* sys_deletes[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000439 "path", "argv", "ps1", "ps2",
440 "last_type", "last_value", "last_traceback",
441 "path_hooks", "path_importer_cache", "meta_path",
442 /* misc stuff */
443 "flags", "float_info",
444 NULL
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000445};
446
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000447static char* sys_files[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000448 "stdin", "__stdin__",
449 "stdout", "__stdout__",
450 "stderr", "__stderr__",
451 NULL
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000452};
453
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000454
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000455/* Un-initialize things, as good as we can */
Guido van Rossum3f5da241990-12-20 15:06:42 +0000456
Guido van Rossum3f5da241990-12-20 15:06:42 +0000457void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000458PyImport_Cleanup(void)
Guido van Rossum3f5da241990-12-20 15:06:42 +0000459{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000460 Py_ssize_t pos, ndone;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000461 PyObject *key, *value, *dict;
462 PyInterpreterState *interp = PyThreadState_GET()->interp;
463 PyObject *modules = interp->modules;
Guido van Rossum758eec01998-01-19 21:58:26 +0000464
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000465 if (modules == NULL)
466 return; /* Already done */
Guido van Rossum758eec01998-01-19 21:58:26 +0000467
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000468 /* Delete some special variables first. These are common
469 places where user values hide and people complain when their
470 destructors fail. Since the modules containing them are
471 deleted *last* of all, they would come too late in the normal
472 destruction order. Sigh. */
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000473
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000474 value = PyDict_GetItemString(modules, "builtins");
475 if (value != NULL && PyModule_Check(value)) {
476 dict = PyModule_GetDict(value);
477 if (Py_VerboseFlag)
478 PySys_WriteStderr("# clear builtins._\n");
479 PyDict_SetItemString(dict, "_", Py_None);
480 }
481 value = PyDict_GetItemString(modules, "sys");
482 if (value != NULL && PyModule_Check(value)) {
483 char **p;
484 PyObject *v;
485 dict = PyModule_GetDict(value);
486 for (p = sys_deletes; *p != NULL; p++) {
487 if (Py_VerboseFlag)
488 PySys_WriteStderr("# clear sys.%s\n", *p);
489 PyDict_SetItemString(dict, *p, Py_None);
490 }
491 for (p = sys_files; *p != NULL; p+=2) {
492 if (Py_VerboseFlag)
493 PySys_WriteStderr("# restore sys.%s\n", *p);
494 v = PyDict_GetItemString(dict, *(p+1));
495 if (v == NULL)
496 v = Py_None;
497 PyDict_SetItemString(dict, *p, v);
498 }
499 }
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000500
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000501 /* First, delete __main__ */
502 value = PyDict_GetItemString(modules, "__main__");
503 if (value != NULL && PyModule_Check(value)) {
504 if (Py_VerboseFlag)
505 PySys_WriteStderr("# cleanup __main__\n");
506 _PyModule_Clear(value);
507 PyDict_SetItemString(modules, "__main__", Py_None);
508 }
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000509
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000510 /* The special treatment of "builtins" here is because even
511 when it's not referenced as a module, its dictionary is
512 referenced by almost every module's __builtins__. Since
513 deleting a module clears its dictionary (even if there are
514 references left to it), we need to delete the "builtins"
515 module last. Likewise, we don't delete sys until the very
516 end because it is implicitly referenced (e.g. by print).
Guido van Rossum758eec01998-01-19 21:58:26 +0000517
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000518 Also note that we 'delete' modules by replacing their entry
519 in the modules dict with None, rather than really deleting
520 them; this avoids a rehash of the modules dictionary and
521 also marks them as "non existent" so they won't be
522 re-imported. */
Guido van Rossum758eec01998-01-19 21:58:26 +0000523
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000524 /* Next, repeatedly delete modules with a reference count of
525 one (skipping builtins and sys) and delete them */
526 do {
527 ndone = 0;
528 pos = 0;
529 while (PyDict_Next(modules, &pos, &key, &value)) {
530 if (value->ob_refcnt != 1)
531 continue;
532 if (PyUnicode_Check(key) && PyModule_Check(value)) {
Victor Stinner9464d612011-03-07 17:08:21 +0100533 if (PyUnicode_CompareWithASCIIString(key, "builtins") == 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000534 continue;
Victor Stinner9464d612011-03-07 17:08:21 +0100535 if (PyUnicode_CompareWithASCIIString(key, "sys") == 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000536 continue;
537 if (Py_VerboseFlag)
Victor Stinner9464d612011-03-07 17:08:21 +0100538 PySys_FormatStderr(
539 "# cleanup[1] %U\n", key);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000540 _PyModule_Clear(value);
541 PyDict_SetItem(modules, key, Py_None);
542 ndone++;
543 }
544 }
545 } while (ndone > 0);
Guido van Rossum758eec01998-01-19 21:58:26 +0000546
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000547 /* Next, delete all modules (still skipping builtins and sys) */
548 pos = 0;
549 while (PyDict_Next(modules, &pos, &key, &value)) {
550 if (PyUnicode_Check(key) && PyModule_Check(value)) {
Victor Stinner9464d612011-03-07 17:08:21 +0100551 if (PyUnicode_CompareWithASCIIString(key, "builtins") == 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000552 continue;
Victor Stinner9464d612011-03-07 17:08:21 +0100553 if (PyUnicode_CompareWithASCIIString(key, "sys") == 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000554 continue;
555 if (Py_VerboseFlag)
Victor Stinner9464d612011-03-07 17:08:21 +0100556 PySys_FormatStderr("# cleanup[2] %U\n", key);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000557 _PyModule_Clear(value);
558 PyDict_SetItem(modules, key, Py_None);
559 }
560 }
Guido van Rossum758eec01998-01-19 21:58:26 +0000561
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000562 /* Next, delete sys and builtins (in that order) */
563 value = PyDict_GetItemString(modules, "sys");
564 if (value != NULL && PyModule_Check(value)) {
565 if (Py_VerboseFlag)
566 PySys_WriteStderr("# cleanup sys\n");
567 _PyModule_Clear(value);
568 PyDict_SetItemString(modules, "sys", Py_None);
569 }
570 value = PyDict_GetItemString(modules, "builtins");
571 if (value != NULL && PyModule_Check(value)) {
572 if (Py_VerboseFlag)
573 PySys_WriteStderr("# cleanup builtins\n");
574 _PyModule_Clear(value);
575 PyDict_SetItemString(modules, "builtins", Py_None);
576 }
Guido van Rossum758eec01998-01-19 21:58:26 +0000577
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000578 /* Finally, clear and delete the modules directory */
579 PyDict_Clear(modules);
580 interp->modules = NULL;
581 Py_DECREF(modules);
582 Py_CLEAR(interp->modules_reloading);
Guido van Rossum8d15b5d1990-10-26 14:58:58 +0000583}
Guido van Rossum7f133ed1991-02-19 12:23:57 +0000584
585
Barry Warsaw28a691b2010-04-17 00:19:56 +0000586/* Helper for pythonrun.c -- return magic number and tag. */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000587
588long
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000589PyImport_GetMagicNumber(void)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000590{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000591 return pyc_magic;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000592}
593
594
Barry Warsaw28a691b2010-04-17 00:19:56 +0000595const char *
596PyImport_GetMagicTag(void)
597{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000598 return pyc_tag;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000599}
600
Guido van Rossum25ce5661997-08-02 03:10:38 +0000601/* Magic for extension modules (built-in as well as dynamically
602 loaded). To prevent initializing an extension module more than
603 once, we keep a static dictionary 'extensions' keyed by module name
604 (for built-in modules) or by filename (for dynamically loaded
Barry Warsaw92883382001-08-13 23:05:44 +0000605 modules), containing these modules. A copy of the module's
Victor Stinner95872862011-03-07 18:20:56 +0100606 dictionary is stored by calling _PyImport_FixupExtensionObject()
Guido van Rossum25ce5661997-08-02 03:10:38 +0000607 immediately after the module initialization function succeeds. A
608 copy can be retrieved from there by calling
Victor Stinner95872862011-03-07 18:20:56 +0100609 _PyImport_FindExtensionObject().
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000610
Barry Warsaw7c9627b2010-06-17 18:38:20 +0000611 Modules which do support multiple initialization set their m_size
612 field to a non-negative number (indicating the size of the
613 module-specific state). They are still recorded in the extensions
614 dictionary, to avoid loading shared libraries twice.
Martin v. Löwis1a214512008-06-11 05:26:20 +0000615*/
616
617int
Victor Stinner95872862011-03-07 18:20:56 +0100618_PyImport_FixupExtensionObject(PyObject *mod, PyObject *name,
619 PyObject *filename)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000620{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000621 PyObject *modules, *dict;
622 struct PyModuleDef *def;
623 if (extensions == NULL) {
624 extensions = PyDict_New();
625 if (extensions == NULL)
626 return -1;
627 }
628 if (mod == NULL || !PyModule_Check(mod)) {
629 PyErr_BadInternalCall();
630 return -1;
631 }
632 def = PyModule_GetDef(mod);
633 if (!def) {
634 PyErr_BadInternalCall();
635 return -1;
636 }
637 modules = PyImport_GetModuleDict();
Victor Stinner95872862011-03-07 18:20:56 +0100638 if (PyDict_SetItem(modules, name, mod) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000639 return -1;
640 if (_PyState_AddModule(mod, def) < 0) {
Victor Stinner95872862011-03-07 18:20:56 +0100641 PyDict_DelItem(modules, name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000642 return -1;
643 }
644 if (def->m_size == -1) {
645 if (def->m_base.m_copy) {
646 /* Somebody already imported the module,
647 likely under a different name.
648 XXX this should really not happen. */
649 Py_DECREF(def->m_base.m_copy);
650 def->m_base.m_copy = NULL;
651 }
652 dict = PyModule_GetDict(mod);
653 if (dict == NULL)
654 return -1;
655 def->m_base.m_copy = PyDict_Copy(dict);
656 if (def->m_base.m_copy == NULL)
657 return -1;
658 }
Victor Stinner49d3f252010-10-17 01:24:53 +0000659 PyDict_SetItem(extensions, filename, (PyObject*)def);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000660 return 0;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000661}
662
Victor Stinner49d3f252010-10-17 01:24:53 +0000663int
664_PyImport_FixupBuiltin(PyObject *mod, char *name)
665{
666 int res;
Victor Stinner95872862011-03-07 18:20:56 +0100667 PyObject *nameobj;
Victor Stinner21fcd0c2011-03-07 18:28:15 +0100668 nameobj = PyUnicode_InternFromString(name);
Victor Stinner95872862011-03-07 18:20:56 +0100669 if (nameobj == NULL)
Victor Stinner49d3f252010-10-17 01:24:53 +0000670 return -1;
Victor Stinner95872862011-03-07 18:20:56 +0100671 res = _PyImport_FixupExtensionObject(mod, nameobj, nameobj);
672 Py_DECREF(nameobj);
Victor Stinner49d3f252010-10-17 01:24:53 +0000673 return res;
674}
675
Guido van Rossum25ce5661997-08-02 03:10:38 +0000676PyObject *
Victor Stinner95872862011-03-07 18:20:56 +0100677_PyImport_FindExtensionObject(PyObject *name, PyObject *filename)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000678{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000679 PyObject *mod, *mdict;
680 PyModuleDef* def;
681 if (extensions == NULL)
682 return NULL;
Victor Stinner49d3f252010-10-17 01:24:53 +0000683 def = (PyModuleDef*)PyDict_GetItem(extensions, filename);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000684 if (def == NULL)
685 return NULL;
686 if (def->m_size == -1) {
687 /* Module does not support repeated initialization */
688 if (def->m_base.m_copy == NULL)
689 return NULL;
Victor Stinner95872862011-03-07 18:20:56 +0100690 mod = PyImport_AddModuleObject(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000691 if (mod == NULL)
692 return NULL;
693 mdict = PyModule_GetDict(mod);
694 if (mdict == NULL)
695 return NULL;
696 if (PyDict_Update(mdict, def->m_base.m_copy))
697 return NULL;
698 }
699 else {
700 if (def->m_base.m_init == NULL)
701 return NULL;
702 mod = def->m_base.m_init();
703 if (mod == NULL)
704 return NULL;
Victor Stinner95872862011-03-07 18:20:56 +0100705 PyDict_SetItem(PyImport_GetModuleDict(), name, mod);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000706 Py_DECREF(mod);
707 }
708 if (_PyState_AddModule(mod, def) < 0) {
Victor Stinner95872862011-03-07 18:20:56 +0100709 PyDict_DelItem(PyImport_GetModuleDict(), name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000710 Py_DECREF(mod);
711 return NULL;
712 }
713 if (Py_VerboseFlag)
Victor Stinner95872862011-03-07 18:20:56 +0100714 PySys_FormatStderr("import %U # previously loaded (%R)\n",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000715 name, filename);
716 return mod;
Brett Cannon9a5b25a2010-03-01 02:09:17 +0000717
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000718}
719
Victor Stinner49d3f252010-10-17 01:24:53 +0000720PyObject *
Victor Stinner501c09a2011-02-23 00:02:00 +0000721_PyImport_FindBuiltin(const char *name)
Victor Stinner49d3f252010-10-17 01:24:53 +0000722{
Victor Stinner95872862011-03-07 18:20:56 +0100723 PyObject *res, *nameobj;
Victor Stinner21fcd0c2011-03-07 18:28:15 +0100724 nameobj = PyUnicode_InternFromString(name);
Victor Stinner95872862011-03-07 18:20:56 +0100725 if (nameobj == NULL)
Victor Stinner49d3f252010-10-17 01:24:53 +0000726 return NULL;
Victor Stinner95872862011-03-07 18:20:56 +0100727 res = _PyImport_FindExtensionObject(nameobj, nameobj);
728 Py_DECREF(nameobj);
Victor Stinner49d3f252010-10-17 01:24:53 +0000729 return res;
730}
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000731
732/* Get the module object corresponding to a module name.
733 First check the modules dictionary if there's one there,
Walter Dörwaldf0dfc7a2003-10-20 14:01:56 +0000734 if not, create a new one and insert it in the modules dictionary.
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000735 Because the former action is most common, THIS DOES NOT RETURN A
736 'NEW' REFERENCE! */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000737
Guido van Rossum79f25d91997-04-29 20:08:16 +0000738PyObject *
Victor Stinner27ee0892011-03-04 12:57:09 +0000739PyImport_AddModuleObject(PyObject *name)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000740{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000741 PyObject *modules = PyImport_GetModuleDict();
742 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000743
Victor Stinner27ee0892011-03-04 12:57:09 +0000744 if ((m = PyDict_GetItem(modules, name)) != NULL &&
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000745 PyModule_Check(m))
746 return m;
Victor Stinner27ee0892011-03-04 12:57:09 +0000747 m = PyModule_NewObject(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000748 if (m == NULL)
749 return NULL;
Victor Stinner27ee0892011-03-04 12:57:09 +0000750 if (PyDict_SetItem(modules, name, m) != 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000751 Py_DECREF(m);
752 return NULL;
753 }
754 Py_DECREF(m); /* Yes, it still exists, in modules! */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000755
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000756 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000757}
758
Victor Stinner27ee0892011-03-04 12:57:09 +0000759PyObject *
760PyImport_AddModule(const char *name)
761{
762 PyObject *nameobj, *module;
763 nameobj = PyUnicode_FromString(name);
764 if (nameobj == NULL)
765 return NULL;
766 module = PyImport_AddModuleObject(nameobj);
767 Py_DECREF(nameobj);
768 return module;
769}
770
771
Tim Peters1cd70172004-08-02 03:52:12 +0000772/* Remove name from sys.modules, if it's there. */
773static void
Victor Stinner27ee0892011-03-04 12:57:09 +0000774remove_module(PyObject *name)
Tim Peters1cd70172004-08-02 03:52:12 +0000775{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000776 PyObject *modules = PyImport_GetModuleDict();
Victor Stinner27ee0892011-03-04 12:57:09 +0000777 if (PyDict_GetItem(modules, name) == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000778 return;
Victor Stinner27ee0892011-03-04 12:57:09 +0000779 if (PyDict_DelItem(modules, name) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000780 Py_FatalError("import: deleting existing key in"
781 "sys.modules failed");
Tim Peters1cd70172004-08-02 03:52:12 +0000782}
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000783
Victor Stinnerc9abda02011-03-14 13:33:46 -0400784static PyObject * get_sourcefile(PyObject *filename);
785static PyObject *make_source_pathname(PyObject *pathname);
Christian Heimes3b06e532008-01-07 20:12:44 +0000786
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000787/* Execute a code object in a module and return the module object
Tim Peters1cd70172004-08-02 03:52:12 +0000788 * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
789 * removed from sys.modules, to avoid leaving damaged module objects
790 * in sys.modules. The caller may wish to restore the original
791 * module object (if any) in this case; PyImport_ReloadModule is an
792 * example.
Barry Warsaw28a691b2010-04-17 00:19:56 +0000793 *
794 * Note that PyImport_ExecCodeModuleWithPathnames() is the preferred, richer
795 * interface. The other two exist primarily for backward compatibility.
Tim Peters1cd70172004-08-02 03:52:12 +0000796 */
Guido van Rossum79f25d91997-04-29 20:08:16 +0000797PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000798PyImport_ExecCodeModule(char *name, PyObject *co)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000799{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000800 return PyImport_ExecCodeModuleWithPathnames(
801 name, co, (char *)NULL, (char *)NULL);
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000802}
803
804PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000805PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000806{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000807 return PyImport_ExecCodeModuleWithPathnames(
808 name, co, pathname, (char *)NULL);
Barry Warsaw28a691b2010-04-17 00:19:56 +0000809}
810
811PyObject *
812PyImport_ExecCodeModuleWithPathnames(char *name, PyObject *co, char *pathname,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000813 char *cpathname)
Barry Warsaw28a691b2010-04-17 00:19:56 +0000814{
Victor Stinner27ee0892011-03-04 12:57:09 +0000815 PyObject *m = NULL;
816 PyObject *nameobj, *pathobj = NULL, *cpathobj = NULL;
817
818 nameobj = PyUnicode_FromString(name);
819 if (nameobj == NULL)
820 return NULL;
821
822 if (pathname != NULL) {
823 pathobj = PyUnicode_DecodeFSDefault(pathname);
824 if (pathobj == NULL)
825 goto error;
826 } else
827 pathobj = NULL;
828 if (cpathname != NULL) {
829 cpathobj = PyUnicode_DecodeFSDefault(cpathname);
830 if (cpathobj == NULL)
831 goto error;
832 } else
833 cpathobj = NULL;
834 m = PyImport_ExecCodeModuleObject(nameobj, co, pathobj, cpathobj);
835error:
836 Py_DECREF(nameobj);
837 Py_XDECREF(pathobj);
838 Py_XDECREF(cpathobj);
839 return m;
840}
841
842PyObject*
843PyImport_ExecCodeModuleObject(PyObject *name, PyObject *co, PyObject *pathname,
844 PyObject *cpathname)
845{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000846 PyObject *modules = PyImport_GetModuleDict();
847 PyObject *m, *d, *v;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000848
Victor Stinner27ee0892011-03-04 12:57:09 +0000849 m = PyImport_AddModuleObject(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000850 if (m == NULL)
851 return NULL;
852 /* If the module is being reloaded, we get the old module back
853 and re-use its dict to exec the new code. */
854 d = PyModule_GetDict(m);
855 if (PyDict_GetItemString(d, "__builtins__") == NULL) {
856 if (PyDict_SetItemString(d, "__builtins__",
857 PyEval_GetBuiltins()) != 0)
858 goto error;
859 }
860 /* Remember the filename as the __file__ attribute */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000861 if (pathname != NULL) {
Victor Stinnerc9abda02011-03-14 13:33:46 -0400862 v = get_sourcefile(pathname);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000863 if (v == NULL)
864 PyErr_Clear();
865 }
Victor Stinner27ee0892011-03-04 12:57:09 +0000866 else
867 v = NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000868 if (v == NULL) {
869 v = ((PyCodeObject *)co)->co_filename;
870 Py_INCREF(v);
871 }
872 if (PyDict_SetItemString(d, "__file__", v) != 0)
873 PyErr_Clear(); /* Not important enough to report */
874 Py_DECREF(v);
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000875
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000876 /* Remember the pyc path name as the __cached__ attribute. */
Victor Stinner27ee0892011-03-04 12:57:09 +0000877 if (cpathname != NULL)
878 v = cpathname;
879 else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000880 v = Py_None;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000881 if (PyDict_SetItemString(d, "__cached__", v) != 0)
882 PyErr_Clear(); /* Not important enough to report */
Barry Warsaw28a691b2010-04-17 00:19:56 +0000883
Martin v. Löwis4d0d4712010-12-03 20:14:31 +0000884 v = PyEval_EvalCode(co, d, d);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000885 if (v == NULL)
886 goto error;
887 Py_DECREF(v);
Guido van Rossumb65e85c1997-07-10 18:00:45 +0000888
Victor Stinner27ee0892011-03-04 12:57:09 +0000889 if ((m = PyDict_GetItem(modules, name)) == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000890 PyErr_Format(PyExc_ImportError,
Victor Stinner27ee0892011-03-04 12:57:09 +0000891 "Loaded module %R not found in sys.modules",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000892 name);
893 return NULL;
894 }
Guido van Rossumb65e85c1997-07-10 18:00:45 +0000895
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000896 Py_INCREF(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000897
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000898 return m;
Tim Peters1cd70172004-08-02 03:52:12 +0000899
900 error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000901 remove_module(name);
902 return NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000903}
904
905
Martin v. Löwis2db72862011-10-23 17:29:08 +0200906/* Like rightmost_sep, but operate on unicode objects. */
907static Py_ssize_t
Martin v. Löwis8a0ef782011-10-23 18:05:06 +0200908rightmost_sep_obj(PyObject* o, Py_ssize_t start, Py_ssize_t end)
Martin v. Löwis2db72862011-10-23 17:29:08 +0200909{
910 Py_ssize_t found, i;
911 Py_UCS4 c;
Martin v. Löwis8a0ef782011-10-23 18:05:06 +0200912 for (found = -1, i = start; i < end; i++) {
Martin v. Löwis2db72862011-10-23 17:29:08 +0200913 c = PyUnicode_READ_CHAR(o, i);
914 if (c == SEP
915#ifdef ALTSEP
916 || c == ALTSEP
917#endif
918 )
919 {
920 found = i;
921 }
922 }
923 return found;
924}
Victor Stinnerc9abda02011-03-14 13:33:46 -0400925
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000926
Barry Warsaw28a691b2010-04-17 00:19:56 +0000927/* Given a pathname to a Python byte compiled file, return the path to the
928 source file, if the path matches the PEP 3147 format. This does not check
929 for any file existence, however, if the pyc file name does not match PEP
930 3147 style, NULL is returned. buf must be at least as big as pathname;
Victor Stinnerc9abda02011-03-14 13:33:46 -0400931 the resulting path will always be shorter.
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000932
Victor Stinnerc9abda02011-03-14 13:33:46 -0400933 (...)/__pycache__/foo.<tag>.pyc -> (...)/foo.py */
934
935static PyObject*
Martin v. Löwis8a0ef782011-10-23 18:05:06 +0200936make_source_pathname(PyObject *path)
Barry Warsaw28a691b2010-04-17 00:19:56 +0000937{
Martin v. Löwis8a0ef782011-10-23 18:05:06 +0200938 Py_ssize_t left, right, dot0, dot1, len;
939 Py_ssize_t i, j;
940 PyObject *result;
941 int kind;
942 void *data;
Victor Stinnerc9abda02011-03-14 13:33:46 -0400943
Martin v. Löwis8a0ef782011-10-23 18:05:06 +0200944 len = PyUnicode_GET_LENGTH(path);
945 if (len > MAXPATHLEN)
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200946 return NULL;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000947
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000948 /* Look back two slashes from the end. In between these two slashes
949 must be the string __pycache__ or this is not a PEP 3147 style
950 path. It's possible for there to be only one slash.
951 */
Martin v. Löwis8a0ef782011-10-23 18:05:06 +0200952 right = rightmost_sep_obj(path, 0, len);
953 if (right == -1)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000954 return NULL;
Martin v. Löwis8a0ef782011-10-23 18:05:06 +0200955 left = rightmost_sep_obj(path, 0, right);
956 if (left == -1)
957 left = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000958 else
959 left++;
Martin v. Löwis8a0ef782011-10-23 18:05:06 +0200960 if (right-left != sizeof(CACHEDIR)-1)
961 return NULL;
962 for (i = 0; i < sizeof(CACHEDIR)-1; i++)
963 if (PyUnicode_READ_CHAR(path, left+i) != CACHEDIR[i])
964 return NULL;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000965
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000966 /* Now verify that the path component to the right of the last slash
967 has two dots in it.
968 */
Martin v. Löwis8a0ef782011-10-23 18:05:06 +0200969 dot0 = PyUnicode_FindChar(path, '.', right+1, len, 1);
970 if (dot0 < 0)
971 return NULL;
972 dot1 = PyUnicode_FindChar(path, '.', dot0+1, len, 1);
973 if (dot1 < 0)
974 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000975 /* Too many dots? */
Martin v. Löwis8a0ef782011-10-23 18:05:06 +0200976 if (PyUnicode_FindChar(path, '.', dot1+1, len, 1) != -1)
977 return NULL;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000978
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000979 /* This is a PEP 3147 path. Start by copying everything from the
980 start of pathname up to and including the leftmost slash. Then
981 copy the file's basename, removing the magic tag and adding a .py
982 suffix.
983 */
Martin v. Löwis8a0ef782011-10-23 18:05:06 +0200984 result = PyUnicode_New(left + (dot0-right) + 2,
985 PyUnicode_MAX_CHAR_VALUE(path));
986 if (!result)
987 return NULL;
988 kind = PyUnicode_KIND(result);
989 data = PyUnicode_DATA(result);
990 PyUnicode_CopyCharacters(result, 0, path, 0, (i = left));
991 PyUnicode_CopyCharacters(result, left, path, right+1,
992 (j = dot0-right));
993 PyUnicode_WRITE(kind, data, i+j, 'p');
994 PyUnicode_WRITE(kind, data, i+j+1, 'y');
995 return result;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000996}
997
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000998
Antoine Pitroud35cbf62009-01-06 19:02:24 +0000999static void
1000update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)
1001{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001002 PyObject *constants, *tmp;
1003 Py_ssize_t i, n;
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001004
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001005 if (PyUnicode_Compare(co->co_filename, oldname))
1006 return;
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001007
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001008 tmp = co->co_filename;
1009 co->co_filename = newname;
1010 Py_INCREF(co->co_filename);
1011 Py_DECREF(tmp);
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001012
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001013 constants = co->co_consts;
1014 n = PyTuple_GET_SIZE(constants);
1015 for (i = 0; i < n; i++) {
1016 tmp = PyTuple_GET_ITEM(constants, i);
1017 if (PyCode_Check(tmp))
1018 update_code_filenames((PyCodeObject *)tmp,
1019 oldname, newname);
1020 }
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001021}
1022
Victor Stinner2f42ae52011-03-20 00:41:24 +01001023static void
1024update_compiled_module(PyCodeObject *co, PyObject *newname)
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001025{
Victor Stinner2f42ae52011-03-20 00:41:24 +01001026 PyObject *oldname;
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001027
Victor Stinner2f42ae52011-03-20 00:41:24 +01001028 if (PyUnicode_Compare(co->co_filename, newname) == 0)
1029 return;
Hirokazu Yamamoto4f447fb2009-03-04 01:52:10 +00001030
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001031 oldname = co->co_filename;
1032 Py_INCREF(oldname);
1033 update_code_filenames(co, oldname, newname);
1034 Py_DECREF(oldname);
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001035}
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001036
Brett Cannon442c9b92011-03-23 16:14:42 -07001037static PyObject *
1038imp_fix_co_filename(PyObject *self, PyObject *args)
1039{
1040 PyObject *co;
1041 PyObject *file_path;
1042
1043 if (!PyArg_ParseTuple(args, "OO:_fix_co_filename", &co, &file_path))
1044 return NULL;
1045
1046 if (!PyCode_Check(co)) {
1047 PyErr_SetString(PyExc_TypeError,
1048 "first argument must be a code object");
1049 return NULL;
1050 }
1051
1052 if (!PyUnicode_Check(file_path)) {
1053 PyErr_SetString(PyExc_TypeError,
1054 "second argument must be a string");
1055 return NULL;
1056 }
1057
1058 update_compiled_module((PyCodeObject*)co, file_path);
1059
1060 Py_RETURN_NONE;
1061}
1062
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001063
Christian Heimes3b06e532008-01-07 20:12:44 +00001064/* Get source file -> unicode or None
1065 * Returns the path to the py file if available, else the given path
1066 */
1067static PyObject *
Victor Stinnerc9abda02011-03-14 13:33:46 -04001068get_sourcefile(PyObject *filename)
Christian Heimes3b06e532008-01-07 20:12:44 +00001069{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001070 Py_ssize_t len;
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001071 Py_UCS4 *fileuni;
Victor Stinnerc9abda02011-03-14 13:33:46 -04001072 PyObject *py;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001073 struct stat statbuf;
Victor Stinnerbd0850b2011-12-18 20:47:30 +01001074 int err;
Christian Heimes3b06e532008-01-07 20:12:44 +00001075
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001076 len = PyUnicode_GET_LENGTH(filename);
Victor Stinnerc9abda02011-03-14 13:33:46 -04001077 if (len == 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001078 Py_RETURN_NONE;
Christian Heimes3b06e532008-01-07 20:12:44 +00001079
Victor Stinnerc9abda02011-03-14 13:33:46 -04001080 /* don't match *.pyc or *.pyo? */
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001081 fileuni = PyUnicode_AsUCS4Copy(filename);
1082 if (!fileuni)
1083 return NULL;
Victor Stinnerc9abda02011-03-14 13:33:46 -04001084 if (len < 5
1085 || fileuni[len-4] != '.'
1086 || (fileuni[len-3] != 'p' && fileuni[len-3] != 'P')
1087 || (fileuni[len-2] != 'y' && fileuni[len-2] != 'Y'))
1088 goto unchanged;
Christian Heimes3b06e532008-01-07 20:12:44 +00001089
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001090 /* Start by trying to turn PEP 3147 path into source path. If that
1091 * fails, just chop off the trailing character, i.e. legacy pyc path
1092 * to py.
1093 */
Victor Stinnerc9abda02011-03-14 13:33:46 -04001094 py = make_source_pathname(filename);
1095 if (py == NULL) {
1096 PyErr_Clear();
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001097 py = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, fileuni, len - 1);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001098 }
Victor Stinnerc9abda02011-03-14 13:33:46 -04001099 if (py == NULL)
1100 goto error;
Barry Warsaw28a691b2010-04-17 00:19:56 +00001101
Victor Stinnerbd0850b2011-12-18 20:47:30 +01001102 err = _Py_stat(py, &statbuf);
1103 if (err == -2)
1104 goto error;
1105 if (err == 0 && S_ISREG(statbuf.st_mode)) {
Martin v. Löwis0b1d3482011-10-01 16:35:40 +02001106 PyMem_Free(fileuni);
Victor Stinnerc9abda02011-03-14 13:33:46 -04001107 return py;
Martin v. Löwis0b1d3482011-10-01 16:35:40 +02001108 }
Victor Stinnerc9abda02011-03-14 13:33:46 -04001109 Py_DECREF(py);
1110 goto unchanged;
1111
1112error:
1113 PyErr_Clear();
1114unchanged:
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001115 PyMem_Free(fileuni);
Victor Stinnerc9abda02011-03-14 13:33:46 -04001116 Py_INCREF(filename);
1117 return filename;
Christian Heimes3b06e532008-01-07 20:12:44 +00001118}
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001119
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001120/* Forward */
Victor Stinnerad3c03b2011-03-14 09:21:33 -04001121static struct filedescr *find_module(PyObject *, PyObject *, PyObject *,
Victor Stinner2fd76e42011-03-14 15:19:39 -04001122 PyObject **, FILE **, PyObject **);
Victor Stinner53dc7352011-03-20 01:50:21 +01001123static struct _frozen * find_frozen(PyObject *);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001124
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001125
1126/* Helper to test for built-in module */
1127
1128static int
Victor Stinner95872862011-03-07 18:20:56 +01001129is_builtin(PyObject *name)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001130{
Victor Stinner95872862011-03-07 18:20:56 +01001131 int i, cmp;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001132 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
Victor Stinner95872862011-03-07 18:20:56 +01001133 cmp = PyUnicode_CompareWithASCIIString(name, PyImport_Inittab[i].name);
1134 if (cmp == 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001135 if (PyImport_Inittab[i].initfunc == NULL)
1136 return -1;
1137 else
1138 return 1;
1139 }
1140 }
1141 return 0;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001142}
1143
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001144
Just van Rossum52e14d62002-12-30 22:08:05 +00001145/* Return an importer object for a sys.path/pkg.__path__ item 'p',
1146 possibly by fetching it from the path_importer_cache dict. If it
Thomas Wouters89f507f2006-12-13 04:49:30 +00001147 wasn't yet cached, traverse path_hooks until a hook is found
Just van Rossum52e14d62002-12-30 22:08:05 +00001148 that can handle the path item. Return None if no hook could;
1149 this tells our caller it should fall back to the builtin
1150 import mechanism. Cache the result in path_importer_cache.
1151 Returns a borrowed reference. */
1152
1153static PyObject *
1154get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001155 PyObject *p)
Just van Rossum52e14d62002-12-30 22:08:05 +00001156{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001157 PyObject *importer;
1158 Py_ssize_t j, nhooks;
Just van Rossum52e14d62002-12-30 22:08:05 +00001159
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001160 /* These conditions are the caller's responsibility: */
1161 assert(PyList_Check(path_hooks));
1162 assert(PyDict_Check(path_importer_cache));
Just van Rossum52e14d62002-12-30 22:08:05 +00001163
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001164 nhooks = PyList_Size(path_hooks);
1165 if (nhooks < 0)
1166 return NULL; /* Shouldn't happen */
Just van Rossum52e14d62002-12-30 22:08:05 +00001167
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001168 importer = PyDict_GetItem(path_importer_cache, p);
1169 if (importer != NULL)
1170 return importer;
Just van Rossum52e14d62002-12-30 22:08:05 +00001171
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001172 /* set path_importer_cache[p] to None to avoid recursion */
1173 if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
1174 return NULL;
Just van Rossum52e14d62002-12-30 22:08:05 +00001175
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001176 for (j = 0; j < nhooks; j++) {
1177 PyObject *hook = PyList_GetItem(path_hooks, j);
1178 if (hook == NULL)
1179 return NULL;
1180 importer = PyObject_CallFunctionObjArgs(hook, p, NULL);
1181 if (importer != NULL)
1182 break;
Just van Rossum52e14d62002-12-30 22:08:05 +00001183
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001184 if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
1185 return NULL;
1186 }
1187 PyErr_Clear();
1188 }
1189 if (importer == NULL) {
1190 importer = PyObject_CallFunctionObjArgs(
1191 (PyObject *)&PyNullImporter_Type, p, NULL
1192 );
1193 if (importer == NULL) {
1194 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1195 PyErr_Clear();
1196 return Py_None;
1197 }
1198 }
1199 }
1200 if (importer != NULL) {
1201 int err = PyDict_SetItem(path_importer_cache, p, importer);
1202 Py_DECREF(importer);
1203 if (err != 0)
1204 return NULL;
1205 }
1206 return importer;
Just van Rossum52e14d62002-12-30 22:08:05 +00001207}
1208
Christian Heimes9cd17752007-11-18 19:35:23 +00001209PyAPI_FUNC(PyObject *)
1210PyImport_GetImporter(PyObject *path) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001211 PyObject *importer=NULL, *path_importer_cache=NULL, *path_hooks=NULL;
Christian Heimes9cd17752007-11-18 19:35:23 +00001212
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001213 if ((path_importer_cache = PySys_GetObject("path_importer_cache"))) {
1214 if ((path_hooks = PySys_GetObject("path_hooks"))) {
1215 importer = get_path_importer(path_importer_cache,
1216 path_hooks, path);
1217 }
1218 }
1219 Py_XINCREF(importer); /* get_path_importer returns a borrowed reference */
1220 return importer;
Christian Heimes9cd17752007-11-18 19:35:23 +00001221}
1222
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001223/* Search the path (default sys.path) for a module. Return the
1224 corresponding filedescr struct, and (via return arguments) the
1225 pathname and an open file. Return NULL if the module is not found. */
1226
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001227#ifdef MS_COREDLL
Victor Stinner4d6c1c42011-03-08 23:49:04 +01001228extern FILE *_PyWin_FindRegisteredModule(PyObject *, struct filedescr **,
1229 PyObject **p_path);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001230#endif
1231
Victor Stinner547a2a62011-03-20 03:07:28 +01001232/* Forward */
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001233static int case_ok(PyObject *, Py_ssize_t, PyObject *);
Victor Stinner547a2a62011-03-20 03:07:28 +01001234static int find_init_module(PyObject *);
Just van Rossum52e14d62002-12-30 22:08:05 +00001235static struct filedescr importhookdescr = {"", "", IMP_HOOK};
Guido van Rossum197346f1997-10-31 18:38:52 +00001236
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001237/* Get the path of a module: get its importer and call importer.find_module()
1238 hook, or check if the module if a package (if path/__init__.py exists).
1239
1240 -1: error: a Python error occurred
1241 0: ignore: an error occurred because of invalid data, but the error is not
1242 important enough to be reported.
1243 1: get path: module not found, but *buf contains its path
1244 2: found: *p_fd is the file descriptor (IMP_HOOK or PKG_DIRECTORY)
1245 and *buf is the path */
1246
1247static int
Victor Stinnerad3c03b2011-03-14 09:21:33 -04001248find_module_path(PyObject *fullname, PyObject *name, PyObject *path,
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001249 PyObject *path_hooks, PyObject *path_importer_cache,
Victor Stinner2fd76e42011-03-14 15:19:39 -04001250 PyObject **p_path, PyObject **p_loader, struct filedescr **p_fd)
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001251{
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001252 PyObject *path_unicode, *filename = NULL;
1253 Py_ssize_t len, pos;
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001254 struct stat statbuf;
1255 static struct filedescr fd_package = {"", "", PKG_DIRECTORY};
Victor Stinnerbd0850b2011-12-18 20:47:30 +01001256 int err, result, addsep;
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001257
1258 if (PyUnicode_Check(path)) {
Victor Stinner2fd76e42011-03-14 15:19:39 -04001259 Py_INCREF(path);
1260 path_unicode = path;
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001261 }
1262 else if (PyBytes_Check(path)) {
Victor Stinner2fd76e42011-03-14 15:19:39 -04001263 path_unicode = PyUnicode_DecodeFSDefaultAndSize(
1264 PyBytes_AS_STRING(path), PyBytes_GET_SIZE(path));
1265 if (path_unicode == NULL)
1266 return -1;
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001267 }
1268 else
1269 return 0;
1270
Victor Stinner46084ba2011-10-06 02:39:42 +02001271 if (PyUnicode_READY(path_unicode))
1272 return -1;
1273
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001274 len = PyUnicode_GET_LENGTH(path_unicode);
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001275 if (PyUnicode_FindChar(path_unicode, 0, 0, len, 1) != -1) {
1276 result = 0;
1277 goto out; /* path contains '\0' */
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001278 }
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001279
1280 /* sys.path_hooks import hook */
1281 if (p_loader != NULL) {
Martin v. Löwisbd928fe2011-10-14 10:20:37 +02001282 _Py_IDENTIFIER(find_module);
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001283 PyObject *importer;
1284
1285 importer = get_path_importer(path_importer_cache,
1286 path_hooks, path);
1287 if (importer == NULL) {
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001288 result = -1;
1289 goto out;
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001290 }
1291 /* Note: importer is a borrowed reference */
1292 if (importer != Py_None) {
1293 PyObject *loader;
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02001294 loader = _PyObject_CallMethodId(importer,
1295 &PyId_find_module, "O", fullname);
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001296 if (loader == NULL) {
1297 result = -1; /* error */
1298 goto out;
1299 }
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001300 if (loader != Py_None) {
1301 /* a loader was found */
1302 *p_loader = loader;
1303 *p_fd = &importhookdescr;
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001304 result = 2;
1305 goto out;
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001306 }
1307 Py_DECREF(loader);
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001308 result = 0;
1309 goto out;
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001310 }
1311 }
1312 /* no hook was found, use builtin import */
1313
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001314 addsep = 0;
1315 if (len > 0 && PyUnicode_READ_CHAR(path_unicode, len-1) != SEP
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001316#ifdef ALTSEP
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001317 && PyUnicode_READ_CHAR(path_unicode, len-1) != ALTSEP
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001318#endif
1319 )
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001320 addsep = 1;
1321 filename = PyUnicode_New(len + PyUnicode_GET_LENGTH(name) + addsep,
1322 Py_MAX(PyUnicode_MAX_CHAR_VALUE(path_unicode),
1323 PyUnicode_MAX_CHAR_VALUE(name)));
1324 if (filename == NULL) {
1325 result = -1;
1326 goto out;
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001327 }
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001328 PyUnicode_CopyCharacters(filename, 0, path_unicode, 0, len);
1329 pos = len;
1330 if (addsep)
Victor Stinner1f795172011-11-17 00:45:54 +01001331 PyUnicode_WRITE(PyUnicode_KIND(filename),
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001332 PyUnicode_DATA(filename),
1333 pos++, SEP);
Victor Stinner1f795172011-11-17 00:45:54 +01001334 PyUnicode_CopyCharacters(filename, pos, name, 0,
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001335 PyUnicode_GET_LENGTH(name));
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001336
1337 /* Check for package import (buf holds a directory name,
1338 and there's an __init__ module in that directory */
1339#ifdef HAVE_STAT
Victor Stinnerbd0850b2011-12-18 20:47:30 +01001340 err = _Py_stat(filename, &statbuf);
1341 if (err == -2) {
1342 result = -1;
1343 goto out;
1344 }
1345 if (err == 0 && /* it exists */
Victor Stinnerd0296212011-03-14 14:04:10 -04001346 S_ISDIR(statbuf.st_mode)) /* it's a directory */
1347 {
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001348 int match;
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001349
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001350 match = case_ok(filename, 0, name);
1351 if (match < 0) {
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001352 result = -1;
1353 goto out;
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001354 }
1355 if (match) { /* case matches */
1356 if (find_init_module(filename)) { /* and has __init__.py */
Victor Stinner2fd76e42011-03-14 15:19:39 -04001357 *p_path = filename;
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001358 filename = NULL;
Victor Stinnerd0296212011-03-14 14:04:10 -04001359 *p_fd = &fd_package;
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001360 result = 2;
1361 goto out;
Victor Stinnerd0296212011-03-14 14:04:10 -04001362 }
1363 else {
1364 int err;
Victor Stinnerd0296212011-03-14 14:04:10 -04001365 err = PyErr_WarnFormat(PyExc_ImportWarning, 1,
Victor Stinner547a2a62011-03-20 03:07:28 +01001366 "Not importing directory %R: missing __init__.py",
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001367 filename);
Victor Stinner547a2a62011-03-20 03:07:28 +01001368 if (err) {
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001369 result = -1;
1370 goto out;
Victor Stinner547a2a62011-03-20 03:07:28 +01001371 }
Victor Stinnerd0296212011-03-14 14:04:10 -04001372 }
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001373 }
1374 }
1375#endif
Victor Stinner2fd76e42011-03-14 15:19:39 -04001376 *p_path = filename;
Martin v. Löwis9af29d32011-10-23 18:45:16 +02001377 filename = NULL;
1378 result = 1;
1379 out:
1380 Py_DECREF(path_unicode);
1381 Py_XDECREF(filename);
1382 return result;
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001383}
1384
1385/* Find a module in search_path_list. For each path, try
Victor Stinnerad3c03b2011-03-14 09:21:33 -04001386 find_module_path() or try each _PyImport_Filetab suffix.
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001387
1388 If the module is found, return a file descriptor, write the path in
1389 *p_filename, write the pointer to the file object into *p_fp, and (if
1390 p_loader is not NULL) the loader into *p_loader.
1391
1392 Otherwise, raise an exception and return NULL. */
1393
Victor Stinner37580282011-03-20 01:34:43 +01001394static struct filedescr*
Victor Stinnerad3c03b2011-03-14 09:21:33 -04001395find_module_path_list(PyObject *fullname, PyObject *name,
Victor Stinner37580282011-03-20 01:34:43 +01001396 PyObject *search_path_list, PyObject *path_hooks,
1397 PyObject *path_importer_cache,
Victor Stinner2fd76e42011-03-14 15:19:39 -04001398 PyObject **p_path, FILE **p_fp, PyObject **p_loader)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001399{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001400 Py_ssize_t i, npath;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001401 struct filedescr *fdp = NULL;
1402 char *filemode;
1403 FILE *fp = NULL;
Victor Stinner2fd76e42011-03-14 15:19:39 -04001404 PyObject *prefix, *filename;
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001405 int match;
Victor Stinnerbd0850b2011-12-18 20:47:30 +01001406 int err;
Victor Stinner53dc7352011-03-20 01:50:21 +01001407
Victor Stinner37580282011-03-20 01:34:43 +01001408 npath = PyList_Size(search_path_list);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001409 for (i = 0; i < npath; i++) {
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001410 PyObject *path;
1411 int ok;
1412
1413 path = PyList_GetItem(search_path_list, i);
1414 if (path == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001415 return NULL;
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001416
Victor Stinner2fd76e42011-03-14 15:19:39 -04001417 prefix = NULL;
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001418 ok = find_module_path(fullname, name, path,
1419 path_hooks, path_importer_cache,
Victor Stinner2fd76e42011-03-14 15:19:39 -04001420 &prefix, p_loader, &fdp);
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001421 if (ok < 0)
1422 return NULL;
1423 if (ok == 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001424 continue;
Victor Stinner2fd76e42011-03-14 15:19:39 -04001425 if (ok == 2) {
1426 *p_path = prefix;
Victor Stinnerd68c2cf2011-03-12 16:02:28 -05001427 return fdp;
Victor Stinner2fd76e42011-03-14 15:19:39 -04001428 }
Amaury Forgeot d'Arcf1ca0b12008-06-11 17:40:47 +00001429
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001430 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
Victor Stinnera1fe1f82011-09-23 18:59:08 +02001431 struct stat statbuf;
1432
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001433 filemode = fdp->mode;
1434 if (filemode[0] == 'U')
1435 filemode = "r" PY_STDIOTEXTMODE;
Victor Stinnerd0296212011-03-14 14:04:10 -04001436
Victor Stinner2fd76e42011-03-14 15:19:39 -04001437 filename = PyUnicode_FromFormat("%U%s", prefix, fdp->suffix);
1438 if (filename == NULL) {
1439 Py_DECREF(prefix);
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001440 return NULL;
Victor Stinner2fd76e42011-03-14 15:19:39 -04001441 }
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001442
1443 if (Py_VerboseFlag > 1)
1444 PySys_FormatStderr("# trying %R\n", filename);
1445
Victor Stinnerbd0850b2011-12-18 20:47:30 +01001446 err = _Py_stat(filename, &statbuf);
1447 if (err == -2) {
1448 Py_DECREF(prefix);
1449 Py_DECREF(filename);
1450 return NULL;
1451 }
1452 if (err != 0 || S_ISDIR(statbuf.st_mode)) {
Charles-François Natali1659b832011-12-07 23:17:58 +01001453 /* it doesn't exist, or it's a directory */
Victor Stinnera1fe1f82011-09-23 18:59:08 +02001454 Py_DECREF(filename);
1455 continue;
1456 }
1457
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001458 fp = _Py_fopen(filename, filemode);
1459 if (fp == NULL) {
1460 Py_DECREF(filename);
Victor Stinner925ef392011-06-20 15:01:10 +02001461 if (PyErr_Occurred()) {
1462 Py_DECREF(prefix);
1463 return NULL;
1464 }
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001465 continue;
1466 }
1467 match = case_ok(filename, -(Py_ssize_t)strlen(fdp->suffix), name);
1468 if (match < 0) {
Victor Stinner2fd76e42011-03-14 15:19:39 -04001469 Py_DECREF(prefix);
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001470 Py_DECREF(filename);
1471 return NULL;
1472 }
1473 if (match) {
Victor Stinner2fd76e42011-03-14 15:19:39 -04001474 Py_DECREF(prefix);
1475 *p_path = filename;
Victor Stinnerd0296212011-03-14 14:04:10 -04001476 *p_fp = fp;
1477 return fdp;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001478 }
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001479 Py_DECREF(filename);
Victor Stinnerd0296212011-03-14 14:04:10 -04001480
1481 fclose(fp);
1482 fp = NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001483 }
Victor Stinner2fd76e42011-03-14 15:19:39 -04001484 Py_DECREF(prefix);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001485 }
Victor Stinnerd0296212011-03-14 14:04:10 -04001486 PyErr_Format(PyExc_ImportError,
Victor Stinner98dbba52011-03-14 15:15:47 -04001487 "No module named %R", name);
Victor Stinnerd0296212011-03-14 14:04:10 -04001488 return NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001489}
1490
Victor Stinner37580282011-03-20 01:34:43 +01001491/* Find a module:
1492
1493 - try find_module() of each sys.meta_path hook
1494 - try find_frozen()
1495 - try is_builtin()
1496 - try _PyWin_FindRegisteredModule() (Windows only)
1497 - otherwise, call find_module_path_list() with search_path_list (if not
1498 NULL) or sys.path
1499
Victor Stinner2fd76e42011-03-14 15:19:39 -04001500 fullname can be NULL, but only if p_loader is NULL.
1501
Victor Stinner37580282011-03-20 01:34:43 +01001502 Return:
1503
1504 - &fd_builtin (C_BUILTIN) if it is a builtin
1505 - &fd_frozen (PY_FROZEN) if it is frozen
Victor Stinner2fd76e42011-03-14 15:19:39 -04001506 - &fd_package (PKG_DIRECTORY) and write the filename into *p_path
Victor Stinner37580282011-03-20 01:34:43 +01001507 if it is a package
1508 - &importhookdescr (IMP_HOOK) and write the loader into *p_loader if a
1509 importer loader was found
1510 - a file descriptor (PY_SOURCE, PY_COMPILED, C_EXTENSION, PY_RESOURCE or
1511 PY_CODERESOURCE: see _PyImport_Filetab), write the filename into
Victor Stinner2fd76e42011-03-14 15:19:39 -04001512 *p_path and the pointer to the open file into *p_fp
Victor Stinner37580282011-03-20 01:34:43 +01001513 - NULL on error
1514
Victor Stinner2fd76e42011-03-14 15:19:39 -04001515 By default, *p_path, *p_fp and *p_loader (if set) are set to NULL.
1516 Eg. *p_path is set to NULL for a builtin package.
1517*/
Victor Stinner37580282011-03-20 01:34:43 +01001518
1519static struct filedescr *
Victor Stinnerad3c03b2011-03-14 09:21:33 -04001520find_module(PyObject *fullname, PyObject *name, PyObject *search_path_list,
Victor Stinner2fd76e42011-03-14 15:19:39 -04001521 PyObject **p_path, FILE **p_fp, PyObject **p_loader)
Victor Stinner37580282011-03-20 01:34:43 +01001522{
1523 Py_ssize_t i, npath;
1524 static struct filedescr fd_frozen = {"", "", PY_FROZEN};
1525 static struct filedescr fd_builtin = {"", "", C_BUILTIN};
1526 PyObject *path_hooks, *path_importer_cache;
Victor Stinner37580282011-03-20 01:34:43 +01001527
Victor Stinner2fd76e42011-03-14 15:19:39 -04001528 *p_path = NULL;
Victor Stinner37580282011-03-20 01:34:43 +01001529 *p_fp = NULL;
1530 if (p_loader != NULL)
1531 *p_loader = NULL;
1532
Victor Stinner37580282011-03-20 01:34:43 +01001533 /* sys.meta_path import hook */
1534 if (p_loader != NULL) {
Martin v. Löwisbd928fe2011-10-14 10:20:37 +02001535 _Py_IDENTIFIER(find_module);
Victor Stinner37580282011-03-20 01:34:43 +01001536 PyObject *meta_path;
1537
1538 meta_path = PySys_GetObject("meta_path");
1539 if (meta_path == NULL || !PyList_Check(meta_path)) {
Victor Stinner16191322011-09-15 19:28:05 +02001540 PyErr_SetString(PyExc_RuntimeError,
Victor Stinner37580282011-03-20 01:34:43 +01001541 "sys.meta_path must be a list of "
1542 "import hooks");
1543 return NULL;
1544 }
1545 Py_INCREF(meta_path); /* zap guard */
1546 npath = PyList_Size(meta_path);
1547 for (i = 0; i < npath; i++) {
1548 PyObject *loader;
1549 PyObject *hook = PyList_GetItem(meta_path, i);
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02001550 loader = _PyObject_CallMethodId(hook, &PyId_find_module,
Victor Stinnerad3c03b2011-03-14 09:21:33 -04001551 "OO", fullname,
Victor Stinner37580282011-03-20 01:34:43 +01001552 search_path_list != NULL ?
1553 search_path_list : Py_None);
1554 if (loader == NULL) {
1555 Py_DECREF(meta_path);
1556 return NULL; /* true error */
1557 }
1558 if (loader != Py_None) {
1559 /* a loader was found */
1560 *p_loader = loader;
1561 Py_DECREF(meta_path);
1562 return &importhookdescr;
1563 }
1564 Py_DECREF(loader);
1565 }
1566 Py_DECREF(meta_path);
1567 }
1568
Victor Stinnerdf75a022011-03-14 13:40:04 -04001569 if (find_frozen(fullname) != NULL)
Victor Stinnerad3c03b2011-03-14 09:21:33 -04001570 return &fd_frozen;
Victor Stinner37580282011-03-20 01:34:43 +01001571
1572 if (search_path_list == NULL) {
1573#ifdef MS_COREDLL
1574 FILE *fp;
1575 struct filedescr *fdp;
Victor Stinner37580282011-03-20 01:34:43 +01001576#endif
Victor Stinnerdf75a022011-03-14 13:40:04 -04001577 if (is_builtin(name))
Victor Stinner37580282011-03-20 01:34:43 +01001578 return &fd_builtin;
Victor Stinner37580282011-03-20 01:34:43 +01001579#ifdef MS_COREDLL
Victor Stinner2fd76e42011-03-14 15:19:39 -04001580 fp = _PyWin_FindRegisteredModule(name, &fdp, p_path);
Victor Stinner37580282011-03-20 01:34:43 +01001581 if (fp != NULL) {
Victor Stinner37580282011-03-20 01:34:43 +01001582 *p_fp = fp;
1583 return fdp;
1584 }
1585 else if (PyErr_Occurred())
1586 return NULL;
1587#endif
Victor Stinner37580282011-03-20 01:34:43 +01001588 search_path_list = PySys_GetObject("path");
1589 }
1590
1591 if (search_path_list == NULL || !PyList_Check(search_path_list)) {
Victor Stinner16191322011-09-15 19:28:05 +02001592 PyErr_SetString(PyExc_RuntimeError,
Victor Stinner37580282011-03-20 01:34:43 +01001593 "sys.path must be a list of directory names");
1594 return NULL;
1595 }
1596
1597 path_hooks = PySys_GetObject("path_hooks");
1598 if (path_hooks == NULL || !PyList_Check(path_hooks)) {
Victor Stinner16191322011-09-15 19:28:05 +02001599 PyErr_SetString(PyExc_RuntimeError,
Victor Stinner37580282011-03-20 01:34:43 +01001600 "sys.path_hooks must be a list of "
1601 "import hooks");
1602 return NULL;
1603 }
1604 path_importer_cache = PySys_GetObject("path_importer_cache");
1605 if (path_importer_cache == NULL ||
1606 !PyDict_Check(path_importer_cache)) {
Victor Stinner16191322011-09-15 19:28:05 +02001607 PyErr_SetString(PyExc_RuntimeError,
Victor Stinner37580282011-03-20 01:34:43 +01001608 "sys.path_importer_cache must be a dict");
1609 return NULL;
1610 }
1611
1612 return find_module_path_list(fullname, name,
1613 search_path_list, path_hooks,
1614 path_importer_cache,
Victor Stinner2fd76e42011-03-14 15:19:39 -04001615 p_path, p_fp, p_loader);
Victor Stinner37580282011-03-20 01:34:43 +01001616}
1617
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001618/* case_bytes(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
Tim Petersd1e87a82001-03-01 18:12:00 +00001619 * The arguments here are tricky, best shown by example:
1620 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1621 * ^ ^ ^ ^
1622 * |--------------------- buf ---------------------|
1623 * |------------------- len ------------------|
1624 * |------ name -------|
1625 * |----- namelen -----|
1626 * buf is the full path, but len only counts up to (& exclusive of) the
1627 * extension. name is the module name, also exclusive of extension.
1628 *
1629 * We've already done a successful stat() or fopen() on buf, so know that
1630 * there's some match, possibly case-insensitive.
1631 *
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001632 * case_bytes() is to return 1 if there's a case-sensitive match for
1633 * name, else 0. case_bytes() is also to return 1 if envar PYTHONCASEOK
Tim Peters50d8d372001-02-28 05:34:27 +00001634 * exists.
Tim Petersd1e87a82001-03-01 18:12:00 +00001635 *
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001636 * case_bytes() is used to implement case-sensitive import semantics even
Tim Peters50d8d372001-02-28 05:34:27 +00001637 * on platforms with case-insensitive filesystems. It's trivial to implement
1638 * for case-sensitive filesystems. It's pretty much a cross-platform
1639 * nightmare for systems with case-insensitive filesystems.
1640 */
Guido van Rossum0980bd91998-02-13 17:18:36 +00001641
Tim Peters50d8d372001-02-28 05:34:27 +00001642/* First we may need a pile of platform-specific header files; the sequence
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001643 * of #if's here should match the sequence in the body of case_bytes().
Tim Peters50d8d372001-02-28 05:34:27 +00001644 */
Jason Tishler7961aa62005-05-20 00:56:54 +00001645#if defined(MS_WINDOWS)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001646#include <windows.h>
Guido van Rossum4c3f57c2001-01-10 20:40:46 +00001647
Tim Peters50d8d372001-02-28 05:34:27 +00001648#elif defined(DJGPP)
1649#include <dir.h>
1650
Jason Tishler7961aa62005-05-20 00:56:54 +00001651#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
Tim Peters430f5d42001-03-01 01:30:56 +00001652#include <sys/types.h>
1653#include <dirent.h>
1654
Andrew MacIntyred9400542002-02-26 11:41:34 +00001655#elif defined(PYOS_OS2)
1656#define INCL_DOS
1657#define INCL_DOSERRORS
1658#define INCL_NOPMAPI
1659#include <os2.h>
Tim Peters50d8d372001-02-28 05:34:27 +00001660#endif
1661
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001662#if defined(DJGPP) \
1663 || ((defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) \
1664 && defined(HAVE_DIRENT_H)) \
1665 || defined(PYOS_OS2)
1666# define USE_CASE_OK_BYTES
1667#endif
1668
1669
1670#ifdef USE_CASE_OK_BYTES
Guido van Rossum0980bd91998-02-13 17:18:36 +00001671static int
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001672case_bytes(char *buf, Py_ssize_t len, Py_ssize_t namelen, const char *name)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001673{
Tim Peters50d8d372001-02-28 05:34:27 +00001674/* Pick a platform-specific implementation; the sequence of #if's here should
1675 * match the sequence just above.
1676 */
1677
Tim Peters50d8d372001-02-28 05:34:27 +00001678/* DJGPP */
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001679#if defined(DJGPP)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001680 struct ffblk ffblk;
1681 int done;
Tim Peters50d8d372001-02-28 05:34:27 +00001682
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001683 if (Py_GETENV("PYTHONCASEOK") != NULL)
1684 return 1;
Tim Peters50d8d372001-02-28 05:34:27 +00001685
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001686 done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);
1687 if (done) {
1688 PyErr_Format(PyExc_NameError,
1689 "Can't find file for module %.100s\n(filename %.300s)",
1690 name, buf);
Victor Stinner9c61e242011-03-22 01:22:27 +01001691 return -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001692 }
1693 return strncmp(ffblk.ff_name, name, namelen) == 0;
Guido van Rossum0980bd91998-02-13 17:18:36 +00001694
Jason Tishler7961aa62005-05-20 00:56:54 +00001695/* new-fangled macintosh (macosx) or Cygwin */
1696#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001697 DIR *dirp;
1698 struct dirent *dp;
1699 char dirname[MAXPATHLEN + 1];
1700 const int dirlen = len - namelen - 1; /* don't want trailing SEP */
Tim Peters430f5d42001-03-01 01:30:56 +00001701
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001702 if (Py_GETENV("PYTHONCASEOK") != NULL)
1703 return 1;
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001704
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001705 /* Copy the dir component into dirname; substitute "." if empty */
1706 if (dirlen <= 0) {
1707 dirname[0] = '.';
1708 dirname[1] = '\0';
1709 }
1710 else {
1711 assert(dirlen <= MAXPATHLEN);
1712 memcpy(dirname, buf, dirlen);
1713 dirname[dirlen] = '\0';
1714 }
1715 /* Open the directory and search the entries for an exact match. */
1716 dirp = opendir(dirname);
1717 if (dirp) {
1718 char *nameWithExt = buf + len - namelen;
1719 while ((dp = readdir(dirp)) != NULL) {
1720 const int thislen =
Tim Peters430f5d42001-03-01 01:30:56 +00001721#ifdef _DIRENT_HAVE_D_NAMELEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001722 dp->d_namlen;
Tim Peters430f5d42001-03-01 01:30:56 +00001723#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001724 strlen(dp->d_name);
Tim Peters430f5d42001-03-01 01:30:56 +00001725#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001726 if (thislen >= namelen &&
1727 strcmp(dp->d_name, nameWithExt) == 0) {
1728 (void)closedir(dirp);
1729 return 1; /* Found */
1730 }
1731 }
1732 (void)closedir(dirp);
1733 }
1734 return 0 ; /* Not found */
Tim Peters430f5d42001-03-01 01:30:56 +00001735
Andrew MacIntyred9400542002-02-26 11:41:34 +00001736/* OS/2 */
1737#elif defined(PYOS_OS2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001738 HDIR hdir = 1;
1739 ULONG srchcnt = 1;
1740 FILEFINDBUF3 ffbuf;
1741 APIRET rc;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001742
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001743 if (Py_GETENV("PYTHONCASEOK") != NULL)
1744 return 1;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001745
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001746 rc = DosFindFirst(buf,
1747 &hdir,
1748 FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,
1749 &ffbuf, sizeof(ffbuf),
1750 &srchcnt,
1751 FIL_STANDARD);
1752 if (rc != NO_ERROR)
1753 return 0;
1754 return strncmp(ffbuf.achName, name, namelen) == 0;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001755
Tim Peters50d8d372001-02-28 05:34:27 +00001756/* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1757#else
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001758# error "USE_CASE_OK_BYTES is not correctly defined"
1759#endif
1760}
1761#endif
1762
1763/*
1764 * Check if a filename case matchs the name case. We've already done a
1765 * successful stat() or fopen() on buf, so know that there's some match,
1766 * possibly case-insensitive.
1767 *
1768 * case_ok() is to return 1 if there's a case-sensitive match for name, 0 if it
1769 * the filename doesn't match, or -1 on error. case_ok() is also to return 1
1770 * if envar PYTHONCASEOK exists.
1771 *
1772 * case_ok() is used to implement case-sensitive import semantics even
1773 * on platforms with case-insensitive filesystems. It's trivial to implement
1774 * for case-sensitive filesystems. It's pretty much a cross-platform
1775 * nightmare for systems with case-insensitive filesystems.
1776 */
1777
1778static int
1779case_ok(PyObject *filename, Py_ssize_t prefix_delta, PyObject *name)
1780{
1781#ifdef MS_WINDOWS
1782 WIN32_FIND_DATAW data;
1783 HANDLE h;
1784 int cmp;
Victor Stinner1f795172011-11-17 00:45:54 +01001785 wchar_t *wfilename, *wname;
Victor Stinner8c981892011-10-11 22:27:13 +02001786 Py_ssize_t wname_len;
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001787
1788 if (Py_GETENV("PYTHONCASEOK") != NULL)
1789 return 1;
1790
Victor Stinner1f795172011-11-17 00:45:54 +01001791 wfilename = PyUnicode_AsUnicode(filename);
1792 if (wfilename == NULL)
1793 return -1;
1794
1795 h = FindFirstFileW(wfilename, &data);
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001796 if (h == INVALID_HANDLE_VALUE) {
1797 PyErr_Format(PyExc_NameError,
1798 "Can't find file for module %R\n(filename %R)",
1799 name, filename);
Victor Stinner1f795172011-11-17 00:45:54 +01001800 return -1;
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001801 }
1802 FindClose(h);
Victor Stinnerbeac78b2011-10-11 21:55:01 +02001803
1804 wname = PyUnicode_AsUnicodeAndSize(name, &wname_len);
1805 if (wname == NULL)
1806 return -1;
1807
1808 cmp = wcsncmp(data.cFileName, wname, wname_len);
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001809 return cmp == 0;
1810#elif defined(USE_CASE_OK_BYTES)
1811 int match;
1812 PyObject *filebytes, *namebytes;
1813 filebytes = PyUnicode_EncodeFSDefault(filename);
1814 if (filebytes == NULL)
1815 return -1;
1816 namebytes = PyUnicode_EncodeFSDefault(name);
1817 if (namebytes == NULL) {
1818 Py_DECREF(filebytes);
1819 return -1;
1820 }
1821 match = case_bytes(
1822 PyBytes_AS_STRING(filebytes),
1823 PyBytes_GET_SIZE(filebytes) + prefix_delta,
Victor Stinner1304f2d2011-03-20 04:28:55 +01001824 PyBytes_GET_SIZE(namebytes),
1825 PyBytes_AS_STRING(namebytes));
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001826 Py_DECREF(filebytes);
1827 Py_DECREF(namebytes);
1828 return match;
1829#else
1830 /* assuming it's a case-sensitive filesystem, so there's nothing to do! */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001831 return 1;
Guido van Rossum0980bd91998-02-13 17:18:36 +00001832
Guido van Rossum4d1b3b91998-02-13 23:27:59 +00001833#endif
Tim Peters50d8d372001-02-28 05:34:27 +00001834}
Guido van Rossum4d1b3b91998-02-13 23:27:59 +00001835
Guido van Rossum197346f1997-10-31 18:38:52 +00001836#ifdef HAVE_STAT
Victor Stinner4f4402c2010-08-14 14:50:26 +00001837
Victor Stinner547a2a62011-03-20 03:07:28 +01001838/* Helper to look for __init__.py or __init__.py[co] in potential package.
1839 Return 1 if __init__ was found, 0 if not, or -1 on error. */
Guido van Rossum197346f1997-10-31 18:38:52 +00001840static int
Victor Stinner547a2a62011-03-20 03:07:28 +01001841find_init_module(PyObject *directory)
Guido van Rossum197346f1997-10-31 18:38:52 +00001842{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001843 struct stat statbuf;
Victor Stinner547a2a62011-03-20 03:07:28 +01001844 PyObject *filename;
1845 int match;
Victor Stinnerbd0850b2011-12-18 20:47:30 +01001846 int err;
Guido van Rossum197346f1997-10-31 18:38:52 +00001847
Victor Stinner547a2a62011-03-20 03:07:28 +01001848 filename = PyUnicode_FromFormat("%U%c__init__.py", directory, SEP);
1849 if (filename == NULL)
1850 return -1;
Victor Stinnerbd0850b2011-12-18 20:47:30 +01001851 err = _Py_stat(filename, &statbuf);
1852 if (err == -2)
1853 return -1;
1854 if (err == 0) {
Victor Stinnercc9564e2011-03-20 04:58:29 +01001855 /* 3=len(".py") */
1856 match = case_ok(filename, -3, initstr);
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001857 if (match < 0) {
1858 Py_DECREF(filename);
1859 return -1;
1860 }
1861 if (match) {
Victor Stinner547a2a62011-03-20 03:07:28 +01001862 Py_DECREF(filename);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001863 return 1;
1864 }
1865 }
Victor Stinner547a2a62011-03-20 03:07:28 +01001866 Py_DECREF(filename);
1867
1868 filename = PyUnicode_FromFormat("%U%c__init__.py%c",
1869 directory, SEP, Py_OptimizeFlag ? 'o' : 'c');
1870 if (filename == NULL)
1871 return -1;
Victor Stinnerbd0850b2011-12-18 20:47:30 +01001872 err = _Py_stat(filename, &statbuf);
1873 if (err == -2) {
1874 Py_DECREF(filename);
1875 return -1;
1876 }
1877 if (err == 0) {
Victor Stinnercc9564e2011-03-20 04:58:29 +01001878 /* 4=len(".pyc") */
1879 match = case_ok(filename, -4, initstr);
Victor Stinnerc9a271c2011-03-14 14:34:13 -04001880 if (match < 0) {
1881 Py_DECREF(filename);
1882 return -1;
1883 }
1884 if (match) {
Victor Stinner547a2a62011-03-20 03:07:28 +01001885 Py_DECREF(filename);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001886 return 1;
1887 }
1888 }
Victor Stinner547a2a62011-03-20 03:07:28 +01001889 Py_DECREF(filename);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001890 return 0;
Guido van Rossum197346f1997-10-31 18:38:52 +00001891}
Guido van Rossum48a680c2001-03-02 06:34:14 +00001892
Guido van Rossum197346f1997-10-31 18:38:52 +00001893#endif /* HAVE_STAT */
1894
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001895
Victor Stinner95872862011-03-07 18:20:56 +01001896static int init_builtin(PyObject *); /* Forward */
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001897
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001898/* Initialize a built-in module.
Thomas Wouters89f507f2006-12-13 04:49:30 +00001899 Return 1 for success, 0 if the module is not found, and -1 with
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001900 an exception set if the initialization failed. */
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001901
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001902static int
Victor Stinner95872862011-03-07 18:20:56 +01001903init_builtin(PyObject *name)
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001904{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001905 struct _inittab *p;
Guido van Rossum25ce5661997-08-02 03:10:38 +00001906
Victor Stinner95872862011-03-07 18:20:56 +01001907 if (_PyImport_FindExtensionObject(name, name) != NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001908 return 1;
Guido van Rossum25ce5661997-08-02 03:10:38 +00001909
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001910 for (p = PyImport_Inittab; p->name != NULL; p++) {
1911 PyObject *mod;
Antoine Pitrou6c40eb72012-01-18 20:16:09 +01001912 PyModuleDef *def;
Victor Stinner95872862011-03-07 18:20:56 +01001913 if (PyUnicode_CompareWithASCIIString(name, p->name) == 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001914 if (p->initfunc == NULL) {
1915 PyErr_Format(PyExc_ImportError,
Victor Stinner95872862011-03-07 18:20:56 +01001916 "Cannot re-init internal module %R",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001917 name);
1918 return -1;
1919 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001920 mod = (*p->initfunc)();
1921 if (mod == 0)
1922 return -1;
Antoine Pitrou6c40eb72012-01-18 20:16:09 +01001923 /* Remember pointer to module init function. */
1924 def = PyModule_GetDef(mod);
1925 def->m_base.m_init = p->initfunc;
Victor Stinner95872862011-03-07 18:20:56 +01001926 if (_PyImport_FixupExtensionObject(mod, name, name) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001927 return -1;
1928 /* FixupExtension has put the module into sys.modules,
1929 so we can release our own reference. */
1930 Py_DECREF(mod);
1931 return 1;
1932 }
1933 }
1934 return 0;
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001935}
Guido van Rossumf56e3db1993-04-01 20:59:32 +00001936
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001937
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001938/* Frozen modules */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001939
Guido van Rossumcfd0a221996-06-17 17:06:34 +00001940static struct _frozen *
Victor Stinner53dc7352011-03-20 01:50:21 +01001941find_frozen(PyObject *name)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001942{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001943 struct _frozen *p;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001944
Victor Stinner53dc7352011-03-20 01:50:21 +01001945 if (name == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001946 return NULL;
Benjamin Petersond968e272008-11-05 22:48:33 +00001947
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001948 for (p = PyImport_FrozenModules; ; p++) {
1949 if (p->name == NULL)
1950 return NULL;
Victor Stinner53dc7352011-03-20 01:50:21 +01001951 if (PyUnicode_CompareWithASCIIString(name, p->name) == 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001952 break;
1953 }
1954 return p;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001955}
1956
Guido van Rossum79f25d91997-04-29 20:08:16 +00001957static PyObject *
Victor Stinner53dc7352011-03-20 01:50:21 +01001958get_frozen_object(PyObject *name)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001959{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001960 struct _frozen *p = find_frozen(name);
1961 int size;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001962
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001963 if (p == NULL) {
1964 PyErr_Format(PyExc_ImportError,
Victor Stinner53dc7352011-03-20 01:50:21 +01001965 "No such frozen object named %R",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001966 name);
1967 return NULL;
1968 }
1969 if (p->code == NULL) {
1970 PyErr_Format(PyExc_ImportError,
Victor Stinner53dc7352011-03-20 01:50:21 +01001971 "Excluded frozen object named %R",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001972 name);
1973 return NULL;
1974 }
1975 size = p->size;
1976 if (size < 0)
1977 size = -size;
1978 return PyMarshal_ReadObjectFromString((char *)p->code, size);
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001979}
1980
Brett Cannon8d110132009-03-15 02:20:16 +00001981static PyObject *
Victor Stinner53dc7352011-03-20 01:50:21 +01001982is_frozen_package(PyObject *name)
Brett Cannon8d110132009-03-15 02:20:16 +00001983{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001984 struct _frozen *p = find_frozen(name);
1985 int size;
Brett Cannon8d110132009-03-15 02:20:16 +00001986
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001987 if (p == NULL) {
1988 PyErr_Format(PyExc_ImportError,
Victor Stinner53dc7352011-03-20 01:50:21 +01001989 "No such frozen object named %R",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001990 name);
1991 return NULL;
1992 }
Brett Cannon8d110132009-03-15 02:20:16 +00001993
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001994 size = p->size;
Brett Cannon8d110132009-03-15 02:20:16 +00001995
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001996 if (size < 0)
1997 Py_RETURN_TRUE;
1998 else
1999 Py_RETURN_FALSE;
Brett Cannon8d110132009-03-15 02:20:16 +00002000}
2001
2002
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002003/* Initialize a frozen module.
Brett Cannon3c2ac442009-03-08 20:49:47 +00002004 Return 1 for success, 0 if the module is not found, and -1 with
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002005 an exception set if the initialization failed.
2006 This function is also used from frozenmain.c */
Guido van Rossum0b344901995-02-07 15:35:27 +00002007
2008int
Victor Stinner53dc7352011-03-20 01:50:21 +01002009PyImport_ImportFrozenModuleObject(PyObject *name)
Guido van Rossumf56e3db1993-04-01 20:59:32 +00002010{
Victor Stinner53dc7352011-03-20 01:50:21 +01002011 struct _frozen *p;
2012 PyObject *co, *m, *path;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002013 int ispackage;
2014 int size;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002015
Victor Stinner53dc7352011-03-20 01:50:21 +01002016 p = find_frozen(name);
2017
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002018 if (p == NULL)
2019 return 0;
2020 if (p->code == NULL) {
2021 PyErr_Format(PyExc_ImportError,
Victor Stinner53dc7352011-03-20 01:50:21 +01002022 "Excluded frozen object named %R",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002023 name);
2024 return -1;
2025 }
2026 size = p->size;
2027 ispackage = (size < 0);
2028 if (ispackage)
2029 size = -size;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002030 co = PyMarshal_ReadObjectFromString((char *)p->code, size);
2031 if (co == NULL)
2032 return -1;
2033 if (!PyCode_Check(co)) {
2034 PyErr_Format(PyExc_TypeError,
Victor Stinner53dc7352011-03-20 01:50:21 +01002035 "frozen object %R is not a code object",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002036 name);
2037 goto err_return;
2038 }
2039 if (ispackage) {
2040 /* Set __path__ to the package name */
Victor Stinner53dc7352011-03-20 01:50:21 +01002041 PyObject *d, *l;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002042 int err;
Victor Stinner53dc7352011-03-20 01:50:21 +01002043 m = PyImport_AddModuleObject(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002044 if (m == NULL)
2045 goto err_return;
2046 d = PyModule_GetDict(m);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002047 l = PyList_New(1);
2048 if (l == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002049 goto err_return;
2050 }
Victor Stinner53dc7352011-03-20 01:50:21 +01002051 Py_INCREF(name);
2052 PyList_SET_ITEM(l, 0, name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002053 err = PyDict_SetItemString(d, "__path__", l);
2054 Py_DECREF(l);
2055 if (err != 0)
2056 goto err_return;
2057 }
Victor Stinner53dc7352011-03-20 01:50:21 +01002058 path = PyUnicode_FromString("<frozen>");
2059 if (path == NULL)
2060 goto err_return;
2061 m = PyImport_ExecCodeModuleObject(name, co, path, NULL);
2062 Py_DECREF(path);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002063 if (m == NULL)
2064 goto err_return;
2065 Py_DECREF(co);
2066 Py_DECREF(m);
2067 return 1;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002068err_return:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002069 Py_DECREF(co);
2070 return -1;
Guido van Rossumf56e3db1993-04-01 20:59:32 +00002071}
Guido van Rossum74e6a111994-08-29 12:54:38 +00002072
Victor Stinner53dc7352011-03-20 01:50:21 +01002073int
2074PyImport_ImportFrozenModule(char *name)
2075{
2076 PyObject *nameobj;
2077 int ret;
2078 nameobj = PyUnicode_InternFromString(name);
2079 if (nameobj == NULL)
2080 return -1;
2081 ret = PyImport_ImportFrozenModuleObject(nameobj);
2082 Py_DECREF(nameobj);
2083 return ret;
2084}
2085
Guido van Rossum74e6a111994-08-29 12:54:38 +00002086
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002087/* Import a module, either built-in, frozen, or external, and return
Guido van Rossum7f9fa971995-01-20 16:53:12 +00002088 its module object WITH INCREMENTED REFERENCE COUNT */
Guido van Rossum74e6a111994-08-29 12:54:38 +00002089
Guido van Rossum79f25d91997-04-29 20:08:16 +00002090PyObject *
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00002091PyImport_ImportModule(const char *name)
Guido van Rossum74e6a111994-08-29 12:54:38 +00002092{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002093 PyObject *pname;
2094 PyObject *result;
Marc-André Lemburg3c61c352001-02-09 19:40:15 +00002095
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002096 pname = PyUnicode_FromString(name);
2097 if (pname == NULL)
2098 return NULL;
2099 result = PyImport_Import(pname);
2100 Py_DECREF(pname);
2101 return result;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002102}
2103
Christian Heimes072c0f12008-01-03 23:01:04 +00002104/* Import a module without blocking
2105 *
2106 * At first it tries to fetch the module from sys.modules. If the module was
2107 * never loaded before it loads it with PyImport_ImportModule() unless another
2108 * thread holds the import lock. In the latter case the function raises an
2109 * ImportError instead of blocking.
2110 *
2111 * Returns the module object with incremented ref count.
2112 */
2113PyObject *
2114PyImport_ImportModuleNoBlock(const char *name)
2115{
Victor Stinner2e5f11a2011-03-13 21:57:27 -04002116 PyObject *nameobj, *modules, *result;
Victor Stinner0af03062011-09-02 00:11:43 +02002117#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002118 long me;
Victor Stinner0af03062011-09-02 00:11:43 +02002119#endif
Christian Heimes072c0f12008-01-03 23:01:04 +00002120
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002121 /* Try to get the module from sys.modules[name] */
2122 modules = PyImport_GetModuleDict();
2123 if (modules == NULL)
2124 return NULL;
Christian Heimes072c0f12008-01-03 23:01:04 +00002125
Victor Stinner2e5f11a2011-03-13 21:57:27 -04002126 nameobj = PyUnicode_FromString(name);
2127 if (nameobj == NULL)
2128 return NULL;
2129 result = PyDict_GetItem(modules, nameobj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002130 if (result != NULL) {
Victor Stinner2e5f11a2011-03-13 21:57:27 -04002131 Py_DECREF(nameobj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002132 Py_INCREF(result);
2133 return result;
2134 }
Victor Stinner2e5f11a2011-03-13 21:57:27 -04002135 PyErr_Clear();
Benjamin Peterson3e4f0552008-09-02 00:31:15 +00002136#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002137 /* check the import lock
2138 * me might be -1 but I ignore the error here, the lock function
2139 * takes care of the problem */
2140 me = PyThread_get_thread_ident();
2141 if (import_lock_thread == -1 || import_lock_thread == me) {
2142 /* no thread or me is holding the lock */
Victor Stinner2e5f11a2011-03-13 21:57:27 -04002143 result = PyImport_Import(nameobj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002144 }
2145 else {
2146 PyErr_Format(PyExc_ImportError,
Victor Stinnerc24c8102011-03-13 22:38:06 -04002147 "Failed to import %R because the import lock"
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002148 "is held by another thread.",
Victor Stinner2e5f11a2011-03-13 21:57:27 -04002149 nameobj);
2150 result = NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002151 }
Benjamin Peterson3e4f0552008-09-02 00:31:15 +00002152#else
Victor Stinner2e5f11a2011-03-13 21:57:27 -04002153 result = PyImport_Import(nameobj);
Benjamin Peterson3e4f0552008-09-02 00:31:15 +00002154#endif
Victor Stinner2e5f11a2011-03-13 21:57:27 -04002155 Py_DECREF(nameobj);
2156 return result;
Christian Heimes072c0f12008-01-03 23:01:04 +00002157}
2158
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002159
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002160PyObject *
Brett Cannonfd074152012-04-14 14:10:13 -04002161PyImport_ImportModuleLevelObject(PyObject *name, PyObject *given_globals,
2162 PyObject *locals, PyObject *given_fromlist,
Victor Stinnerfe93faf2011-03-14 15:54:52 -04002163 int level)
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002164{
Brett Cannonfd074152012-04-14 14:10:13 -04002165 _Py_IDENTIFIER(__import__);
2166 _Py_IDENTIFIER(__package__);
2167 _Py_IDENTIFIER(__path__);
2168 _Py_IDENTIFIER(__name__);
2169 _Py_IDENTIFIER(_find_and_load);
2170 _Py_IDENTIFIER(_handle_fromlist);
2171 _Py_static_string(single_dot, ".");
2172 PyObject *abs_name = NULL;
2173 PyObject *builtins_import = NULL;
2174 PyObject *final_mod = NULL;
2175 PyObject *mod = NULL;
2176 PyObject *package = NULL;
2177 PyObject *globals = NULL;
2178 PyObject *fromlist = NULL;
2179 PyInterpreterState *interp = PyThreadState_GET()->interp;
2180
2181 /* Make sure to use default values so as to not have
2182 PyObject_CallMethodObjArgs() truncate the parameter list because of a
2183 NULL argument. */
2184 if (given_globals == NULL) {
2185 globals = PyDict_New();
2186 if (globals == NULL) {
2187 goto error;
2188 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002189 }
Brett Cannonfd074152012-04-14 14:10:13 -04002190 else {
2191 /* Only have to care what given_globals is if it will be used
2192 fortsomething. */
2193 if (level > 0 && !PyDict_Check(given_globals)) {
2194 PyErr_SetString(PyExc_TypeError, "globals must be a dict");
2195 goto error;
2196 }
2197 globals = given_globals;
2198 Py_INCREF(globals);
2199 }
2200
2201 if (given_fromlist == NULL) {
2202 fromlist = PyList_New(0);
2203 if (fromlist == NULL) {
2204 goto error;
2205 }
2206 }
2207 else {
2208 fromlist = given_fromlist;
2209 Py_INCREF(fromlist);
2210 }
2211 if (name == NULL) {
2212 PyErr_SetString(PyExc_ValueError, "Empty module name");
2213 goto error;
2214 }
2215
2216 /* The below code is importlib.__import__() & _gcd_import(), ported to C
2217 for added performance. */
2218
2219 if (!PyUnicode_Check(name)) {
2220 PyErr_SetString(PyExc_TypeError, "module name must be a string");
2221 goto error;
2222 }
2223 else if (PyUnicode_READY(name) < 0) {
2224 goto error;
2225 }
2226 if (level < 0) {
2227 PyErr_SetString(PyExc_ValueError, "level must be >= 0");
2228 goto error;
2229 }
2230 else if (level > 0) {
2231 package = _PyDict_GetItemId(globals, &PyId___package__);
2232 if (package != NULL && package != Py_None) {
2233 Py_INCREF(package);
2234 if (!PyUnicode_Check(package)) {
2235 PyErr_SetString(PyExc_TypeError, "package must be a string");
2236 goto error;
2237 }
2238 }
2239 else {
Brett Cannon273323c2012-04-17 19:05:11 -04002240 package = _PyDict_GetItemId(globals, &PyId___name__);
Brett Cannonfd074152012-04-14 14:10:13 -04002241 if (package == NULL) {
Brett Cannon273323c2012-04-17 19:05:11 -04002242 PyErr_SetString(PyExc_KeyError, "'__name__' not in globals");
Brett Cannonfd074152012-04-14 14:10:13 -04002243 goto error;
2244 }
2245 else if (!PyUnicode_Check(package)) {
2246 PyErr_SetString(PyExc_TypeError, "__name__ must be a string");
2247 }
2248 Py_INCREF(package);
2249
2250 if (_PyDict_GetItemId(globals, &PyId___path__) == NULL) {
Brett Cannon740fce02012-04-14 14:23:49 -04002251 PyObject *partition = NULL;
Brett Cannonfd074152012-04-14 14:10:13 -04002252 PyObject *borrowed_dot = _PyUnicode_FromId(&single_dot);
2253 if (borrowed_dot == NULL) {
2254 goto error;
2255 }
Brett Cannon740fce02012-04-14 14:23:49 -04002256 partition = PyUnicode_RPartition(package, borrowed_dot);
Brett Cannonfd074152012-04-14 14:10:13 -04002257 Py_DECREF(package);
2258 if (partition == NULL) {
2259 goto error;
2260 }
2261 package = PyTuple_GET_ITEM(partition, 0);
2262 Py_INCREF(package);
2263 Py_DECREF(partition);
2264 }
2265 }
2266
2267 if (PyDict_GetItem(interp->modules, package) == NULL) {
2268 PyErr_Format(PyExc_SystemError,
2269 "Parent module %R not loaded, cannot perform relative "
2270 "import", package);
2271 goto error;
2272 }
2273 }
2274 else { /* level == 0 */
2275 if (PyUnicode_GET_LENGTH(name) == 0) {
2276 PyErr_SetString(PyExc_ValueError, "Empty module name");
2277 goto error;
2278 }
2279 package = Py_None;
2280 Py_INCREF(package);
2281 }
2282
2283 if (level > 0) {
2284 Py_ssize_t last_dot = PyUnicode_GET_LENGTH(package);
2285 PyObject *base = NULL;
2286 int level_up = 1;
2287
2288 for (level_up = 1; level_up < level; level_up += 1) {
2289 last_dot = PyUnicode_FindChar(package, '.', 0, last_dot, -1);
2290 if (last_dot == -2) {
2291 goto error;
2292 }
2293 else if (last_dot == -1) {
2294 PyErr_SetString(PyExc_ValueError,
2295 "attempted relative import beyond top-level "
2296 "package");
2297 goto error;
2298 }
2299 }
2300 base = PyUnicode_Substring(package, 0, last_dot);
2301 if (PyUnicode_GET_LENGTH(name) > 0) {
Antoine Pitrou538ba2a2012-04-16 21:52:45 +02002302 PyObject *borrowed_dot, *seq = NULL;
Brett Cannonfd074152012-04-14 14:10:13 -04002303
2304 borrowed_dot = _PyUnicode_FromId(&single_dot);
Antoine Pitrou538ba2a2012-04-16 21:52:45 +02002305 seq = PyTuple_Pack(2, base, name);
2306 Py_DECREF(base);
Brett Cannonfd074152012-04-14 14:10:13 -04002307 if (borrowed_dot == NULL || seq == NULL) {
2308 goto error;
2309 }
2310
2311 abs_name = PyUnicode_Join(borrowed_dot, seq);
2312 Py_DECREF(seq);
2313 if (abs_name == NULL) {
2314 goto error;
2315 }
2316 }
2317 else {
2318 abs_name = base;
2319 }
2320 }
2321 else {
2322 abs_name = name;
2323 Py_INCREF(abs_name);
2324 }
2325
Brian Curtine6b299f2012-04-14 14:19:33 -05002326#ifdef WITH_THREAD
Brett Cannonfd074152012-04-14 14:10:13 -04002327 _PyImport_AcquireLock();
2328#endif
2329 /* From this point forward, goto error_with_unlock! */
2330 if (PyDict_Check(globals)) {
2331 builtins_import = _PyDict_GetItemId(globals, &PyId___import__);
2332 }
2333 if (builtins_import == NULL) {
2334 builtins_import = _PyDict_GetItemId(interp->builtins, &PyId___import__);
2335 if (builtins_import == NULL) {
2336 Py_FatalError("__import__ missing");
2337 }
2338 }
2339 Py_INCREF(builtins_import);
2340
2341 mod = PyDict_GetItem(interp->modules, abs_name);
2342 if (mod == Py_None) {
Brett Cannon27fc5282012-04-15 14:15:31 -04002343 PyObject *msg = PyUnicode_FromFormat("import of %R halted; "
2344 "None in sys.modules", abs_name);
2345 if (msg != NULL) {
Brian Curtin09b86d12012-04-17 16:57:09 -05002346 PyErr_SetImportError(msg, abs_name, NULL);
2347 Py_DECREF(msg);
Brett Cannon27fc5282012-04-15 14:15:31 -04002348 }
Antoine Pitrou71382cb2012-04-16 18:48:49 +02002349 mod = NULL;
Brett Cannonfd074152012-04-14 14:10:13 -04002350 goto error_with_unlock;
2351 }
2352 else if (mod != NULL) {
2353 Py_INCREF(mod);
2354 }
2355 else {
2356 mod = _PyObject_CallMethodObjIdArgs(interp->importlib,
2357 &PyId__find_and_load, abs_name,
2358 builtins_import, NULL);
2359 if (mod == NULL) {
2360 goto error_with_unlock;
2361 }
2362 }
2363
2364 if (PyObject_Not(fromlist)) {
2365 if (level == 0 || PyUnicode_GET_LENGTH(name) > 0) {
2366 PyObject *front = NULL;
Brian Curtine6b299f2012-04-14 14:19:33 -05002367 PyObject *partition = NULL;
Brett Cannonfd074152012-04-14 14:10:13 -04002368 PyObject *borrowed_dot = _PyUnicode_FromId(&single_dot);
2369
2370 if (borrowed_dot == NULL) {
2371 goto error_with_unlock;
2372 }
2373
Brian Curtine6b299f2012-04-14 14:19:33 -05002374 partition = PyUnicode_Partition(name, borrowed_dot);
Brett Cannonfd074152012-04-14 14:10:13 -04002375 if (partition == NULL) {
2376 goto error_with_unlock;
2377 }
2378
2379 front = PyTuple_GET_ITEM(partition, 0);
2380 Py_INCREF(front);
2381 Py_DECREF(partition);
2382
2383 if (level == 0) {
Benjamin Petersond76bc7a2012-04-18 10:55:43 -04002384 final_mod = PyDict_GetItem(interp->modules, front);
Brett Cannon881535b2012-04-15 15:24:04 -04002385 Py_DECREF(front);
2386 if (final_mod == NULL) {
Benjamin Petersond76bc7a2012-04-18 10:55:43 -04002387 PyErr_Format(PyExc_KeyError,
2388 "%R not in sys.modules as expected", front);
Brett Cannon881535b2012-04-15 15:24:04 -04002389 }
Benjamin Petersond76bc7a2012-04-18 10:55:43 -04002390 else {
2391 Py_INCREF(final_mod);
2392 }
Brett Cannonfd074152012-04-14 14:10:13 -04002393 }
2394 else {
Antoine Pitrou22a1d172012-04-16 22:06:21 +02002395 Py_ssize_t cut_off = PyUnicode_GET_LENGTH(name) -
2396 PyUnicode_GET_LENGTH(front);
2397 Py_ssize_t abs_name_len = PyUnicode_GET_LENGTH(abs_name);
Brett Cannon49f8d8b2012-04-14 21:50:00 -04002398 PyObject *to_return = PyUnicode_Substring(abs_name, 0,
Brett Cannonfd074152012-04-14 14:10:13 -04002399 abs_name_len - cut_off);
Antoine Pitrou22a1d172012-04-16 22:06:21 +02002400 Py_DECREF(front);
2401 if (to_return == NULL) {
2402 goto error_with_unlock;
2403 }
Brett Cannonfd074152012-04-14 14:10:13 -04002404
2405 final_mod = PyDict_GetItem(interp->modules, to_return);
Brett Cannonfd074152012-04-14 14:10:13 -04002406 Py_DECREF(to_return);
Brett Cannon49f8d8b2012-04-14 21:50:00 -04002407 if (final_mod == NULL) {
2408 PyErr_Format(PyExc_KeyError,
2409 "%R not in sys.modules as expected",
2410 to_return);
2411 }
2412 else {
2413 Py_INCREF(final_mod);
2414 }
Brett Cannonfd074152012-04-14 14:10:13 -04002415 }
2416 }
2417 else {
2418 final_mod = mod;
2419 Py_INCREF(mod);
2420 }
2421 }
2422 else {
2423 final_mod = _PyObject_CallMethodObjIdArgs(interp->importlib,
2424 &PyId__handle_fromlist, mod,
2425 fromlist, builtins_import,
2426 NULL);
2427 }
2428 error_with_unlock:
Brian Curtine6b299f2012-04-14 14:19:33 -05002429#ifdef WITH_THREAD
Brett Cannonfd074152012-04-14 14:10:13 -04002430 if (_PyImport_ReleaseLock() < 0) {
2431 PyErr_SetString(PyExc_RuntimeError, "not holding the import lock");
2432 }
2433#endif
2434 error:
2435 Py_XDECREF(abs_name);
2436 Py_XDECREF(builtins_import);
2437 Py_XDECREF(mod);
2438 Py_XDECREF(package);
2439 Py_XDECREF(globals);
2440 Py_XDECREF(fromlist);
2441 return final_mod;
Guido van Rossum75acc9c1998-03-03 22:26:50 +00002442}
2443
Victor Stinnerfe93faf2011-03-14 15:54:52 -04002444PyObject *
Benjamin Peterson04778a82011-05-25 09:29:00 -05002445PyImport_ImportModuleLevel(const char *name, PyObject *globals, PyObject *locals,
Victor Stinnerfe93faf2011-03-14 15:54:52 -04002446 PyObject *fromlist, int level)
2447{
2448 PyObject *nameobj, *mod;
2449 nameobj = PyUnicode_FromString(name);
2450 if (nameobj == NULL)
2451 return NULL;
2452 mod = PyImport_ImportModuleLevelObject(nameobj, globals, locals,
2453 fromlist, level);
2454 Py_DECREF(nameobj);
2455 return mod;
2456}
2457
2458
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002459/* Re-import a module of any kind and return its module object, WITH
2460 INCREMENTED REFERENCE COUNT */
2461
Guido van Rossum79f25d91997-04-29 20:08:16 +00002462PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002463PyImport_ReloadModule(PyObject *m)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002464{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002465 PyInterpreterState *interp = PyThreadState_Get()->interp;
2466 PyObject *modules_reloading = interp->modules_reloading;
2467 PyObject *modules = PyImport_GetModuleDict();
Brett Cannon8a1d04c2012-04-15 17:56:09 -04002468 PyObject *loader = NULL, *existing_m = NULL;
2469 PyObject *name;
Martin v. Löwis796ea532011-10-30 09:07:07 +01002470 Py_ssize_t subname_start;
Victor Stinnerad3c03b2011-03-14 09:21:33 -04002471 PyObject *newm = NULL;
Brett Cannon8a1d04c2012-04-15 17:56:09 -04002472 _Py_IDENTIFIER(__loader__);
2473 _Py_IDENTIFIER(load_module);
Brett Cannon9a5b25a2010-03-01 02:09:17 +00002474
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002475 if (modules_reloading == NULL) {
2476 Py_FatalError("PyImport_ReloadModule: "
2477 "no modules_reloading dictionary!");
2478 return NULL;
2479 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002480
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002481 if (m == NULL || !PyModule_Check(m)) {
2482 PyErr_SetString(PyExc_TypeError,
2483 "reload() argument must be module");
2484 return NULL;
2485 }
Martin v. Löwis796ea532011-10-30 09:07:07 +01002486 name = PyModule_GetNameObject(m);
2487 if (name == NULL || PyUnicode_READY(name) == -1)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002488 return NULL;
Martin v. Löwis796ea532011-10-30 09:07:07 +01002489 if (m != PyDict_GetItem(modules, name)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002490 PyErr_Format(PyExc_ImportError,
Victor Stinner98dbba52011-03-14 15:15:47 -04002491 "reload(): module %R not in sys.modules",
Martin v. Löwis796ea532011-10-30 09:07:07 +01002492 name);
2493 Py_DECREF(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002494 return NULL;
2495 }
Martin v. Löwis796ea532011-10-30 09:07:07 +01002496 existing_m = PyDict_GetItem(modules_reloading, name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002497 if (existing_m != NULL) {
2498 /* Due to a recursive reload, this module is already
2499 being reloaded. */
Martin v. Löwis796ea532011-10-30 09:07:07 +01002500 Py_DECREF(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002501 Py_INCREF(existing_m);
2502 return existing_m;
2503 }
Martin v. Löwis796ea532011-10-30 09:07:07 +01002504 if (PyDict_SetItem(modules_reloading, name, m) < 0) {
2505 Py_DECREF(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002506 return NULL;
Victor Stinnerad3c03b2011-03-14 09:21:33 -04002507 }
Guido van Rossumd8faa362007-04-27 19:54:29 +00002508
Martin v. Löwis796ea532011-10-30 09:07:07 +01002509 subname_start = PyUnicode_FindChar(name, '.', 0,
2510 PyUnicode_GET_LENGTH(name), -1);
Brett Cannon8a1d04c2012-04-15 17:56:09 -04002511 if (subname_start != -1) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002512 PyObject *parentname, *parent;
Martin v. Löwis796ea532011-10-30 09:07:07 +01002513 parentname = PyUnicode_Substring(name, 0, subname_start);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002514 if (parentname == NULL) {
Victor Stinnerad3c03b2011-03-14 09:21:33 -04002515 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002516 }
2517 parent = PyDict_GetItem(modules, parentname);
Brett Cannon8a1d04c2012-04-15 17:56:09 -04002518 Py_XDECREF(parent);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002519 if (parent == NULL) {
2520 PyErr_Format(PyExc_ImportError,
Victor Stinner98dbba52011-03-14 15:15:47 -04002521 "reload(): parent %R not in sys.modules",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002522 parentname);
Victor Stinnerad3c03b2011-03-14 09:21:33 -04002523 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002524 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002525 }
Phillip J. Eby7ec642a2004-09-23 04:37:36 +00002526
Brett Cannon8a1d04c2012-04-15 17:56:09 -04002527 loader = _PyObject_GetAttrId(m, &PyId___loader__);
2528 if (loader == NULL) {
2529 goto error;
2530 }
2531 newm = _PyObject_CallMethodId(loader, &PyId_load_module, "O", name);
2532 Py_DECREF(loader);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002533 if (newm == NULL) {
2534 /* load_module probably removed name from modules because of
2535 * the error. Put back the original module object. We're
2536 * going to return NULL in this case regardless of whether
2537 * replacing name succeeds, so the return value is ignored.
2538 */
Martin v. Löwis796ea532011-10-30 09:07:07 +01002539 PyDict_SetItem(modules, name, m);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002540 }
Victor Stinnerad3c03b2011-03-14 09:21:33 -04002541
2542error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002543 imp_modules_reloading_clear();
Martin v. Löwis796ea532011-10-30 09:07:07 +01002544 Py_DECREF(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002545 return newm;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002546}
2547
2548
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002549/* Higher-level import emulator which emulates the "import" statement
2550 more accurately -- it invokes the __import__() function from the
2551 builtins of the current globals. This means that the import is
2552 done using whatever import hooks are installed in the current
Brett Cannonbc2eff32010-09-19 21:39:02 +00002553 environment.
Guido van Rossum6058eb41998-12-21 19:51:00 +00002554 A dummy list ["__doc__"] is passed as the 4th argument so that
Neal Norwitz80e7f272007-08-26 06:45:23 +00002555 e.g. PyImport_Import(PyUnicode_FromString("win32com.client.gencache"))
Guido van Rossum6058eb41998-12-21 19:51:00 +00002556 will return <module "gencache"> instead of <module "win32com">. */
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002557
2558PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002559PyImport_Import(PyObject *module_name)
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002560{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002561 static PyObject *silly_list = NULL;
2562 static PyObject *builtins_str = NULL;
2563 static PyObject *import_str = NULL;
2564 PyObject *globals = NULL;
2565 PyObject *import = NULL;
2566 PyObject *builtins = NULL;
Brett Cannonbc2eff32010-09-19 21:39:02 +00002567 PyObject *modules = NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002568 PyObject *r = NULL;
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002569
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002570 /* Initialize constant string objects */
2571 if (silly_list == NULL) {
2572 import_str = PyUnicode_InternFromString("__import__");
2573 if (import_str == NULL)
2574 return NULL;
2575 builtins_str = PyUnicode_InternFromString("__builtins__");
2576 if (builtins_str == NULL)
2577 return NULL;
Brett Cannonbc2eff32010-09-19 21:39:02 +00002578 silly_list = PyList_New(0);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002579 if (silly_list == NULL)
2580 return NULL;
2581 }
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002582
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002583 /* Get the builtins from current globals */
2584 globals = PyEval_GetGlobals();
2585 if (globals != NULL) {
2586 Py_INCREF(globals);
2587 builtins = PyObject_GetItem(globals, builtins_str);
2588 if (builtins == NULL)
2589 goto err;
2590 }
2591 else {
2592 /* No globals -- use standard builtins, and fake globals */
2593 builtins = PyImport_ImportModuleLevel("builtins",
2594 NULL, NULL, NULL, 0);
2595 if (builtins == NULL)
2596 return NULL;
2597 globals = Py_BuildValue("{OO}", builtins_str, builtins);
2598 if (globals == NULL)
2599 goto err;
2600 }
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002601
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002602 /* Get the __import__ function from the builtins */
2603 if (PyDict_Check(builtins)) {
2604 import = PyObject_GetItem(builtins, import_str);
2605 if (import == NULL)
2606 PyErr_SetObject(PyExc_KeyError, import_str);
2607 }
2608 else
2609 import = PyObject_GetAttr(builtins, import_str);
2610 if (import == NULL)
2611 goto err;
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002612
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002613 /* Call the __import__ function with the proper argument list
Brett Cannonbc2eff32010-09-19 21:39:02 +00002614 Always use absolute import here.
2615 Calling for side-effect of import. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002616 r = PyObject_CallFunction(import, "OOOOi", module_name, globals,
2617 globals, silly_list, 0, NULL);
Brett Cannonbc2eff32010-09-19 21:39:02 +00002618 if (r == NULL)
2619 goto err;
2620 Py_DECREF(r);
2621
2622 modules = PyImport_GetModuleDict();
2623 r = PyDict_GetItem(modules, module_name);
2624 if (r != NULL)
2625 Py_INCREF(r);
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002626
2627 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002628 Py_XDECREF(globals);
2629 Py_XDECREF(builtins);
2630 Py_XDECREF(import);
Tim Peters50d8d372001-02-28 05:34:27 +00002631
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002632 return r;
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002633}
2634
2635
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002636/* Module 'imp' provides Python access to the primitives used for
2637 importing modules.
2638*/
2639
Guido van Rossum79f25d91997-04-29 20:08:16 +00002640static PyObject *
Barry Warsaw28a691b2010-04-17 00:19:56 +00002641imp_make_magic(long magic)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002642{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002643 char buf[4];
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002644
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002645 buf[0] = (char) ((magic >> 0) & 0xff);
2646 buf[1] = (char) ((magic >> 8) & 0xff);
2647 buf[2] = (char) ((magic >> 16) & 0xff);
2648 buf[3] = (char) ((magic >> 24) & 0xff);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002649
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002650 return PyBytes_FromStringAndSize(buf, 4);
Victor Stinner3e2b7172010-11-09 09:32:19 +00002651}
Barry Warsaw28a691b2010-04-17 00:19:56 +00002652
2653static PyObject *
2654imp_get_magic(PyObject *self, PyObject *noargs)
2655{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002656 return imp_make_magic(pyc_magic);
Barry Warsaw28a691b2010-04-17 00:19:56 +00002657}
2658
2659static PyObject *
2660imp_get_tag(PyObject *self, PyObject *noargs)
2661{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002662 return PyUnicode_FromString(pyc_tag);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002663}
2664
Guido van Rossum79f25d91997-04-29 20:08:16 +00002665static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +00002666imp_get_suffixes(PyObject *self, PyObject *noargs)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002667{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002668 PyObject *list;
2669 struct filedescr *fdp;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002670
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002671 list = PyList_New(0);
2672 if (list == NULL)
2673 return NULL;
2674 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
2675 PyObject *item = Py_BuildValue("ssi",
2676 fdp->suffix, fdp->mode, fdp->type);
2677 if (item == NULL) {
2678 Py_DECREF(list);
2679 return NULL;
2680 }
2681 if (PyList_Append(list, item) < 0) {
2682 Py_DECREF(list);
2683 Py_DECREF(item);
2684 return NULL;
2685 }
2686 Py_DECREF(item);
2687 }
2688 return list;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002689}
2690
Guido van Rossum79f25d91997-04-29 20:08:16 +00002691static PyObject *
Victor Stinner533d7832011-03-14 13:22:54 -04002692call_find_module(PyObject *name, PyObject *path_list)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002693{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002694 extern int fclose(FILE *);
2695 PyObject *fob, *ret;
2696 PyObject *pathobj;
2697 struct filedescr *fdp;
Victor Stinner7d8b77c2011-03-12 08:45:02 -05002698 FILE *fp;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002699 int fd = -1;
2700 char *found_encoding = NULL;
2701 char *encoding = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002702
Victor Stinner533d7832011-03-14 13:22:54 -04002703 if (path_list == Py_None)
2704 path_list = NULL;
2705 fdp = find_module(NULL, name, path_list,
Victor Stinner2fd76e42011-03-14 15:19:39 -04002706 &pathobj, &fp, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002707 if (fdp == NULL)
2708 return NULL;
2709 if (fp != NULL) {
2710 fd = fileno(fp);
2711 if (fd != -1)
2712 fd = dup(fd);
2713 fclose(fp);
2714 fp = NULL;
Antoine Pitrou72146122012-02-22 18:03:04 +01002715 if (fd == -1)
2716 return PyErr_SetFromErrno(PyExc_OSError);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002717 }
2718 if (fd != -1) {
2719 if (strchr(fdp->mode, 'b') == NULL) {
Victor Stinnerfe7c5b52011-04-05 01:48:03 +02002720 /* PyTokenizer_FindEncodingFilename() returns PyMem_MALLOC'ed
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002721 memory. */
Victor Stinnerfe7c5b52011-04-05 01:48:03 +02002722 found_encoding = PyTokenizer_FindEncodingFilename(fd, pathobj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002723 lseek(fd, 0, 0); /* Reset position */
Victor Stinner2fd76e42011-03-14 15:19:39 -04002724 if (found_encoding == NULL && PyErr_Occurred()) {
2725 Py_XDECREF(pathobj);
Antoine Pitrou4f22a8d2012-02-22 18:05:43 +01002726 close(fd);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002727 return NULL;
Victor Stinner2fd76e42011-03-14 15:19:39 -04002728 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002729 encoding = (found_encoding != NULL) ? found_encoding :
2730 (char*)PyUnicode_GetDefaultEncoding();
2731 }
Victor Stinner2fd76e42011-03-14 15:19:39 -04002732 fob = PyFile_FromFd(fd, NULL, fdp->mode, -1,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002733 (char*)encoding, NULL, NULL, 1);
2734 if (fob == NULL) {
Victor Stinner2fd76e42011-03-14 15:19:39 -04002735 Py_XDECREF(pathobj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002736 close(fd);
2737 PyMem_FREE(found_encoding);
2738 return NULL;
2739 }
2740 }
2741 else {
2742 fob = Py_None;
2743 Py_INCREF(fob);
2744 }
Victor Stinner2fd76e42011-03-14 15:19:39 -04002745 if (pathobj == NULL) {
2746 Py_INCREF(Py_None);
2747 pathobj = Py_None;
2748 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002749 ret = Py_BuildValue("NN(ssi)",
2750 fob, pathobj, fdp->suffix, fdp->mode, fdp->type);
2751 PyMem_FREE(found_encoding);
Brett Cannon3bb42d92007-10-20 03:43:15 +00002752
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002753 return ret;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002754}
2755
Guido van Rossum79f25d91997-04-29 20:08:16 +00002756static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002757imp_find_module(PyObject *self, PyObject *args)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002758{
Victor Stinnerad3c03b2011-03-14 09:21:33 -04002759 PyObject *name, *path_list = NULL;
2760 if (!PyArg_ParseTuple(args, "U|O:find_module",
2761 &name, &path_list))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002762 return NULL;
Victor Stinnerad3c03b2011-03-14 09:21:33 -04002763 return call_find_module(name, path_list);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002764}
2765
2766static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002767imp_init_builtin(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002768{
Victor Stinner95872862011-03-07 18:20:56 +01002769 PyObject *name;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002770 int ret;
2771 PyObject *m;
Victor Stinner95872862011-03-07 18:20:56 +01002772 if (!PyArg_ParseTuple(args, "U:init_builtin", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002773 return NULL;
2774 ret = init_builtin(name);
2775 if (ret < 0)
2776 return NULL;
2777 if (ret == 0) {
2778 Py_INCREF(Py_None);
2779 return Py_None;
2780 }
Victor Stinner95872862011-03-07 18:20:56 +01002781 m = PyImport_AddModuleObject(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002782 Py_XINCREF(m);
2783 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002784}
2785
Guido van Rossum79f25d91997-04-29 20:08:16 +00002786static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002787imp_init_frozen(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002788{
Victor Stinner53dc7352011-03-20 01:50:21 +01002789 PyObject *name;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002790 int ret;
2791 PyObject *m;
Victor Stinner53dc7352011-03-20 01:50:21 +01002792 if (!PyArg_ParseTuple(args, "U:init_frozen", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002793 return NULL;
Victor Stinner53dc7352011-03-20 01:50:21 +01002794 ret = PyImport_ImportFrozenModuleObject(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002795 if (ret < 0)
2796 return NULL;
2797 if (ret == 0) {
2798 Py_INCREF(Py_None);
2799 return Py_None;
2800 }
Victor Stinner53dc7352011-03-20 01:50:21 +01002801 m = PyImport_AddModuleObject(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002802 Py_XINCREF(m);
2803 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002804}
2805
Guido van Rossum79f25d91997-04-29 20:08:16 +00002806static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002807imp_get_frozen_object(PyObject *self, PyObject *args)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002808{
Victor Stinner53dc7352011-03-20 01:50:21 +01002809 PyObject *name;
Jack Jansen95ffa231995-10-03 14:38:41 +00002810
Victor Stinner53dc7352011-03-20 01:50:21 +01002811 if (!PyArg_ParseTuple(args, "U:get_frozen_object", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002812 return NULL;
2813 return get_frozen_object(name);
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002814}
2815
Guido van Rossum79f25d91997-04-29 20:08:16 +00002816static PyObject *
Brett Cannon8d110132009-03-15 02:20:16 +00002817imp_is_frozen_package(PyObject *self, PyObject *args)
2818{
Victor Stinner53dc7352011-03-20 01:50:21 +01002819 PyObject *name;
Brett Cannon8d110132009-03-15 02:20:16 +00002820
Victor Stinner53dc7352011-03-20 01:50:21 +01002821 if (!PyArg_ParseTuple(args, "U:is_frozen_package", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002822 return NULL;
2823 return is_frozen_package(name);
Brett Cannon8d110132009-03-15 02:20:16 +00002824}
2825
2826static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002827imp_is_builtin(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002828{
Victor Stinner95872862011-03-07 18:20:56 +01002829 PyObject *name;
2830 if (!PyArg_ParseTuple(args, "U:is_builtin", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002831 return NULL;
2832 return PyLong_FromLong(is_builtin(name));
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002833}
2834
Guido van Rossum79f25d91997-04-29 20:08:16 +00002835static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002836imp_is_frozen(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002837{
Victor Stinner53dc7352011-03-20 01:50:21 +01002838 PyObject *name;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002839 struct _frozen *p;
Victor Stinner53dc7352011-03-20 01:50:21 +01002840 if (!PyArg_ParseTuple(args, "U:is_frozen", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002841 return NULL;
2842 p = find_frozen(name);
2843 return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002844}
2845
2846static FILE *
Victor Stinner2f42ae52011-03-20 00:41:24 +01002847get_file(PyObject *pathname, PyObject *fob, char *mode)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002848{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002849 FILE *fp;
2850 if (mode[0] == 'U')
2851 mode = "r" PY_STDIOTEXTMODE;
2852 if (fob == NULL) {
Victor Stinner2f42ae52011-03-20 00:41:24 +01002853 fp = _Py_fopen(pathname, mode);
Victor Stinner35734762011-12-18 21:05:22 +01002854 if (!fp) {
2855 if (!PyErr_Occurred())
2856 PyErr_SetFromErrno(PyExc_IOError);
2857 return NULL;
2858 }
2859 return fp;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002860 }
2861 else {
2862 int fd = PyObject_AsFileDescriptor(fob);
2863 if (fd == -1)
2864 return NULL;
Victor Stinner35734762011-12-18 21:05:22 +01002865 if (!_PyVerify_fd(fd)) {
2866 PyErr_SetFromErrno(PyExc_IOError);
2867 return NULL;
2868 }
2869
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002870 /* the FILE struct gets a new fd, so that it can be closed
2871 * independently of the file descriptor given
2872 */
2873 fd = dup(fd);
Victor Stinner35734762011-12-18 21:05:22 +01002874 if (fd == -1) {
2875 PyErr_SetFromErrno(PyExc_IOError);
2876 return NULL;
2877 }
2878
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002879 fp = fdopen(fd, mode);
Victor Stinner35734762011-12-18 21:05:22 +01002880 if (!fp) {
2881 PyErr_SetFromErrno(PyExc_IOError);
2882 return NULL;
2883 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002884 return fp;
Victor Stinner35734762011-12-18 21:05:22 +01002885 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002886}
2887
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002888#ifdef HAVE_DYNAMIC_LOADING
2889
Guido van Rossum79f25d91997-04-29 20:08:16 +00002890static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002891imp_load_dynamic(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002892{
Victor Stinnerfefd70c2011-03-14 15:54:07 -04002893 PyObject *name, *pathname, *fob = NULL, *mod;
2894 FILE *fp;
2895
2896 if (!PyArg_ParseTuple(args, "UO&|O:load_dynamic",
2897 &name, PyUnicode_FSDecoder, &pathname, &fob))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002898 return NULL;
Victor Stinnerfefd70c2011-03-14 15:54:07 -04002899 if (fob != NULL) {
2900 fp = get_file(NULL, fob, "r");
Victor Stinnere9ddbf62011-03-22 10:46:35 +01002901 if (fp == NULL) {
2902 Py_DECREF(pathname);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002903 return NULL;
Victor Stinnere9ddbf62011-03-22 10:46:35 +01002904 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002905 }
Victor Stinnerfefd70c2011-03-14 15:54:07 -04002906 else
2907 fp = NULL;
2908 mod = _PyImport_LoadDynamicModule(name, pathname, fp);
Victor Stinnere9ddbf62011-03-22 10:46:35 +01002909 Py_DECREF(pathname);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002910 if (fp)
2911 fclose(fp);
Victor Stinnerfefd70c2011-03-14 15:54:07 -04002912 return mod;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002913}
2914
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002915#endif /* HAVE_DYNAMIC_LOADING */
2916
Guido van Rossum79f25d91997-04-29 20:08:16 +00002917static PyObject *
Christian Heimes13a7a212008-01-07 17:13:09 +00002918imp_reload(PyObject *self, PyObject *v)
2919{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002920 return PyImport_ReloadModule(v);
Christian Heimes13a7a212008-01-07 17:13:09 +00002921}
2922
2923PyDoc_STRVAR(doc_reload,
2924"reload(module) -> module\n\
2925\n\
2926Reload the module. The module must have been successfully imported before.");
2927
Barry Warsaw28a691b2010-04-17 00:19:56 +00002928
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002929/* Doc strings */
2930
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002931PyDoc_STRVAR(doc_imp,
Brett Cannon6f44d662012-04-15 16:08:47 -04002932"(Extremely) low-level import machinery bits as used by importlib and imp.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002933
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002934PyDoc_STRVAR(doc_find_module,
2935"find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002936Search for a module. If path is omitted or None, search for a\n\
2937built-in, frozen or special module and continue search in sys.path.\n\
2938The module name cannot contain '.'; to search for a submodule of a\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002939package, pass the submodule name and the package's __path__.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002940
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002941PyDoc_STRVAR(doc_get_magic,
2942"get_magic() -> string\n\
2943Return the magic number for .pyc or .pyo files.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002944
Barry Warsaw28a691b2010-04-17 00:19:56 +00002945PyDoc_STRVAR(doc_get_tag,
2946"get_tag() -> string\n\
2947Return the magic tag for .pyc or .pyo files.");
2948
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002949PyDoc_STRVAR(doc_get_suffixes,
2950"get_suffixes() -> [(suffix, mode, type), ...]\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002951Return a list of (suffix, mode, type) tuples describing the files\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002952that find_module() looks for.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002953
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002954PyDoc_STRVAR(doc_lock_held,
Tim Petersa7c65092004-08-01 23:26:05 +00002955"lock_held() -> boolean\n\
2956Return True if the import lock is currently held, else False.\n\
2957On platforms without threads, return False.");
Tim Peters69232342001-08-30 05:16:13 +00002958
Guido van Rossumc4f4ca92003-02-12 21:46:11 +00002959PyDoc_STRVAR(doc_acquire_lock,
2960"acquire_lock() -> None\n\
Neal Norwitz2294c0d2003-02-12 23:02:21 +00002961Acquires the interpreter's import lock for the current thread.\n\
2962This lock should be used by import hooks to ensure thread-safety\n\
2963when importing modules.\n\
Guido van Rossumc4f4ca92003-02-12 21:46:11 +00002964On platforms without threads, this function does nothing.");
2965
2966PyDoc_STRVAR(doc_release_lock,
2967"release_lock() -> None\n\
2968Release the interpreter's import lock.\n\
2969On platforms without threads, this function does nothing.");
2970
Guido van Rossum79f25d91997-04-29 20:08:16 +00002971static PyMethodDef imp_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002972 {"find_module", imp_find_module, METH_VARARGS, doc_find_module},
2973 {"get_magic", imp_get_magic, METH_NOARGS, doc_get_magic},
2974 {"get_tag", imp_get_tag, METH_NOARGS, doc_get_tag},
2975 {"get_suffixes", imp_get_suffixes, METH_NOARGS, doc_get_suffixes},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002976 {"lock_held", imp_lock_held, METH_NOARGS, doc_lock_held},
2977 {"acquire_lock", imp_acquire_lock, METH_NOARGS, doc_acquire_lock},
2978 {"release_lock", imp_release_lock, METH_NOARGS, doc_release_lock},
2979 {"reload", imp_reload, METH_O, doc_reload},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002980 {"get_frozen_object", imp_get_frozen_object, METH_VARARGS},
2981 {"is_frozen_package", imp_is_frozen_package, METH_VARARGS},
2982 {"init_builtin", imp_init_builtin, METH_VARARGS},
2983 {"init_frozen", imp_init_frozen, METH_VARARGS},
2984 {"is_builtin", imp_is_builtin, METH_VARARGS},
2985 {"is_frozen", imp_is_frozen, METH_VARARGS},
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002986#ifdef HAVE_DYNAMIC_LOADING
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002987 {"load_dynamic", imp_load_dynamic, METH_VARARGS},
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002988#endif
Brett Cannon442c9b92011-03-23 16:14:42 -07002989 {"_fix_co_filename", imp_fix_co_filename, METH_VARARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002990 {NULL, NULL} /* sentinel */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002991};
2992
Guido van Rossum1a8791e1998-08-04 22:46:29 +00002993static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002994setint(PyObject *d, char *name, int value)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002995{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002996 PyObject *v;
2997 int err;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002998
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002999 v = PyLong_FromLong((long)value);
3000 err = PyDict_SetItemString(d, name, v);
3001 Py_XDECREF(v);
3002 return err;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003003}
3004
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003005typedef struct {
3006 PyObject_HEAD
3007} NullImporter;
3008
3009static int
3010NullImporter_init(NullImporter *self, PyObject *args, PyObject *kwds)
3011{
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003012#ifndef MS_WINDOWS
3013 PyObject *path;
3014 struct stat statbuf;
3015 int rv;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003016
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003017 if (!_PyArg_NoKeywords("NullImporter()", kwds))
3018 return -1;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003019
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003020 if (!PyArg_ParseTuple(args, "O&:NullImporter",
3021 PyUnicode_FSConverter, &path))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003022 return -1;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003023
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003024 if (PyBytes_GET_SIZE(path) == 0) {
3025 Py_DECREF(path);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003026 PyErr_SetString(PyExc_ImportError, "empty pathname");
3027 return -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003028 }
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003029
3030 rv = stat(PyBytes_AS_STRING(path), &statbuf);
3031 Py_DECREF(path);
3032 if (rv == 0) {
3033 /* it exists */
3034 if (S_ISDIR(statbuf.st_mode)) {
3035 /* it's a directory */
3036 PyErr_SetString(PyExc_ImportError, "existing directory");
3037 return -1;
3038 }
3039 }
3040#else /* MS_WINDOWS */
3041 PyObject *pathobj;
3042 DWORD rv;
Victor Stinner255dfdb2010-09-29 10:28:51 +00003043 wchar_t *path;
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003044
3045 if (!_PyArg_NoKeywords("NullImporter()", kwds))
3046 return -1;
3047
3048 if (!PyArg_ParseTuple(args, "U:NullImporter",
3049 &pathobj))
3050 return -1;
3051
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02003052 if (PyUnicode_GET_LENGTH(pathobj) == 0) {
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003053 PyErr_SetString(PyExc_ImportError, "empty pathname");
3054 return -1;
3055 }
3056
Victor Stinnerbeb4135b2010-10-07 01:02:42 +00003057 path = PyUnicode_AsWideCharString(pathobj, NULL);
Victor Stinner255dfdb2010-09-29 10:28:51 +00003058 if (path == NULL)
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003059 return -1;
3060 /* see issue1293 and issue3677:
3061 * stat() on Windows doesn't recognise paths like
3062 * "e:\\shared\\" and "\\\\whiterab-c2znlh\\shared" as dirs.
3063 */
3064 rv = GetFileAttributesW(path);
Victor Stinner255dfdb2010-09-29 10:28:51 +00003065 PyMem_Free(path);
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003066 if (rv != INVALID_FILE_ATTRIBUTES) {
3067 /* it exists */
3068 if (rv & FILE_ATTRIBUTE_DIRECTORY) {
3069 /* it's a directory */
3070 PyErr_SetString(PyExc_ImportError, "existing directory");
3071 return -1;
3072 }
3073 }
3074#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003075 return 0;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003076}
3077
3078static PyObject *
3079NullImporter_find_module(NullImporter *self, PyObject *args)
3080{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003081 Py_RETURN_NONE;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003082}
3083
3084static PyMethodDef NullImporter_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003085 {"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,
3086 "Always return None"
3087 },
3088 {NULL} /* Sentinel */
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003089};
3090
3091
Christian Heimes9cd17752007-11-18 19:35:23 +00003092PyTypeObject PyNullImporter_Type = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003093 PyVarObject_HEAD_INIT(NULL, 0)
3094 "imp.NullImporter", /*tp_name*/
3095 sizeof(NullImporter), /*tp_basicsize*/
3096 0, /*tp_itemsize*/
3097 0, /*tp_dealloc*/
3098 0, /*tp_print*/
3099 0, /*tp_getattr*/
3100 0, /*tp_setattr*/
3101 0, /*tp_reserved*/
3102 0, /*tp_repr*/
3103 0, /*tp_as_number*/
3104 0, /*tp_as_sequence*/
3105 0, /*tp_as_mapping*/
3106 0, /*tp_hash */
3107 0, /*tp_call*/
3108 0, /*tp_str*/
3109 0, /*tp_getattro*/
3110 0, /*tp_setattro*/
3111 0, /*tp_as_buffer*/
3112 Py_TPFLAGS_DEFAULT, /*tp_flags*/
3113 "Null importer object", /* tp_doc */
3114 0, /* tp_traverse */
3115 0, /* tp_clear */
3116 0, /* tp_richcompare */
3117 0, /* tp_weaklistoffset */
3118 0, /* tp_iter */
3119 0, /* tp_iternext */
3120 NullImporter_methods, /* tp_methods */
3121 0, /* tp_members */
3122 0, /* tp_getset */
3123 0, /* tp_base */
3124 0, /* tp_dict */
3125 0, /* tp_descr_get */
3126 0, /* tp_descr_set */
3127 0, /* tp_dictoffset */
3128 (initproc)NullImporter_init, /* tp_init */
3129 0, /* tp_alloc */
3130 PyType_GenericNew /* tp_new */
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003131};
3132
Martin v. Löwis1a214512008-06-11 05:26:20 +00003133static struct PyModuleDef impmodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003134 PyModuleDef_HEAD_INIT,
Brett Cannon6f44d662012-04-15 16:08:47 -04003135 "_imp",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003136 doc_imp,
3137 0,
3138 imp_methods,
3139 NULL,
3140 NULL,
3141 NULL,
3142 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +00003143};
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003144
Jason Tishler6bc06ec2003-09-04 11:59:50 +00003145PyMODINIT_FUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +00003146PyInit_imp(void)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003147{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003148 PyObject *m, *d;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003149
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003150 if (PyType_Ready(&PyNullImporter_Type) < 0)
3151 return NULL;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003152
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003153 m = PyModule_Create(&impmodule);
3154 if (m == NULL)
3155 goto failure;
3156 d = PyModule_GetDict(m);
3157 if (d == NULL)
3158 goto failure;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003159
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003160 if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;
3161 if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;
3162 if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;
3163 if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;
3164 if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;
3165 if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;
3166 if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;
3167 if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;
3168 if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;
3169 if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003170
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003171 Py_INCREF(&PyNullImporter_Type);
3172 PyModule_AddObject(m, "NullImporter", (PyObject *)&PyNullImporter_Type);
3173 return m;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003174 failure:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003175 Py_XDECREF(m);
3176 return NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003177}
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003178
3179
Guido van Rossumb18618d2000-05-03 23:44:39 +00003180/* API for embedding applications that want to add their own entries
3181 to the table of built-in modules. This should normally be called
3182 *before* Py_Initialize(). When the table resize fails, -1 is
3183 returned and the existing table is unchanged.
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003184
3185 After a similar function by Just van Rossum. */
3186
3187int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003188PyImport_ExtendInittab(struct _inittab *newtab)
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003189{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003190 static struct _inittab *our_copy = NULL;
3191 struct _inittab *p;
3192 int i, n;
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003193
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003194 /* Count the number of entries in both tables */
3195 for (n = 0; newtab[n].name != NULL; n++)
3196 ;
3197 if (n == 0)
3198 return 0; /* Nothing to do */
3199 for (i = 0; PyImport_Inittab[i].name != NULL; i++)
3200 ;
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003201
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003202 /* Allocate new memory for the combined table */
3203 p = our_copy;
3204 PyMem_RESIZE(p, struct _inittab, i+n+1);
3205 if (p == NULL)
3206 return -1;
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003207
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003208 /* Copy the tables into the new memory */
3209 if (our_copy != PyImport_Inittab)
3210 memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
3211 PyImport_Inittab = our_copy = p;
3212 memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003213
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003214 return 0;
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003215}
3216
3217/* Shorthand to add a single entry given a name and a function */
3218
3219int
Brett Cannona826f322009-04-02 03:41:46 +00003220PyImport_AppendInittab(const char *name, PyObject* (*initfunc)(void))
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003221{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003222 struct _inittab newtab[2];
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003223
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003224 memset(newtab, '\0', sizeof newtab);
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003225
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003226 newtab[0].name = (char *)name;
3227 newtab[0].initfunc = initfunc;
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003228
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003229 return PyImport_ExtendInittab(newtab);
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003230}
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00003231
3232#ifdef __cplusplus
3233}
3234#endif