blob: 93defeff7fb41bf5d755ebadf3d6479143f03aba [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)
Tim Peters36515e22001-11-18 04:06:29 +0000105*/
Guido van Rossum3ddee711991-12-16 13:06:34 +0000106
Nick Coghlancd419ab2010-09-11 00:39:25 +0000107/* MAGIC must change whenever the bytecode emitted by the compiler may no
108 longer be understood by older implementations of the eval loop (usually
109 due to the addition of new opcodes)
110 TAG must change for each major Python release. The magic number will take
111 care of any bytecode changes that occur during development.
Barry Warsaw28a691b2010-04-17 00:19:56 +0000112*/
Benjamin Peterson6246d6d2010-09-10 21:51:44 +0000113#define MAGIC (3180 | ((long)'\r'<<16) | ((long)'\n'<<24))
Barry Warsaw28a691b2010-04-17 00:19:56 +0000114#define TAG "cpython-32"
115#define CACHEDIR "__pycache__"
116/* Current magic word and string tag as globals. */
Guido van Rossum96774c12000-05-01 20:19:08 +0000117static long pyc_magic = MAGIC;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000118static const char *pyc_tag = TAG;
Guido van Rossum96774c12000-05-01 20:19:08 +0000119
Victor Stinner49d3f252010-10-17 01:24:53 +0000120/* See _PyImport_FixupExtensionUnicode() below */
Guido van Rossum25ce5661997-08-02 03:10:38 +0000121static PyObject *extensions = NULL;
Guido van Rossum3f5da241990-12-20 15:06:42 +0000122
Guido van Rossum771c6c81997-10-31 18:37:24 +0000123/* This table is defined in config.c: */
124extern struct _inittab _PyImport_Inittab[];
125
Guido van Rossumce3a72a2007-10-19 23:16:50 +0000126/* Method from Parser/tokenizer.c */
Guido van Rossum40d20bc2007-10-22 00:09:51 +0000127extern char * PyTokenizer_FindEncoding(int);
Guido van Rossumce3a72a2007-10-19 23:16:50 +0000128
Guido van Rossum771c6c81997-10-31 18:37:24 +0000129struct _inittab *PyImport_Inittab = _PyImport_Inittab;
Guido van Rossum66f1fa81991-04-03 19:03:52 +0000130
Guido van Rossumed1170e1999-12-20 21:23:41 +0000131/* these tables define the module suffixes that Python recognizes */
132struct filedescr * _PyImport_Filetab = NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000133
Guido van Rossumed1170e1999-12-20 21:23:41 +0000134static const struct filedescr _PyImport_StandardFiletab[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000135 {".py", "U", PY_SOURCE},
Martin v. Löwis6238d2b2002-06-30 15:26:10 +0000136#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000137 {".pyw", "U", PY_SOURCE},
Tim Peters36515e22001-11-18 04:06:29 +0000138#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000139 {".pyc", "rb", PY_COMPILED},
140 {0, 0}
Guido van Rossumed1170e1999-12-20 21:23:41 +0000141};
142
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000143
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000144/* Initialize things */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000145
146void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000147_PyImport_Init(void)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000148{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000149 const struct filedescr *scan;
150 struct filedescr *filetab;
151 int countD = 0;
152 int countS = 0;
Guido van Rossumed1170e1999-12-20 21:23:41 +0000153
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000154 /* prepare _PyImport_Filetab: copy entries from
155 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
156 */
Guido van Rossum04110fb2007-08-24 16:32:05 +0000157#ifdef HAVE_DYNAMIC_LOADING
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000158 for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)
159 ++countD;
Guido van Rossum04110fb2007-08-24 16:32:05 +0000160#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000161 for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
162 ++countS;
163 filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
164 if (filetab == NULL)
165 Py_FatalError("Can't initialize import file table.");
Guido van Rossum04110fb2007-08-24 16:32:05 +0000166#ifdef HAVE_DYNAMIC_LOADING
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000167 memcpy(filetab, _PyImport_DynLoadFiletab,
168 countD * sizeof(struct filedescr));
Guido van Rossum04110fb2007-08-24 16:32:05 +0000169#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000170 memcpy(filetab + countD, _PyImport_StandardFiletab,
171 countS * sizeof(struct filedescr));
172 filetab[countD + countS].suffix = NULL;
Guido van Rossumed1170e1999-12-20 21:23:41 +0000173
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000174 _PyImport_Filetab = filetab;
Guido van Rossumed1170e1999-12-20 21:23:41 +0000175
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000176 if (Py_OptimizeFlag) {
177 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
178 for (; filetab->suffix != NULL; filetab++) {
179 if (strcmp(filetab->suffix, ".pyc") == 0)
180 filetab->suffix = ".pyo";
181 }
182 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000183}
184
Guido van Rossum25ce5661997-08-02 03:10:38 +0000185void
Just van Rossum52e14d62002-12-30 22:08:05 +0000186_PyImportHooks_Init(void)
187{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000188 PyObject *v, *path_hooks = NULL, *zimpimport;
189 int err = 0;
Just van Rossum52e14d62002-12-30 22:08:05 +0000190
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000191 /* adding sys.path_hooks and sys.path_importer_cache, setting up
192 zipimport */
193 if (PyType_Ready(&PyNullImporter_Type) < 0)
194 goto error;
Just van Rossum52e14d62002-12-30 22:08:05 +0000195
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000196 if (Py_VerboseFlag)
197 PySys_WriteStderr("# installing zipimport hook\n");
Just van Rossum52e14d62002-12-30 22:08:05 +0000198
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000199 v = PyList_New(0);
200 if (v == NULL)
201 goto error;
202 err = PySys_SetObject("meta_path", v);
203 Py_DECREF(v);
204 if (err)
205 goto error;
206 v = PyDict_New();
207 if (v == NULL)
208 goto error;
209 err = PySys_SetObject("path_importer_cache", v);
210 Py_DECREF(v);
211 if (err)
212 goto error;
213 path_hooks = PyList_New(0);
214 if (path_hooks == NULL)
215 goto error;
216 err = PySys_SetObject("path_hooks", path_hooks);
217 if (err) {
Just van Rossum52e14d62002-12-30 22:08:05 +0000218 error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000219 PyErr_Print();
220 Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
221 "path_importer_cache, or NullImporter failed"
222 );
223 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000224
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000225 zimpimport = PyImport_ImportModule("zipimport");
226 if (zimpimport == NULL) {
227 PyErr_Clear(); /* No zip import module -- okay */
228 if (Py_VerboseFlag)
229 PySys_WriteStderr("# can't import zipimport\n");
230 }
231 else {
232 PyObject *zipimporter = PyObject_GetAttrString(zimpimport,
233 "zipimporter");
234 Py_DECREF(zimpimport);
235 if (zipimporter == NULL) {
236 PyErr_Clear(); /* No zipimporter object -- okay */
237 if (Py_VerboseFlag)
238 PySys_WriteStderr(
239 "# can't import zipimport.zipimporter\n");
240 }
241 else {
242 /* sys.path_hooks.append(zipimporter) */
243 err = PyList_Append(path_hooks, zipimporter);
244 Py_DECREF(zipimporter);
245 if (err)
246 goto error;
247 if (Py_VerboseFlag)
248 PySys_WriteStderr(
249 "# installed zipimport hook\n");
250 }
251 }
252 Py_DECREF(path_hooks);
Just van Rossum52e14d62002-12-30 22:08:05 +0000253}
254
255void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000256_PyImport_Fini(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000257{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000258 Py_XDECREF(extensions);
259 extensions = NULL;
260 PyMem_DEL(_PyImport_Filetab);
261 _PyImport_Filetab = NULL;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000262}
263
264
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000265/* Locking primitives to prevent parallel imports of the same module
266 in different threads to return with a partially loaded module.
267 These calls are serialized by the global interpreter lock. */
268
269#ifdef WITH_THREAD
270
Guido van Rossum49b56061998-10-01 20:42:43 +0000271#include "pythread.h"
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000272
Guido van Rossum65d5b571998-12-21 19:32:43 +0000273static PyThread_type_lock import_lock = 0;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000274static long import_lock_thread = -1;
275static int import_lock_level = 0;
276
Benjamin Peterson0df35a92009-10-04 20:32:25 +0000277void
278_PyImport_AcquireLock(void)
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000279{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000280 long me = PyThread_get_thread_ident();
281 if (me == -1)
282 return; /* Too bad */
283 if (import_lock == NULL) {
284 import_lock = PyThread_allocate_lock();
285 if (import_lock == NULL)
286 return; /* Nothing much we can do. */
287 }
288 if (import_lock_thread == me) {
289 import_lock_level++;
290 return;
291 }
292 if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
293 {
294 PyThreadState *tstate = PyEval_SaveThread();
295 PyThread_acquire_lock(import_lock, 1);
296 PyEval_RestoreThread(tstate);
297 }
298 import_lock_thread = me;
299 import_lock_level = 1;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000300}
301
Benjamin Peterson0df35a92009-10-04 20:32:25 +0000302int
303_PyImport_ReleaseLock(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 || import_lock == NULL)
307 return 0; /* Too bad */
308 if (import_lock_thread != me)
309 return -1;
310 import_lock_level--;
311 if (import_lock_level == 0) {
312 import_lock_thread = -1;
313 PyThread_release_lock(import_lock);
314 }
315 return 1;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000316}
317
Gregory P. Smith24cec9f2010-03-01 06:18:41 +0000318/* This function is called from PyOS_AfterFork to ensure that newly
319 created child processes do not share locks with the parent.
320 We now acquire the import lock around fork() calls but on some platforms
321 (Solaris 9 and earlier? see isue7242) that still left us with problems. */
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +0000322
323void
324_PyImport_ReInitLock(void)
325{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000326 if (import_lock != NULL)
327 import_lock = PyThread_allocate_lock();
Nick Coghlanb2ddf792010-12-02 04:11:46 +0000328 if (import_lock_level > 1) {
329 /* Forked as a side effect of import */
330 long me = PyThread_get_thread_ident();
331 PyThread_acquire_lock(import_lock, 0);
332 /* XXX: can the previous line fail? */
333 import_lock_thread = me;
334 import_lock_level--;
335 } else {
336 import_lock_thread = -1;
337 import_lock_level = 0;
338 }
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +0000339}
340
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000341#endif
342
Tim Peters69232342001-08-30 05:16:13 +0000343static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000344imp_lock_held(PyObject *self, PyObject *noargs)
Tim Peters69232342001-08-30 05:16:13 +0000345{
Tim Peters69232342001-08-30 05:16:13 +0000346#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000347 return PyBool_FromLong(import_lock_thread != -1);
Tim Peters69232342001-08-30 05:16:13 +0000348#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000349 return PyBool_FromLong(0);
Tim Peters69232342001-08-30 05:16:13 +0000350#endif
351}
352
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000353static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000354imp_acquire_lock(PyObject *self, PyObject *noargs)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000355{
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000356#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000357 _PyImport_AcquireLock();
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000358#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000359 Py_INCREF(Py_None);
360 return Py_None;
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000361}
362
363static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000364imp_release_lock(PyObject *self, PyObject *noargs)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000365{
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000366#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000367 if (_PyImport_ReleaseLock() < 0) {
368 PyErr_SetString(PyExc_RuntimeError,
369 "not holding the import lock");
370 return NULL;
371 }
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000372#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000373 Py_INCREF(Py_None);
374 return Py_None;
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000375}
376
Guido van Rossumd8faa362007-04-27 19:54:29 +0000377static void
378imp_modules_reloading_clear(void)
379{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000380 PyInterpreterState *interp = PyThreadState_Get()->interp;
381 if (interp->modules_reloading != NULL)
382 PyDict_Clear(interp->modules_reloading);
Guido van Rossumd8faa362007-04-27 19:54:29 +0000383}
384
Guido van Rossum25ce5661997-08-02 03:10:38 +0000385/* Helper for sys */
386
387PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000388PyImport_GetModuleDict(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000389{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000390 PyInterpreterState *interp = PyThreadState_GET()->interp;
391 if (interp->modules == NULL)
392 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
393 return interp->modules;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000394}
395
Guido van Rossum3f5da241990-12-20 15:06:42 +0000396
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000397/* List of names to clear in sys */
398static char* sys_deletes[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000399 "path", "argv", "ps1", "ps2",
400 "last_type", "last_value", "last_traceback",
401 "path_hooks", "path_importer_cache", "meta_path",
402 /* misc stuff */
403 "flags", "float_info",
404 NULL
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000405};
406
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000407static char* sys_files[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000408 "stdin", "__stdin__",
409 "stdout", "__stdout__",
410 "stderr", "__stderr__",
411 NULL
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000412};
413
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000414
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000415/* Un-initialize things, as good as we can */
Guido van Rossum3f5da241990-12-20 15:06:42 +0000416
Guido van Rossum3f5da241990-12-20 15:06:42 +0000417void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000418PyImport_Cleanup(void)
Guido van Rossum3f5da241990-12-20 15:06:42 +0000419{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000420 Py_ssize_t pos, ndone;
421 char *name;
422 PyObject *key, *value, *dict;
423 PyInterpreterState *interp = PyThreadState_GET()->interp;
424 PyObject *modules = interp->modules;
Guido van Rossum758eec01998-01-19 21:58:26 +0000425
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000426 if (modules == NULL)
427 return; /* Already done */
Guido van Rossum758eec01998-01-19 21:58:26 +0000428
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000429 /* Delete some special variables first. These are common
430 places where user values hide and people complain when their
431 destructors fail. Since the modules containing them are
432 deleted *last* of all, they would come too late in the normal
433 destruction order. Sigh. */
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000434
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000435 value = PyDict_GetItemString(modules, "builtins");
436 if (value != NULL && PyModule_Check(value)) {
437 dict = PyModule_GetDict(value);
438 if (Py_VerboseFlag)
439 PySys_WriteStderr("# clear builtins._\n");
440 PyDict_SetItemString(dict, "_", Py_None);
441 }
442 value = PyDict_GetItemString(modules, "sys");
443 if (value != NULL && PyModule_Check(value)) {
444 char **p;
445 PyObject *v;
446 dict = PyModule_GetDict(value);
447 for (p = sys_deletes; *p != NULL; p++) {
448 if (Py_VerboseFlag)
449 PySys_WriteStderr("# clear sys.%s\n", *p);
450 PyDict_SetItemString(dict, *p, Py_None);
451 }
452 for (p = sys_files; *p != NULL; p+=2) {
453 if (Py_VerboseFlag)
454 PySys_WriteStderr("# restore sys.%s\n", *p);
455 v = PyDict_GetItemString(dict, *(p+1));
456 if (v == NULL)
457 v = Py_None;
458 PyDict_SetItemString(dict, *p, v);
459 }
460 }
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000461
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000462 /* First, delete __main__ */
463 value = PyDict_GetItemString(modules, "__main__");
464 if (value != NULL && PyModule_Check(value)) {
465 if (Py_VerboseFlag)
466 PySys_WriteStderr("# cleanup __main__\n");
467 _PyModule_Clear(value);
468 PyDict_SetItemString(modules, "__main__", Py_None);
469 }
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000470
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000471 /* The special treatment of "builtins" here is because even
472 when it's not referenced as a module, its dictionary is
473 referenced by almost every module's __builtins__. Since
474 deleting a module clears its dictionary (even if there are
475 references left to it), we need to delete the "builtins"
476 module last. Likewise, we don't delete sys until the very
477 end because it is implicitly referenced (e.g. by print).
Guido van Rossum758eec01998-01-19 21:58:26 +0000478
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000479 Also note that we 'delete' modules by replacing their entry
480 in the modules dict with None, rather than really deleting
481 them; this avoids a rehash of the modules dictionary and
482 also marks them as "non existent" so they won't be
483 re-imported. */
Guido van Rossum758eec01998-01-19 21:58:26 +0000484
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000485 /* Next, repeatedly delete modules with a reference count of
486 one (skipping builtins and sys) and delete them */
487 do {
488 ndone = 0;
489 pos = 0;
490 while (PyDict_Next(modules, &pos, &key, &value)) {
491 if (value->ob_refcnt != 1)
492 continue;
493 if (PyUnicode_Check(key) && PyModule_Check(value)) {
494 name = _PyUnicode_AsString(key);
495 if (strcmp(name, "builtins") == 0)
496 continue;
497 if (strcmp(name, "sys") == 0)
498 continue;
499 if (Py_VerboseFlag)
500 PySys_WriteStderr(
501 "# cleanup[1] %s\n", name);
502 _PyModule_Clear(value);
503 PyDict_SetItem(modules, key, Py_None);
504 ndone++;
505 }
506 }
507 } while (ndone > 0);
Guido van Rossum758eec01998-01-19 21:58:26 +0000508
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000509 /* Next, delete all modules (still skipping builtins and sys) */
510 pos = 0;
511 while (PyDict_Next(modules, &pos, &key, &value)) {
512 if (PyUnicode_Check(key) && PyModule_Check(value)) {
513 name = _PyUnicode_AsString(key);
514 if (strcmp(name, "builtins") == 0)
515 continue;
516 if (strcmp(name, "sys") == 0)
517 continue;
518 if (Py_VerboseFlag)
519 PySys_WriteStderr("# cleanup[2] %s\n", name);
520 _PyModule_Clear(value);
521 PyDict_SetItem(modules, key, Py_None);
522 }
523 }
Guido van Rossum758eec01998-01-19 21:58:26 +0000524
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000525 /* Next, delete sys and builtins (in that order) */
526 value = PyDict_GetItemString(modules, "sys");
527 if (value != NULL && PyModule_Check(value)) {
528 if (Py_VerboseFlag)
529 PySys_WriteStderr("# cleanup sys\n");
530 _PyModule_Clear(value);
531 PyDict_SetItemString(modules, "sys", Py_None);
532 }
533 value = PyDict_GetItemString(modules, "builtins");
534 if (value != NULL && PyModule_Check(value)) {
535 if (Py_VerboseFlag)
536 PySys_WriteStderr("# cleanup builtins\n");
537 _PyModule_Clear(value);
538 PyDict_SetItemString(modules, "builtins", Py_None);
539 }
Guido van Rossum758eec01998-01-19 21:58:26 +0000540
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000541 /* Finally, clear and delete the modules directory */
542 PyDict_Clear(modules);
543 interp->modules = NULL;
544 Py_DECREF(modules);
545 Py_CLEAR(interp->modules_reloading);
Guido van Rossum8d15b5d1990-10-26 14:58:58 +0000546}
Guido van Rossum7f133ed1991-02-19 12:23:57 +0000547
548
Barry Warsaw28a691b2010-04-17 00:19:56 +0000549/* Helper for pythonrun.c -- return magic number and tag. */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000550
551long
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000552PyImport_GetMagicNumber(void)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000553{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000554 return pyc_magic;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000555}
556
557
Barry Warsaw28a691b2010-04-17 00:19:56 +0000558const char *
559PyImport_GetMagicTag(void)
560{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000561 return pyc_tag;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000562}
563
Guido van Rossum25ce5661997-08-02 03:10:38 +0000564/* Magic for extension modules (built-in as well as dynamically
565 loaded). To prevent initializing an extension module more than
566 once, we keep a static dictionary 'extensions' keyed by module name
567 (for built-in modules) or by filename (for dynamically loaded
Barry Warsaw92883382001-08-13 23:05:44 +0000568 modules), containing these modules. A copy of the module's
Victor Stinner49d3f252010-10-17 01:24:53 +0000569 dictionary is stored by calling _PyImport_FixupExtensionUnicode()
Guido van Rossum25ce5661997-08-02 03:10:38 +0000570 immediately after the module initialization function succeeds. A
571 copy can be retrieved from there by calling
Victor Stinner49d3f252010-10-17 01:24:53 +0000572 _PyImport_FindExtensionUnicode().
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000573
Barry Warsaw7c9627b2010-06-17 18:38:20 +0000574 Modules which do support multiple initialization set their m_size
575 field to a non-negative number (indicating the size of the
576 module-specific state). They are still recorded in the extensions
577 dictionary, to avoid loading shared libraries twice.
Martin v. Löwis1a214512008-06-11 05:26:20 +0000578*/
579
580int
Victor Stinner49d3f252010-10-17 01:24:53 +0000581_PyImport_FixupExtensionUnicode(PyObject *mod, char *name, PyObject *filename)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000582{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000583 PyObject *modules, *dict;
584 struct PyModuleDef *def;
585 if (extensions == NULL) {
586 extensions = PyDict_New();
587 if (extensions == NULL)
588 return -1;
589 }
590 if (mod == NULL || !PyModule_Check(mod)) {
591 PyErr_BadInternalCall();
592 return -1;
593 }
594 def = PyModule_GetDef(mod);
595 if (!def) {
596 PyErr_BadInternalCall();
597 return -1;
598 }
599 modules = PyImport_GetModuleDict();
600 if (PyDict_SetItemString(modules, name, mod) < 0)
601 return -1;
602 if (_PyState_AddModule(mod, def) < 0) {
603 PyDict_DelItemString(modules, name);
604 return -1;
605 }
606 if (def->m_size == -1) {
607 if (def->m_base.m_copy) {
608 /* Somebody already imported the module,
609 likely under a different name.
610 XXX this should really not happen. */
611 Py_DECREF(def->m_base.m_copy);
612 def->m_base.m_copy = NULL;
613 }
614 dict = PyModule_GetDict(mod);
615 if (dict == NULL)
616 return -1;
617 def->m_base.m_copy = PyDict_Copy(dict);
618 if (def->m_base.m_copy == NULL)
619 return -1;
620 }
Victor Stinner49d3f252010-10-17 01:24:53 +0000621 PyDict_SetItem(extensions, filename, (PyObject*)def);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000622 return 0;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000623}
624
Victor Stinner49d3f252010-10-17 01:24:53 +0000625int
626_PyImport_FixupBuiltin(PyObject *mod, char *name)
627{
628 int res;
629 PyObject *filename;
630 filename = PyUnicode_FromString(name);
631 if (filename == NULL)
632 return -1;
633 res = _PyImport_FixupExtensionUnicode(mod, name, filename);
634 Py_DECREF(filename);
635 return res;
636}
637
Guido van Rossum25ce5661997-08-02 03:10:38 +0000638PyObject *
Victor Stinner49d3f252010-10-17 01:24:53 +0000639_PyImport_FindExtensionUnicode(char *name, PyObject *filename)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000640{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000641 PyObject *mod, *mdict;
642 PyModuleDef* def;
643 if (extensions == NULL)
644 return NULL;
Victor Stinner49d3f252010-10-17 01:24:53 +0000645 def = (PyModuleDef*)PyDict_GetItem(extensions, filename);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000646 if (def == NULL)
647 return NULL;
648 if (def->m_size == -1) {
649 /* Module does not support repeated initialization */
650 if (def->m_base.m_copy == NULL)
651 return NULL;
652 mod = PyImport_AddModule(name);
653 if (mod == NULL)
654 return NULL;
655 mdict = PyModule_GetDict(mod);
656 if (mdict == NULL)
657 return NULL;
658 if (PyDict_Update(mdict, def->m_base.m_copy))
659 return NULL;
660 }
661 else {
662 if (def->m_base.m_init == NULL)
663 return NULL;
664 mod = def->m_base.m_init();
665 if (mod == NULL)
666 return NULL;
667 PyDict_SetItemString(PyImport_GetModuleDict(), name, mod);
668 Py_DECREF(mod);
669 }
670 if (_PyState_AddModule(mod, def) < 0) {
671 PyDict_DelItemString(PyImport_GetModuleDict(), name);
672 Py_DECREF(mod);
673 return NULL;
674 }
675 if (Py_VerboseFlag)
Victor Stinner49d3f252010-10-17 01:24:53 +0000676 PySys_FormatStderr("import %s # previously loaded (%U)\n",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000677 name, filename);
678 return mod;
Brett Cannon9a5b25a2010-03-01 02:09:17 +0000679
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000680}
681
Victor Stinner49d3f252010-10-17 01:24:53 +0000682PyObject *
683_PyImport_FindBuiltin(char *name)
684{
685 PyObject *res, *filename;
686 filename = PyUnicode_FromString(name);
687 if (filename == NULL)
688 return NULL;
689 res = _PyImport_FindExtensionUnicode(name, filename);
690 Py_DECREF(filename);
691 return res;
692}
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000693
694/* Get the module object corresponding to a module name.
695 First check the modules dictionary if there's one there,
Walter Dörwaldf0dfc7a2003-10-20 14:01:56 +0000696 if not, create a new one and insert it in the modules dictionary.
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000697 Because the former action is most common, THIS DOES NOT RETURN A
698 'NEW' REFERENCE! */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000699
Guido van Rossum79f25d91997-04-29 20:08:16 +0000700PyObject *
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000701PyImport_AddModule(const char *name)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000702{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000703 PyObject *modules = PyImport_GetModuleDict();
704 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000705
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000706 if ((m = PyDict_GetItemString(modules, name)) != NULL &&
707 PyModule_Check(m))
708 return m;
709 m = PyModule_New(name);
710 if (m == NULL)
711 return NULL;
712 if (PyDict_SetItemString(modules, name, m) != 0) {
713 Py_DECREF(m);
714 return NULL;
715 }
716 Py_DECREF(m); /* Yes, it still exists, in modules! */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000717
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000718 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000719}
720
Tim Peters1cd70172004-08-02 03:52:12 +0000721/* Remove name from sys.modules, if it's there. */
722static void
Benjamin Petersonfa0aeba2010-03-25 23:30:20 +0000723remove_module(const char *name)
Tim Peters1cd70172004-08-02 03:52:12 +0000724{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000725 PyObject *modules = PyImport_GetModuleDict();
726 if (PyDict_GetItemString(modules, name) == NULL)
727 return;
728 if (PyDict_DelItemString(modules, name) < 0)
729 Py_FatalError("import: deleting existing key in"
730 "sys.modules failed");
Tim Peters1cd70172004-08-02 03:52:12 +0000731}
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000732
Barry Warsaw28a691b2010-04-17 00:19:56 +0000733static PyObject * get_sourcefile(char *file);
734static char *make_source_pathname(char *pathname, char *buf);
735static char *make_compiled_pathname(char *pathname, char *buf, size_t buflen,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000736 int debug);
Christian Heimes3b06e532008-01-07 20:12:44 +0000737
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000738/* Execute a code object in a module and return the module object
Tim Peters1cd70172004-08-02 03:52:12 +0000739 * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
740 * removed from sys.modules, to avoid leaving damaged module objects
741 * in sys.modules. The caller may wish to restore the original
742 * module object (if any) in this case; PyImport_ReloadModule is an
743 * example.
Barry Warsaw28a691b2010-04-17 00:19:56 +0000744 *
745 * Note that PyImport_ExecCodeModuleWithPathnames() is the preferred, richer
746 * interface. The other two exist primarily for backward compatibility.
Tim Peters1cd70172004-08-02 03:52:12 +0000747 */
Guido van Rossum79f25d91997-04-29 20:08:16 +0000748PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000749PyImport_ExecCodeModule(char *name, PyObject *co)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000750{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000751 return PyImport_ExecCodeModuleWithPathnames(
752 name, co, (char *)NULL, (char *)NULL);
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000753}
754
755PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000756PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000757{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000758 return PyImport_ExecCodeModuleWithPathnames(
759 name, co, pathname, (char *)NULL);
Barry Warsaw28a691b2010-04-17 00:19:56 +0000760}
761
762PyObject *
763PyImport_ExecCodeModuleWithPathnames(char *name, PyObject *co, char *pathname,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000764 char *cpathname)
Barry Warsaw28a691b2010-04-17 00:19:56 +0000765{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000766 PyObject *modules = PyImport_GetModuleDict();
767 PyObject *m, *d, *v;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000768
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000769 m = PyImport_AddModule(name);
770 if (m == NULL)
771 return NULL;
772 /* If the module is being reloaded, we get the old module back
773 and re-use its dict to exec the new code. */
774 d = PyModule_GetDict(m);
775 if (PyDict_GetItemString(d, "__builtins__") == NULL) {
776 if (PyDict_SetItemString(d, "__builtins__",
777 PyEval_GetBuiltins()) != 0)
778 goto error;
779 }
780 /* Remember the filename as the __file__ attribute */
781 v = NULL;
782 if (pathname != NULL) {
783 v = get_sourcefile(pathname);
784 if (v == NULL)
785 PyErr_Clear();
786 }
787 if (v == NULL) {
788 v = ((PyCodeObject *)co)->co_filename;
789 Py_INCREF(v);
790 }
791 if (PyDict_SetItemString(d, "__file__", v) != 0)
792 PyErr_Clear(); /* Not important enough to report */
793 Py_DECREF(v);
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000794
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000795 /* Remember the pyc path name as the __cached__ attribute. */
796 if (cpathname == NULL) {
797 v = Py_None;
798 Py_INCREF(v);
799 }
800 else if ((v = PyUnicode_FromString(cpathname)) == NULL) {
801 PyErr_Clear(); /* Not important enough to report */
802 v = Py_None;
803 Py_INCREF(v);
804 }
805 if (PyDict_SetItemString(d, "__cached__", v) != 0)
806 PyErr_Clear(); /* Not important enough to report */
807 Py_DECREF(v);
Barry Warsaw28a691b2010-04-17 00:19:56 +0000808
Martin v. Löwis4d0d4712010-12-03 20:14:31 +0000809 v = PyEval_EvalCode(co, d, d);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000810 if (v == NULL)
811 goto error;
812 Py_DECREF(v);
Guido van Rossumb65e85c1997-07-10 18:00:45 +0000813
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000814 if ((m = PyDict_GetItemString(modules, name)) == NULL) {
815 PyErr_Format(PyExc_ImportError,
816 "Loaded module %.200s not found in sys.modules",
817 name);
818 return NULL;
819 }
Guido van Rossumb65e85c1997-07-10 18:00:45 +0000820
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000821 Py_INCREF(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000822
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000823 return m;
Tim Peters1cd70172004-08-02 03:52:12 +0000824
825 error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000826 remove_module(name);
827 return NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000828}
829
830
Barry Warsaw28a691b2010-04-17 00:19:56 +0000831/* Like strrchr(string, '/') but searches for the rightmost of either SEP
832 or ALTSEP, if the latter is defined.
833*/
834static char *
835rightmost_sep(char *s)
836{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000837 char *found, c;
838 for (found = NULL; (c = *s); s++) {
839 if (c == SEP
Barry Warsaw28a691b2010-04-17 00:19:56 +0000840#ifdef ALTSEP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000841 || c == ALTSEP
Barry Warsaw28a691b2010-04-17 00:19:56 +0000842#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000843 )
844 {
845 found = s;
846 }
847 }
848 return found;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000849}
850
851
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000852/* Given a pathname for a Python source file, fill a buffer with the
853 pathname for the corresponding compiled file. Return the pathname
854 for the compiled file, or NULL if there's no space in the buffer.
855 Doesn't set an exception. */
856
857static char *
Barry Warsaw28a691b2010-04-17 00:19:56 +0000858make_compiled_pathname(char *pathname, char *buf, size_t buflen, int debug)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000859{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000860 /* foo.py -> __pycache__/foo.<tag>.pyc */
861 size_t len = strlen(pathname);
862 size_t i, save;
863 char *pos;
864 int sep = SEP;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000865
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000866 /* Sanity check that the buffer has roughly enough space to hold what
867 will eventually be the full path to the compiled file. The 5 extra
868 bytes include the slash afer __pycache__, the two extra dots, the
869 extra trailing character ('c' or 'o') and null. This isn't exact
870 because the contents of the buffer can affect how many actual
871 characters of the string get into the buffer. We'll do a final
872 sanity check before writing the extension to ensure we do not
873 overflow the buffer.
874 */
875 if (len + strlen(CACHEDIR) + strlen(pyc_tag) + 5 > buflen)
876 return NULL;
Tim Petersc1731372001-08-04 08:12:36 +0000877
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000878 /* Find the last path separator and copy everything from the start of
879 the source string up to and including the separator.
880 */
881 if ((pos = rightmost_sep(pathname)) == NULL) {
882 i = 0;
883 }
884 else {
885 sep = *pos;
886 i = pos - pathname + 1;
887 strncpy(buf, pathname, i);
888 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000889
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000890 save = i;
891 buf[i++] = '\0';
892 /* Add __pycache__/ */
893 strcat(buf, CACHEDIR);
894 i += strlen(CACHEDIR) - 1;
895 buf[i++] = sep;
896 buf[i++] = '\0';
897 /* Add the base filename, but remove the .py or .pyw extension, since
898 the tag name must go before the extension.
899 */
900 strcat(buf, pathname + save);
901 if ((pos = strrchr(buf, '.')) != NULL)
902 *++pos = '\0';
903 strcat(buf, pyc_tag);
904 /* The length test above assumes that we're only adding one character
905 to the end of what would normally be the extension. What if there
906 is no extension, or the string ends in '.' or '.p', and otherwise
907 fills the buffer? By appending 4 more characters onto the string
908 here, we could overrun the buffer.
Barry Warsaw28a691b2010-04-17 00:19:56 +0000909
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000910 As a simple example, let's say buflen=32 and the input string is
911 'xxx.py'. strlen() would be 6 and the test above would yield:
Barry Warsaw28a691b2010-04-17 00:19:56 +0000912
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000913 (6 + 11 + 10 + 5 == 32) > 32
Barry Warsaw28a691b2010-04-17 00:19:56 +0000914
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000915 which is false and so the name mangling would continue. This would
916 be fine because we'd end up with this string in buf:
Barry Warsaw28a691b2010-04-17 00:19:56 +0000917
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000918 __pycache__/xxx.cpython-32.pyc\0
Barry Warsaw28a691b2010-04-17 00:19:56 +0000919
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000920 strlen(of that) == 30 + the nul fits inside a 32 character buffer.
921 We can even handle an input string of say 'xxxxx' above because
922 that's (5 + 11 + 10 + 5 == 31) > 32 which is also false. Name
923 mangling that yields:
Barry Warsaw28a691b2010-04-17 00:19:56 +0000924
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000925 __pycache__/xxxxxcpython-32.pyc\0
Barry Warsaw28a691b2010-04-17 00:19:56 +0000926
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000927 which is 32 characters including the nul, and thus fits in the
928 buffer. However, an input string of 'xxxxxx' would yield a result
929 string of:
Barry Warsaw28a691b2010-04-17 00:19:56 +0000930
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000931 __pycache__/xxxxxxcpython-32.pyc\0
Barry Warsaw28a691b2010-04-17 00:19:56 +0000932
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000933 which is 33 characters long (including the nul), thus overflowing
934 the buffer, even though the first test would fail, i.e.: the input
935 string is also 6 characters long, so 32 > 32 is false.
Barry Warsaw28a691b2010-04-17 00:19:56 +0000936
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000937 The reason the first test fails but we still overflow the buffer is
938 that the test above only expects to add one extra character to be
939 added to the extension, and here we're adding three (pyc). We
940 don't add the first dot, so that reclaims one of expected
941 positions, leaving us overflowing by 1 byte (3 extra - 1 reclaimed
942 dot - 1 expected extra == 1 overflowed).
Barry Warsaw28a691b2010-04-17 00:19:56 +0000943
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000944 The best we can do is ensure that we still have enough room in the
945 target buffer before we write the extension. Because it's always
946 only the extension that can cause the overflow, and never the other
947 path bytes we've written, it's sufficient to just do one more test
948 here. Still, the assertion that follows can't hurt.
949 */
Barry Warsaw28a691b2010-04-17 00:19:56 +0000950#if 0
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000951 printf("strlen(buf): %d; buflen: %d\n", (int)strlen(buf), (int)buflen);
Barry Warsaw28a691b2010-04-17 00:19:56 +0000952#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000953 if (strlen(buf) + 5 > buflen)
954 return NULL;
955 strcat(buf, debug ? ".pyc" : ".pyo");
956 assert(strlen(buf) < buflen);
957 return buf;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000958}
959
960
Barry Warsaw28a691b2010-04-17 00:19:56 +0000961/* Given a pathname to a Python byte compiled file, return the path to the
962 source file, if the path matches the PEP 3147 format. This does not check
963 for any file existence, however, if the pyc file name does not match PEP
964 3147 style, NULL is returned. buf must be at least as big as pathname;
965 the resulting path will always be shorter. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000966
Barry Warsaw28a691b2010-04-17 00:19:56 +0000967static char *
968make_source_pathname(char *pathname, char *buf)
969{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000970 /* __pycache__/foo.<tag>.pyc -> foo.py */
971 size_t i, j;
972 char *left, *right, *dot0, *dot1, sep;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000973
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000974 /* Look back two slashes from the end. In between these two slashes
975 must be the string __pycache__ or this is not a PEP 3147 style
976 path. It's possible for there to be only one slash.
977 */
978 if ((right = rightmost_sep(pathname)) == NULL)
979 return NULL;
980 sep = *right;
981 *right = '\0';
982 left = rightmost_sep(pathname);
983 *right = sep;
984 if (left == NULL)
985 left = pathname;
986 else
987 left++;
988 if (right-left != strlen(CACHEDIR) ||
989 strncmp(left, CACHEDIR, right-left) != 0)
990 return NULL;
Barry Warsaw28a691b2010-04-17 00:19:56 +0000991
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000992 /* Now verify that the path component to the right of the last slash
993 has two dots in it.
994 */
995 if ((dot0 = strchr(right + 1, '.')) == NULL)
996 return NULL;
997 if ((dot1 = strchr(dot0 + 1, '.')) == NULL)
998 return NULL;
999 /* Too many dots? */
1000 if (strchr(dot1 + 1, '.') != NULL)
1001 return NULL;
Barry Warsaw28a691b2010-04-17 00:19:56 +00001002
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001003 /* This is a PEP 3147 path. Start by copying everything from the
1004 start of pathname up to and including the leftmost slash. Then
1005 copy the file's basename, removing the magic tag and adding a .py
1006 suffix.
1007 */
1008 strncpy(buf, pathname, (i=left-pathname));
1009 strncpy(buf+i, right+1, (j=dot0-right));
1010 strcpy(buf+i+j, "py");
1011 return buf;
Barry Warsaw28a691b2010-04-17 00:19:56 +00001012}
1013
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001014/* Given a pathname for a Python source file, its time of last
1015 modification, and a pathname for a compiled file, check whether the
1016 compiled file represents the same version of the source. If so,
1017 return a FILE pointer for the compiled file, positioned just after
1018 the header; if not, return NULL.
1019 Doesn't set an exception. */
1020
1021static FILE *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001022check_compiled_module(char *pathname, time_t mtime, char *cpathname)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001023{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001024 FILE *fp;
1025 long magic;
1026 long pyc_mtime;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001027
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001028 fp = fopen(cpathname, "rb");
1029 if (fp == NULL)
1030 return NULL;
1031 magic = PyMarshal_ReadLongFromFile(fp);
1032 if (magic != pyc_magic) {
1033 if (Py_VerboseFlag)
1034 PySys_WriteStderr("# %s has bad magic\n", cpathname);
1035 fclose(fp);
1036 return NULL;
1037 }
1038 pyc_mtime = PyMarshal_ReadLongFromFile(fp);
1039 if (pyc_mtime != mtime) {
1040 if (Py_VerboseFlag)
1041 PySys_WriteStderr("# %s has bad mtime\n", cpathname);
1042 fclose(fp);
1043 return NULL;
1044 }
1045 if (Py_VerboseFlag)
1046 PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
1047 return fp;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001048}
1049
1050
1051/* Read a code object from a file and check it for validity */
1052
Guido van Rossum79f25d91997-04-29 20:08:16 +00001053static PyCodeObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001054read_compiled_module(char *cpathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001055{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001056 PyObject *co;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001057
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001058 co = PyMarshal_ReadLastObjectFromFile(fp);
1059 if (co == NULL)
1060 return NULL;
1061 if (!PyCode_Check(co)) {
1062 PyErr_Format(PyExc_ImportError,
1063 "Non-code object in %.200s", cpathname);
1064 Py_DECREF(co);
1065 return NULL;
1066 }
1067 return (PyCodeObject *)co;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001068}
1069
1070
1071/* Load a module from a compiled file, execute it, and return its
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001072 module object WITH INCREMENTED REFERENCE COUNT */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001073
Guido van Rossum79f25d91997-04-29 20:08:16 +00001074static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001075load_compiled_module(char *name, char *cpathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001076{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001077 long magic;
1078 PyCodeObject *co;
1079 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001080
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001081 magic = PyMarshal_ReadLongFromFile(fp);
1082 if (magic != pyc_magic) {
1083 PyErr_Format(PyExc_ImportError,
1084 "Bad magic number in %.200s", cpathname);
1085 return NULL;
1086 }
1087 (void) PyMarshal_ReadLongFromFile(fp);
1088 co = read_compiled_module(cpathname, fp);
1089 if (co == NULL)
1090 return NULL;
1091 if (Py_VerboseFlag)
1092 PySys_WriteStderr("import %s # precompiled from %s\n",
1093 name, cpathname);
1094 m = PyImport_ExecCodeModuleWithPathnames(
1095 name, (PyObject *)co, cpathname, cpathname);
1096 Py_DECREF(co);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001097
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001098 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001099}
1100
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001101/* Parse a source file and return the corresponding code object */
1102
Guido van Rossum79f25d91997-04-29 20:08:16 +00001103static PyCodeObject *
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001104parse_source_module(const char *pathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001105{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001106 PyCodeObject *co = NULL;
1107 mod_ty mod;
1108 PyCompilerFlags flags;
1109 PyArena *arena = PyArena_New();
1110 if (arena == NULL)
1111 return NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001112
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001113 flags.cf_flags = 0;
1114 mod = PyParser_ASTFromFile(fp, pathname, NULL,
1115 Py_file_input, 0, 0, &flags,
1116 NULL, arena);
1117 if (mod) {
1118 co = PyAST_Compile(mod, pathname, NULL, arena);
1119 }
1120 PyArena_Free(arena);
1121 return co;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001122}
1123
1124
Guido van Rossum55a83382000-09-20 20:31:38 +00001125/* Helper to open a bytecode file for writing in exclusive mode */
1126
1127static FILE *
Christian Heimes05e8be12008-02-23 18:30:17 +00001128open_exclusive(char *filename, mode_t mode)
Guido van Rossum55a83382000-09-20 20:31:38 +00001129{
1130#if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001131 /* Use O_EXCL to avoid a race condition when another process tries to
1132 write the same file. When that happens, our open() call fails,
1133 which is just fine (since it's only a cache).
1134 XXX If the file exists and is writable but the directory is not
1135 writable, the file will never be written. Oh well.
1136 */
1137 int fd;
1138 (void) unlink(filename);
1139 fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC
Tim Peters42c83af2000-09-29 04:03:10 +00001140#ifdef O_BINARY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001141 |O_BINARY /* necessary for Windows */
Tim Peters42c83af2000-09-29 04:03:10 +00001142#endif
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00001143#ifdef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001144 , mode, "ctxt=bin", "shr=nil"
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00001145#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001146 , mode
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00001147#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001148 );
1149 if (fd < 0)
1150 return NULL;
1151 return fdopen(fd, "wb");
Guido van Rossum55a83382000-09-20 20:31:38 +00001152#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001153 /* Best we can do -- on Windows this can't happen anyway */
1154 return fopen(filename, "wb");
Guido van Rossum55a83382000-09-20 20:31:38 +00001155#endif
1156}
1157
1158
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001159/* Write a compiled module to a file, placing the time of last
1160 modification of its source into the header.
1161 Errors are ignored, if a write error occurs an attempt is made to
1162 remove the file. */
1163
1164static void
Christian Heimes05e8be12008-02-23 18:30:17 +00001165write_compiled_module(PyCodeObject *co, char *cpathname, struct stat *srcstat)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001166{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001167 FILE *fp;
1168 char *dirpath;
1169 time_t mtime = srcstat->st_mtime;
Alexandre Vassalotti9d58e3e2009-07-17 10:55:50 +00001170#ifdef MS_WINDOWS /* since Windows uses different permissions */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001171 mode_t mode = srcstat->st_mode & ~S_IEXEC;
Alexandre Vassalotti9d58e3e2009-07-17 10:55:50 +00001172#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001173 mode_t mode = srcstat->st_mode & ~S_IXUSR & ~S_IXGRP & ~S_IXOTH;
1174 mode_t dirmode = (srcstat->st_mode |
1175 S_IXUSR | S_IXGRP | S_IXOTH |
1176 S_IWUSR | S_IWGRP | S_IWOTH);
Brett Cannon9a5b25a2010-03-01 02:09:17 +00001177#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001178 int saved;
Barry Warsaw28a691b2010-04-17 00:19:56 +00001179
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001180 /* Ensure that the __pycache__ directory exists. */
1181 dirpath = rightmost_sep(cpathname);
1182 if (dirpath == NULL) {
1183 if (Py_VerboseFlag)
1184 PySys_WriteStderr(
1185 "# no %s path found %s\n",
1186 CACHEDIR, cpathname);
1187 return;
1188 }
1189 saved = *dirpath;
1190 *dirpath = '\0';
Daniel Stutzbachc7937792010-09-09 21:18:04 +00001191
1192#ifdef MS_WINDOWS
1193 if (_mkdir(cpathname) < 0 && errno != EEXIST) {
1194#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001195 if (mkdir(cpathname, dirmode) < 0 && errno != EEXIST) {
Daniel Stutzbachc7937792010-09-09 21:18:04 +00001196#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001197 *dirpath = saved;
1198 if (Py_VerboseFlag)
1199 PySys_WriteStderr(
1200 "# cannot create cache dir %s\n", cpathname);
1201 return;
1202 }
1203 *dirpath = saved;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001204
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001205 fp = open_exclusive(cpathname, mode);
1206 if (fp == NULL) {
1207 if (Py_VerboseFlag)
1208 PySys_WriteStderr(
1209 "# can't create %s\n", cpathname);
1210 return;
1211 }
1212 PyMarshal_WriteLongToFile(pyc_magic, fp, Py_MARSHAL_VERSION);
1213 /* First write a 0 for mtime */
1214 PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
1215 PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
1216 if (fflush(fp) != 0 || ferror(fp)) {
1217 if (Py_VerboseFlag)
1218 PySys_WriteStderr("# can't write %s\n", cpathname);
1219 /* Don't keep partial file */
1220 fclose(fp);
1221 (void) unlink(cpathname);
1222 return;
1223 }
1224 /* Now write the true mtime */
1225 fseek(fp, 4L, 0);
1226 assert(mtime < LONG_MAX);
1227 PyMarshal_WriteLongToFile((long)mtime, fp, Py_MARSHAL_VERSION);
1228 fflush(fp);
1229 fclose(fp);
1230 if (Py_VerboseFlag)
1231 PySys_WriteStderr("# wrote %s\n", cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001232}
1233
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001234static void
1235update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)
1236{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001237 PyObject *constants, *tmp;
1238 Py_ssize_t i, n;
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001239
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001240 if (PyUnicode_Compare(co->co_filename, oldname))
1241 return;
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001242
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001243 tmp = co->co_filename;
1244 co->co_filename = newname;
1245 Py_INCREF(co->co_filename);
1246 Py_DECREF(tmp);
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001247
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001248 constants = co->co_consts;
1249 n = PyTuple_GET_SIZE(constants);
1250 for (i = 0; i < n; i++) {
1251 tmp = PyTuple_GET_ITEM(constants, i);
1252 if (PyCode_Check(tmp))
1253 update_code_filenames((PyCodeObject *)tmp,
1254 oldname, newname);
1255 }
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001256}
1257
1258static int
1259update_compiled_module(PyCodeObject *co, char *pathname)
1260{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001261 PyObject *oldname, *newname;
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001262
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001263 newname = PyUnicode_DecodeFSDefault(pathname);
1264 if (newname == NULL)
1265 return -1;
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001266
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001267 if (!PyUnicode_Compare(co->co_filename, newname)) {
1268 Py_DECREF(newname);
1269 return 0;
1270 }
Hirokazu Yamamoto4f447fb2009-03-04 01:52:10 +00001271
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001272 oldname = co->co_filename;
1273 Py_INCREF(oldname);
1274 update_code_filenames(co, oldname, newname);
1275 Py_DECREF(oldname);
1276 Py_DECREF(newname);
1277 return 1;
Antoine Pitroud35cbf62009-01-06 19:02:24 +00001278}
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001279
1280/* Load a source module from a given file and return its module
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001281 object WITH INCREMENTED REFERENCE COUNT. If there's a matching
1282 byte-compiled file, use that instead. */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001283
Guido van Rossum79f25d91997-04-29 20:08:16 +00001284static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001285load_source_module(char *name, char *pathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001286{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001287 struct stat st;
1288 FILE *fpc;
1289 char buf[MAXPATHLEN+1];
1290 char *cpathname;
1291 PyCodeObject *co;
1292 PyObject *m;
Brett Cannon9a5b25a2010-03-01 02:09:17 +00001293
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001294 if (fstat(fileno(fp), &st) != 0) {
1295 PyErr_Format(PyExc_RuntimeError,
1296 "unable to get file status from '%s'",
1297 pathname);
1298 return NULL;
1299 }
Fred Drake4c82b232000-06-30 16:18:57 +00001300#if SIZEOF_TIME_T > 4
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001301 /* Python's .pyc timestamp handling presumes that the timestamp fits
1302 in 4 bytes. This will be fine until sometime in the year 2038,
1303 when a 4-byte signed time_t will overflow.
1304 */
1305 if (st.st_mtime >> 32) {
1306 PyErr_SetString(PyExc_OverflowError,
1307 "modification time overflows a 4 byte field");
1308 return NULL;
1309 }
Fred Drake4c82b232000-06-30 16:18:57 +00001310#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001311 cpathname = make_compiled_pathname(
1312 pathname, buf, (size_t)MAXPATHLEN + 1, !Py_OptimizeFlag);
1313 if (cpathname != NULL &&
1314 (fpc = check_compiled_module(pathname, st.st_mtime, cpathname))) {
1315 co = read_compiled_module(cpathname, fpc);
1316 fclose(fpc);
1317 if (co == NULL)
1318 return NULL;
1319 if (update_compiled_module(co, pathname) < 0)
1320 return NULL;
1321 if (Py_VerboseFlag)
1322 PySys_WriteStderr("import %s # precompiled from %s\n",
1323 name, cpathname);
1324 pathname = cpathname;
1325 }
1326 else {
1327 co = parse_source_module(pathname, fp);
1328 if (co == NULL)
1329 return NULL;
1330 if (Py_VerboseFlag)
1331 PySys_WriteStderr("import %s # from %s\n",
1332 name, pathname);
1333 if (cpathname) {
1334 PyObject *ro = PySys_GetObject("dont_write_bytecode");
1335 if (ro == NULL || !PyObject_IsTrue(ro))
1336 write_compiled_module(co, cpathname, &st);
1337 }
1338 }
1339 m = PyImport_ExecCodeModuleWithPathnames(
1340 name, (PyObject *)co, pathname, cpathname);
1341 Py_DECREF(co);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001342
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001343 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001344}
1345
Christian Heimes3b06e532008-01-07 20:12:44 +00001346/* Get source file -> unicode or None
1347 * Returns the path to the py file if available, else the given path
1348 */
1349static PyObject *
Barry Warsaw28a691b2010-04-17 00:19:56 +00001350get_sourcefile(char *file)
Christian Heimes3b06e532008-01-07 20:12:44 +00001351{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001352 char py[MAXPATHLEN + 1];
1353 Py_ssize_t len;
1354 PyObject *u;
1355 struct stat statbuf;
Christian Heimes3b06e532008-01-07 20:12:44 +00001356
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001357 if (!file || !*file) {
1358 Py_RETURN_NONE;
1359 }
Christian Heimes3b06e532008-01-07 20:12:44 +00001360
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001361 len = strlen(file);
1362 /* match '*.py?' */
1363 if (len > MAXPATHLEN || PyOS_strnicmp(&file[len-4], ".py", 3) != 0) {
1364 return PyUnicode_DecodeFSDefault(file);
1365 }
Christian Heimes3b06e532008-01-07 20:12:44 +00001366
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001367 /* Start by trying to turn PEP 3147 path into source path. If that
1368 * fails, just chop off the trailing character, i.e. legacy pyc path
1369 * to py.
1370 */
1371 if (make_source_pathname(file, py) == NULL) {
1372 strncpy(py, file, len-1);
1373 py[len-1] = '\0';
1374 }
Barry Warsaw28a691b2010-04-17 00:19:56 +00001375
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001376 if (stat(py, &statbuf) == 0 &&
1377 S_ISREG(statbuf.st_mode)) {
1378 u = PyUnicode_DecodeFSDefault(py);
1379 }
1380 else {
1381 u = PyUnicode_DecodeFSDefault(file);
1382 }
1383 return u;
Christian Heimes3b06e532008-01-07 20:12:44 +00001384}
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001385
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001386/* Forward */
Just van Rossum52e14d62002-12-30 22:08:05 +00001387static PyObject *load_module(char *, FILE *, char *, int, PyObject *);
1388static struct filedescr *find_module(char *, char *, PyObject *,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001389 char *, size_t, FILE **, PyObject **);
Christian Heimes3b06e532008-01-07 20:12:44 +00001390static struct _frozen * find_frozen(char *);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001391
1392/* Load a package and return its module object WITH INCREMENTED
1393 REFERENCE COUNT */
1394
1395static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001396load_package(char *name, char *pathname)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001397{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001398 PyObject *m, *d;
1399 PyObject *file = NULL;
1400 PyObject *path = NULL;
1401 int err;
1402 char buf[MAXPATHLEN+1];
1403 FILE *fp = NULL;
1404 struct filedescr *fdp;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001405
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001406 m = PyImport_AddModule(name);
1407 if (m == NULL)
1408 return NULL;
1409 if (Py_VerboseFlag)
1410 PySys_WriteStderr("import %s # directory %s\n",
1411 name, pathname);
1412 d = PyModule_GetDict(m);
1413 file = get_sourcefile(pathname);
1414 if (file == NULL)
1415 goto error;
1416 path = Py_BuildValue("[O]", file);
1417 if (path == NULL)
1418 goto error;
1419 err = PyDict_SetItemString(d, "__file__", file);
1420 if (err == 0)
1421 err = PyDict_SetItemString(d, "__path__", path);
1422 if (err != 0)
1423 goto error;
1424 buf[0] = '\0';
1425 fdp = find_module(name, "__init__", path, buf, sizeof(buf), &fp, NULL);
1426 if (fdp == NULL) {
1427 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1428 PyErr_Clear();
1429 Py_INCREF(m);
1430 }
1431 else
1432 m = NULL;
1433 goto cleanup;
1434 }
1435 m = load_module(name, fp, buf, fdp->type, NULL);
1436 if (fp != NULL)
1437 fclose(fp);
1438 goto cleanup;
Tim Peters1cd70172004-08-02 03:52:12 +00001439
1440 error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001441 m = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001442 cleanup:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001443 Py_XDECREF(path);
1444 Py_XDECREF(file);
1445 return m;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001446}
1447
1448
1449/* Helper to test for built-in module */
1450
1451static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001452is_builtin(char *name)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001453{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001454 int i;
1455 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
1456 if (strcmp(name, PyImport_Inittab[i].name) == 0) {
1457 if (PyImport_Inittab[i].initfunc == NULL)
1458 return -1;
1459 else
1460 return 1;
1461 }
1462 }
1463 return 0;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001464}
1465
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001466
Just van Rossum52e14d62002-12-30 22:08:05 +00001467/* Return an importer object for a sys.path/pkg.__path__ item 'p',
1468 possibly by fetching it from the path_importer_cache dict. If it
Thomas Wouters89f507f2006-12-13 04:49:30 +00001469 wasn't yet cached, traverse path_hooks until a hook is found
Just van Rossum52e14d62002-12-30 22:08:05 +00001470 that can handle the path item. Return None if no hook could;
1471 this tells our caller it should fall back to the builtin
1472 import mechanism. Cache the result in path_importer_cache.
1473 Returns a borrowed reference. */
1474
1475static PyObject *
1476get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001477 PyObject *p)
Just van Rossum52e14d62002-12-30 22:08:05 +00001478{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001479 PyObject *importer;
1480 Py_ssize_t j, nhooks;
Just van Rossum52e14d62002-12-30 22:08:05 +00001481
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001482 /* These conditions are the caller's responsibility: */
1483 assert(PyList_Check(path_hooks));
1484 assert(PyDict_Check(path_importer_cache));
Just van Rossum52e14d62002-12-30 22:08:05 +00001485
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001486 nhooks = PyList_Size(path_hooks);
1487 if (nhooks < 0)
1488 return NULL; /* Shouldn't happen */
Just van Rossum52e14d62002-12-30 22:08:05 +00001489
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001490 importer = PyDict_GetItem(path_importer_cache, p);
1491 if (importer != NULL)
1492 return importer;
Just van Rossum52e14d62002-12-30 22:08:05 +00001493
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001494 /* set path_importer_cache[p] to None to avoid recursion */
1495 if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
1496 return NULL;
Just van Rossum52e14d62002-12-30 22:08:05 +00001497
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001498 for (j = 0; j < nhooks; j++) {
1499 PyObject *hook = PyList_GetItem(path_hooks, j);
1500 if (hook == NULL)
1501 return NULL;
1502 importer = PyObject_CallFunctionObjArgs(hook, p, NULL);
1503 if (importer != NULL)
1504 break;
Just van Rossum52e14d62002-12-30 22:08:05 +00001505
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001506 if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
1507 return NULL;
1508 }
1509 PyErr_Clear();
1510 }
1511 if (importer == NULL) {
1512 importer = PyObject_CallFunctionObjArgs(
1513 (PyObject *)&PyNullImporter_Type, p, NULL
1514 );
1515 if (importer == NULL) {
1516 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1517 PyErr_Clear();
1518 return Py_None;
1519 }
1520 }
1521 }
1522 if (importer != NULL) {
1523 int err = PyDict_SetItem(path_importer_cache, p, importer);
1524 Py_DECREF(importer);
1525 if (err != 0)
1526 return NULL;
1527 }
1528 return importer;
Just van Rossum52e14d62002-12-30 22:08:05 +00001529}
1530
Christian Heimes9cd17752007-11-18 19:35:23 +00001531PyAPI_FUNC(PyObject *)
1532PyImport_GetImporter(PyObject *path) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001533 PyObject *importer=NULL, *path_importer_cache=NULL, *path_hooks=NULL;
Christian Heimes9cd17752007-11-18 19:35:23 +00001534
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001535 if ((path_importer_cache = PySys_GetObject("path_importer_cache"))) {
1536 if ((path_hooks = PySys_GetObject("path_hooks"))) {
1537 importer = get_path_importer(path_importer_cache,
1538 path_hooks, path);
1539 }
1540 }
1541 Py_XINCREF(importer); /* get_path_importer returns a borrowed reference */
1542 return importer;
Christian Heimes9cd17752007-11-18 19:35:23 +00001543}
1544
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001545/* Search the path (default sys.path) for a module. Return the
1546 corresponding filedescr struct, and (via return arguments) the
1547 pathname and an open file. Return NULL if the module is not found. */
1548
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001549#ifdef MS_COREDLL
Thomas Woutersb4bd21c2000-07-22 23:38:01 +00001550extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001551 char *, Py_ssize_t);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001552#endif
1553
Martin v. Löwis18e16552006-02-15 17:27:45 +00001554static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *);
Tim Petersdbd9ba62000-07-09 03:09:57 +00001555static int find_init_module(char *); /* Forward */
Just van Rossum52e14d62002-12-30 22:08:05 +00001556static struct filedescr importhookdescr = {"", "", IMP_HOOK};
Guido van Rossum197346f1997-10-31 18:38:52 +00001557
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001558static struct filedescr *
Just van Rossum52e14d62002-12-30 22:08:05 +00001559find_module(char *fullname, char *subname, PyObject *path, char *buf,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001560 size_t buflen, FILE **p_fp, PyObject **p_loader)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001561{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001562 Py_ssize_t i, npath;
1563 size_t len, namelen;
1564 struct filedescr *fdp = NULL;
1565 char *filemode;
1566 FILE *fp = NULL;
1567 PyObject *path_hooks, *path_importer_cache;
1568 struct stat statbuf;
1569 static struct filedescr fd_frozen = {"", "", PY_FROZEN};
1570 static struct filedescr fd_builtin = {"", "", C_BUILTIN};
1571 static struct filedescr fd_package = {"", "", PKG_DIRECTORY};
1572 char name[MAXPATHLEN+1];
Andrew MacIntyred9400542002-02-26 11:41:34 +00001573#if defined(PYOS_OS2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001574 size_t saved_len;
1575 size_t saved_namelen;
1576 char *saved_buf = NULL;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001577#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001578 if (p_loader != NULL)
1579 *p_loader = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001580
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001581 if (strlen(subname) > MAXPATHLEN) {
1582 PyErr_SetString(PyExc_OverflowError,
1583 "module name is too long");
1584 return NULL;
1585 }
1586 strcpy(name, subname);
Just van Rossum52e14d62002-12-30 22:08:05 +00001587
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001588 /* sys.meta_path import hook */
1589 if (p_loader != NULL) {
1590 PyObject *meta_path;
Just van Rossum52e14d62002-12-30 22:08:05 +00001591
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001592 meta_path = PySys_GetObject("meta_path");
1593 if (meta_path == NULL || !PyList_Check(meta_path)) {
1594 PyErr_SetString(PyExc_ImportError,
1595 "sys.meta_path must be a list of "
1596 "import hooks");
1597 return NULL;
1598 }
1599 Py_INCREF(meta_path); /* zap guard */
1600 npath = PyList_Size(meta_path);
1601 for (i = 0; i < npath; i++) {
1602 PyObject *loader;
1603 PyObject *hook = PyList_GetItem(meta_path, i);
1604 loader = PyObject_CallMethod(hook, "find_module",
1605 "sO", fullname,
1606 path != NULL ?
1607 path : Py_None);
1608 if (loader == NULL) {
1609 Py_DECREF(meta_path);
1610 return NULL; /* true error */
1611 }
1612 if (loader != Py_None) {
1613 /* a loader was found */
1614 *p_loader = loader;
1615 Py_DECREF(meta_path);
1616 return &importhookdescr;
1617 }
1618 Py_DECREF(loader);
1619 }
1620 Py_DECREF(meta_path);
1621 }
Guido van Rossum0506a431998-08-11 15:07:39 +00001622
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001623 if (find_frozen(fullname) != NULL) {
1624 strcpy(buf, fullname);
1625 return &fd_frozen;
1626 }
Benjamin Petersond968e272008-11-05 22:48:33 +00001627
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001628 if (path == NULL) {
1629 if (is_builtin(name)) {
1630 strcpy(buf, name);
1631 return &fd_builtin;
1632 }
Guido van Rossumac279101996-08-22 23:10:58 +00001633#ifdef MS_COREDLL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001634 fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen);
1635 if (fp != NULL) {
1636 *p_fp = fp;
1637 return fdp;
1638 }
Guido van Rossuma5a3db71996-04-09 02:39:59 +00001639#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001640 path = PySys_GetObject("path");
1641 }
Benjamin Petersond968e272008-11-05 22:48:33 +00001642
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001643 if (path == NULL || !PyList_Check(path)) {
1644 PyErr_SetString(PyExc_ImportError,
1645 "sys.path must be a list of directory names");
1646 return NULL;
1647 }
Just van Rossum52e14d62002-12-30 22:08:05 +00001648
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001649 path_hooks = PySys_GetObject("path_hooks");
1650 if (path_hooks == NULL || !PyList_Check(path_hooks)) {
1651 PyErr_SetString(PyExc_ImportError,
1652 "sys.path_hooks must be a list of "
1653 "import hooks");
1654 return NULL;
1655 }
1656 path_importer_cache = PySys_GetObject("path_importer_cache");
1657 if (path_importer_cache == NULL ||
1658 !PyDict_Check(path_importer_cache)) {
1659 PyErr_SetString(PyExc_ImportError,
1660 "sys.path_importer_cache must be a dict");
1661 return NULL;
1662 }
Just van Rossum52e14d62002-12-30 22:08:05 +00001663
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001664 npath = PyList_Size(path);
1665 namelen = strlen(name);
1666 for (i = 0; i < npath; i++) {
1667 PyObject *v = PyList_GetItem(path, i);
1668 PyObject *origv = v;
1669 const char *base;
1670 Py_ssize_t size;
1671 if (!v)
1672 return NULL;
1673 if (PyUnicode_Check(v)) {
Victor Stinnerae6265f2010-05-15 16:27:27 +00001674 v = PyUnicode_EncodeFSDefault(v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001675 if (v == NULL)
1676 return NULL;
1677 }
1678 else if (!PyBytes_Check(v))
1679 continue;
1680 else
1681 Py_INCREF(v);
Amaury Forgeot d'Arcf1ca0b12008-06-11 17:40:47 +00001682
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001683 base = PyBytes_AS_STRING(v);
1684 size = PyBytes_GET_SIZE(v);
1685 len = size;
1686 if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {
1687 Py_DECREF(v);
1688 continue; /* Too long */
1689 }
1690 strcpy(buf, base);
1691 Py_DECREF(v);
Amaury Forgeot d'Arcf1ca0b12008-06-11 17:40:47 +00001692
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001693 if (strlen(buf) != len) {
1694 continue; /* v contains '\0' */
1695 }
Just van Rossum52e14d62002-12-30 22:08:05 +00001696
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001697 /* sys.path_hooks import hook */
1698 if (p_loader != NULL) {
1699 PyObject *importer;
Just van Rossum52e14d62002-12-30 22:08:05 +00001700
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001701 importer = get_path_importer(path_importer_cache,
1702 path_hooks, origv);
1703 if (importer == NULL) {
1704 return NULL;
1705 }
1706 /* Note: importer is a borrowed reference */
1707 if (importer != Py_None) {
1708 PyObject *loader;
1709 loader = PyObject_CallMethod(importer,
1710 "find_module",
1711 "s", fullname);
1712 if (loader == NULL)
1713 return NULL; /* error */
1714 if (loader != Py_None) {
1715 /* a loader was found */
1716 *p_loader = loader;
1717 return &importhookdescr;
1718 }
1719 Py_DECREF(loader);
1720 continue;
1721 }
1722 }
1723 /* no hook was found, use builtin import */
Just van Rossum52e14d62002-12-30 22:08:05 +00001724
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001725 if (len > 0 && buf[len-1] != SEP
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001726#ifdef ALTSEP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001727 && buf[len-1] != ALTSEP
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001728#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001729 )
1730 buf[len++] = SEP;
1731 strcpy(buf+len, name);
1732 len += namelen;
Tim Peters50d8d372001-02-28 05:34:27 +00001733
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001734 /* Check for package import (buf holds a directory name,
1735 and there's an __init__ module in that directory */
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001736#ifdef HAVE_STAT
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001737 if (stat(buf, &statbuf) == 0 && /* it exists */
1738 S_ISDIR(statbuf.st_mode) && /* it's a directory */
1739 case_ok(buf, len, namelen, name)) { /* case matches */
1740 if (find_init_module(buf)) { /* and has __init__.py */
1741 return &fd_package;
1742 }
1743 else {
Victor Stinnered7916d2010-10-17 02:07:09 +00001744 int err;
1745 PyObject *unicode = PyUnicode_DecodeFSDefault(buf);
1746 if (unicode == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001747 return NULL;
Victor Stinnered7916d2010-10-17 02:07:09 +00001748 err = PyErr_WarnFormat(PyExc_ImportWarning, 1,
1749 "Not importing directory '%U': missing __init__.py",
1750 unicode);
1751 Py_DECREF(unicode);
1752 if (err)
1753 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001754 }
1755 }
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001756#endif
Andrew MacIntyred9400542002-02-26 11:41:34 +00001757#if defined(PYOS_OS2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001758 /* take a snapshot of the module spec for restoration
1759 * after the 8 character DLL hackery
1760 */
1761 saved_buf = strdup(buf);
1762 saved_len = len;
1763 saved_namelen = namelen;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001764#endif /* PYOS_OS2 */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001765 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
Guido van Rossum04110fb2007-08-24 16:32:05 +00001766#if defined(PYOS_OS2) && defined(HAVE_DYNAMIC_LOADING)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001767 /* OS/2 limits DLLs to 8 character names (w/o
1768 extension)
1769 * so if the name is longer than that and its a
1770 * dynamically loaded module we're going to try,
1771 * truncate the name before trying
1772 */
1773 if (strlen(subname) > 8) {
1774 /* is this an attempt to load a C extension? */
1775 const struct filedescr *scan;
1776 scan = _PyImport_DynLoadFiletab;
1777 while (scan->suffix != NULL) {
1778 if (!strcmp(scan->suffix, fdp->suffix))
1779 break;
1780 else
1781 scan++;
1782 }
1783 if (scan->suffix != NULL) {
1784 /* yes, so truncate the name */
1785 namelen = 8;
1786 len -= strlen(subname) - namelen;
1787 buf[len] = '\0';
1788 }
1789 }
Andrew MacIntyred9400542002-02-26 11:41:34 +00001790#endif /* PYOS_OS2 */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001791 strcpy(buf+len, fdp->suffix);
1792 if (Py_VerboseFlag > 1)
1793 PySys_WriteStderr("# trying %s\n", buf);
1794 filemode = fdp->mode;
1795 if (filemode[0] == 'U')
1796 filemode = "r" PY_STDIOTEXTMODE;
1797 fp = fopen(buf, filemode);
1798 if (fp != NULL) {
1799 if (case_ok(buf, len, namelen, name))
1800 break;
1801 else { /* continue search */
1802 fclose(fp);
1803 fp = NULL;
1804 }
1805 }
Andrew MacIntyred9400542002-02-26 11:41:34 +00001806#if defined(PYOS_OS2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001807 /* restore the saved snapshot */
1808 strcpy(buf, saved_buf);
1809 len = saved_len;
1810 namelen = saved_namelen;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001811#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001812 }
Andrew MacIntyred9400542002-02-26 11:41:34 +00001813#if defined(PYOS_OS2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001814 /* don't need/want the module name snapshot anymore */
1815 if (saved_buf)
1816 {
1817 free(saved_buf);
1818 saved_buf = NULL;
1819 }
Andrew MacIntyred9400542002-02-26 11:41:34 +00001820#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001821 if (fp != NULL)
1822 break;
1823 }
1824 if (fp == NULL) {
1825 PyErr_Format(PyExc_ImportError,
1826 "No module named %.200s", name);
1827 return NULL;
1828 }
1829 *p_fp = fp;
1830 return fdp;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001831}
1832
Martin v. Löwis18e16552006-02-15 17:27:45 +00001833/* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
Tim Petersd1e87a82001-03-01 18:12:00 +00001834 * The arguments here are tricky, best shown by example:
1835 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1836 * ^ ^ ^ ^
1837 * |--------------------- buf ---------------------|
1838 * |------------------- len ------------------|
1839 * |------ name -------|
1840 * |----- namelen -----|
1841 * buf is the full path, but len only counts up to (& exclusive of) the
1842 * extension. name is the module name, also exclusive of extension.
1843 *
1844 * We've already done a successful stat() or fopen() on buf, so know that
1845 * there's some match, possibly case-insensitive.
1846 *
Tim Peters50d8d372001-02-28 05:34:27 +00001847 * case_ok() is to return 1 if there's a case-sensitive match for
1848 * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK
1849 * exists.
Tim Petersd1e87a82001-03-01 18:12:00 +00001850 *
Tim Peters50d8d372001-02-28 05:34:27 +00001851 * case_ok() is used to implement case-sensitive import semantics even
1852 * on platforms with case-insensitive filesystems. It's trivial to implement
1853 * for case-sensitive filesystems. It's pretty much a cross-platform
1854 * nightmare for systems with case-insensitive filesystems.
1855 */
Guido van Rossum0980bd91998-02-13 17:18:36 +00001856
Tim Peters50d8d372001-02-28 05:34:27 +00001857/* First we may need a pile of platform-specific header files; the sequence
1858 * of #if's here should match the sequence in the body of case_ok().
1859 */
Jason Tishler7961aa62005-05-20 00:56:54 +00001860#if defined(MS_WINDOWS)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001861#include <windows.h>
Guido van Rossum4c3f57c2001-01-10 20:40:46 +00001862
Tim Peters50d8d372001-02-28 05:34:27 +00001863#elif defined(DJGPP)
1864#include <dir.h>
1865
Jason Tishler7961aa62005-05-20 00:56:54 +00001866#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
Tim Peters430f5d42001-03-01 01:30:56 +00001867#include <sys/types.h>
1868#include <dirent.h>
1869
Andrew MacIntyred9400542002-02-26 11:41:34 +00001870#elif defined(PYOS_OS2)
1871#define INCL_DOS
1872#define INCL_DOSERRORS
1873#define INCL_NOPMAPI
1874#include <os2.h>
Tim Peters50d8d372001-02-28 05:34:27 +00001875#endif
1876
Guido van Rossum0980bd91998-02-13 17:18:36 +00001877static int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001878case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001879{
Tim Peters50d8d372001-02-28 05:34:27 +00001880/* Pick a platform-specific implementation; the sequence of #if's here should
1881 * match the sequence just above.
1882 */
1883
Jason Tishler7961aa62005-05-20 00:56:54 +00001884/* MS_WINDOWS */
1885#if defined(MS_WINDOWS)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001886 WIN32_FIND_DATA data;
1887 HANDLE h;
Tim Peters50d8d372001-02-28 05:34:27 +00001888
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001889 if (Py_GETENV("PYTHONCASEOK") != NULL)
1890 return 1;
Tim Peters50d8d372001-02-28 05:34:27 +00001891
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001892 h = FindFirstFile(buf, &data);
1893 if (h == INVALID_HANDLE_VALUE) {
1894 PyErr_Format(PyExc_NameError,
1895 "Can't find file for module %.100s\n(filename %.300s)",
1896 name, buf);
1897 return 0;
1898 }
1899 FindClose(h);
1900 return strncmp(data.cFileName, name, namelen) == 0;
Tim Peters50d8d372001-02-28 05:34:27 +00001901
1902/* DJGPP */
1903#elif defined(DJGPP)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001904 struct ffblk ffblk;
1905 int done;
Tim Peters50d8d372001-02-28 05:34:27 +00001906
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001907 if (Py_GETENV("PYTHONCASEOK") != NULL)
1908 return 1;
Tim Peters50d8d372001-02-28 05:34:27 +00001909
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001910 done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);
1911 if (done) {
1912 PyErr_Format(PyExc_NameError,
1913 "Can't find file for module %.100s\n(filename %.300s)",
1914 name, buf);
1915 return 0;
1916 }
1917 return strncmp(ffblk.ff_name, name, namelen) == 0;
Guido van Rossum0980bd91998-02-13 17:18:36 +00001918
Jason Tishler7961aa62005-05-20 00:56:54 +00001919/* new-fangled macintosh (macosx) or Cygwin */
1920#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001921 DIR *dirp;
1922 struct dirent *dp;
1923 char dirname[MAXPATHLEN + 1];
1924 const int dirlen = len - namelen - 1; /* don't want trailing SEP */
Tim Peters430f5d42001-03-01 01:30:56 +00001925
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001926 if (Py_GETENV("PYTHONCASEOK") != NULL)
1927 return 1;
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001928
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001929 /* Copy the dir component into dirname; substitute "." if empty */
1930 if (dirlen <= 0) {
1931 dirname[0] = '.';
1932 dirname[1] = '\0';
1933 }
1934 else {
1935 assert(dirlen <= MAXPATHLEN);
1936 memcpy(dirname, buf, dirlen);
1937 dirname[dirlen] = '\0';
1938 }
1939 /* Open the directory and search the entries for an exact match. */
1940 dirp = opendir(dirname);
1941 if (dirp) {
1942 char *nameWithExt = buf + len - namelen;
1943 while ((dp = readdir(dirp)) != NULL) {
1944 const int thislen =
Tim Peters430f5d42001-03-01 01:30:56 +00001945#ifdef _DIRENT_HAVE_D_NAMELEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001946 dp->d_namlen;
Tim Peters430f5d42001-03-01 01:30:56 +00001947#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001948 strlen(dp->d_name);
Tim Peters430f5d42001-03-01 01:30:56 +00001949#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001950 if (thislen >= namelen &&
1951 strcmp(dp->d_name, nameWithExt) == 0) {
1952 (void)closedir(dirp);
1953 return 1; /* Found */
1954 }
1955 }
1956 (void)closedir(dirp);
1957 }
1958 return 0 ; /* Not found */
Tim Peters430f5d42001-03-01 01:30:56 +00001959
Andrew MacIntyred9400542002-02-26 11:41:34 +00001960/* OS/2 */
1961#elif defined(PYOS_OS2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001962 HDIR hdir = 1;
1963 ULONG srchcnt = 1;
1964 FILEFINDBUF3 ffbuf;
1965 APIRET rc;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001966
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001967 if (Py_GETENV("PYTHONCASEOK") != NULL)
1968 return 1;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001969
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001970 rc = DosFindFirst(buf,
1971 &hdir,
1972 FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,
1973 &ffbuf, sizeof(ffbuf),
1974 &srchcnt,
1975 FIL_STANDARD);
1976 if (rc != NO_ERROR)
1977 return 0;
1978 return strncmp(ffbuf.achName, name, namelen) == 0;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001979
Tim Peters50d8d372001-02-28 05:34:27 +00001980/* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1981#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001982 return 1;
Guido van Rossum0980bd91998-02-13 17:18:36 +00001983
Guido van Rossum4d1b3b91998-02-13 23:27:59 +00001984#endif
Tim Peters50d8d372001-02-28 05:34:27 +00001985}
Guido van Rossum4d1b3b91998-02-13 23:27:59 +00001986
Guido van Rossum197346f1997-10-31 18:38:52 +00001987#ifdef HAVE_STAT
Victor Stinner4f4402c2010-08-14 14:50:26 +00001988
Guido van Rossum197346f1997-10-31 18:38:52 +00001989/* Helper to look for __init__.py or __init__.py[co] in potential package */
1990static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001991find_init_module(char *buf)
Guido van Rossum197346f1997-10-31 18:38:52 +00001992{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001993 const size_t save_len = strlen(buf);
1994 size_t i = save_len;
1995 char *pname; /* pointer to start of __init__ */
1996 struct stat statbuf;
Guido van Rossum197346f1997-10-31 18:38:52 +00001997
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001998/* For calling case_ok(buf, len, namelen, name):
1999 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
2000 * ^ ^ ^ ^
2001 * |--------------------- buf ---------------------|
2002 * |------------------- len ------------------|
2003 * |------ name -------|
2004 * |----- namelen -----|
Tim Peters0f9431f2001-07-05 03:47:53 +00002005 */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002006 if (save_len + 13 >= MAXPATHLEN)
2007 return 0;
2008 buf[i++] = SEP;
2009 pname = buf + i;
2010 strcpy(pname, "__init__.py");
2011 if (stat(buf, &statbuf) == 0) {
2012 if (case_ok(buf,
2013 save_len + 9, /* len("/__init__") */
2014 8, /* len("__init__") */
2015 pname)) {
2016 buf[save_len] = '\0';
2017 return 1;
2018 }
2019 }
2020 i += strlen(pname);
2021 strcpy(buf+i, Py_OptimizeFlag ? "o" : "c");
2022 if (stat(buf, &statbuf) == 0) {
2023 if (case_ok(buf,
2024 save_len + 9, /* len("/__init__") */
2025 8, /* len("__init__") */
2026 pname)) {
2027 buf[save_len] = '\0';
2028 return 1;
2029 }
2030 }
2031 buf[save_len] = '\0';
2032 return 0;
Guido van Rossum197346f1997-10-31 18:38:52 +00002033}
Guido van Rossum48a680c2001-03-02 06:34:14 +00002034
Guido van Rossum197346f1997-10-31 18:38:52 +00002035#endif /* HAVE_STAT */
2036
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002037
Tim Petersdbd9ba62000-07-09 03:09:57 +00002038static int init_builtin(char *); /* Forward */
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002039
Victor Stinner44c6c152010-08-09 00:59:10 +00002040static PyObject*
2041load_builtin(char *name, char *pathname, int type)
2042{
2043 PyObject *m, *modules;
2044 int err;
2045
2046 if (pathname != NULL && pathname[0] != '\0')
2047 name = pathname;
2048
2049 if (type == C_BUILTIN)
2050 err = init_builtin(name);
2051 else
2052 err = PyImport_ImportFrozenModule(name);
2053 if (err < 0)
2054 return NULL;
2055 if (err == 0) {
2056 PyErr_Format(PyExc_ImportError,
2057 "Purported %s module %.200s not found",
2058 type == C_BUILTIN ?
2059 "builtin" : "frozen",
2060 name);
2061 return NULL;
2062 }
2063
2064 modules = PyImport_GetModuleDict();
2065 m = PyDict_GetItemString(modules, name);
2066 if (m == NULL) {
2067 PyErr_Format(
2068 PyExc_ImportError,
2069 "%s module %.200s not properly initialized",
2070 type == C_BUILTIN ?
2071 "builtin" : "frozen",
2072 name);
2073 return NULL;
2074 }
2075 Py_INCREF(m);
2076 return m;
2077}
2078
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002079/* Load an external module using the default search path and return
Guido van Rossum7f9fa971995-01-20 16:53:12 +00002080 its module object WITH INCREMENTED REFERENCE COUNT */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002081
Guido van Rossum79f25d91997-04-29 20:08:16 +00002082static PyObject *
Alexandre Vassalottie223eb82009-07-29 20:12:15 +00002083load_module(char *name, FILE *fp, char *pathname, int type, PyObject *loader)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002084{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002085 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002086
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002087 /* First check that there's an open file (if we need one) */
2088 switch (type) {
2089 case PY_SOURCE:
2090 case PY_COMPILED:
2091 if (fp == NULL) {
2092 PyErr_Format(PyExc_ValueError,
2093 "file object required for import (type code %d)",
2094 type);
2095 return NULL;
2096 }
2097 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002098
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002099 switch (type) {
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002100
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002101 case PY_SOURCE:
2102 m = load_source_module(name, pathname, fp);
2103 break;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002104
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002105 case PY_COMPILED:
2106 m = load_compiled_module(name, pathname, fp);
2107 break;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002108
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002109#ifdef HAVE_DYNAMIC_LOADING
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002110 case C_EXTENSION:
2111 m = _PyImport_LoadDynamicModule(name, pathname, fp);
2112 break;
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002113#endif
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002114
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002115 case PKG_DIRECTORY:
2116 m = load_package(name, pathname);
2117 break;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002118
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002119 case C_BUILTIN:
2120 case PY_FROZEN:
Victor Stinner44c6c152010-08-09 00:59:10 +00002121 m = load_builtin(name, pathname, type);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002122 break;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002123
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002124 case IMP_HOOK: {
2125 if (loader == NULL) {
2126 PyErr_SetString(PyExc_ImportError,
2127 "import hook without loader");
2128 return NULL;
2129 }
2130 m = PyObject_CallMethod(loader, "load_module", "s", name);
2131 break;
2132 }
Just van Rossum52e14d62002-12-30 22:08:05 +00002133
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002134 default:
2135 PyErr_Format(PyExc_ImportError,
2136 "Don't know how to import %.200s (type code %d)",
2137 name, type);
2138 m = NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002139
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002140 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002141
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002142 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002143}
2144
2145
2146/* Initialize a built-in module.
Thomas Wouters89f507f2006-12-13 04:49:30 +00002147 Return 1 for success, 0 if the module is not found, and -1 with
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002148 an exception set if the initialization failed. */
Guido van Rossum7f133ed1991-02-19 12:23:57 +00002149
Guido van Rossum7f133ed1991-02-19 12:23:57 +00002150static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002151init_builtin(char *name)
Guido van Rossum7f133ed1991-02-19 12:23:57 +00002152{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002153 struct _inittab *p;
Guido van Rossum25ce5661997-08-02 03:10:38 +00002154
Victor Stinner49d3f252010-10-17 01:24:53 +00002155 if (_PyImport_FindBuiltin(name) != NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002156 return 1;
Guido van Rossum25ce5661997-08-02 03:10:38 +00002157
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002158 for (p = PyImport_Inittab; p->name != NULL; p++) {
2159 PyObject *mod;
2160 if (strcmp(name, p->name) == 0) {
2161 if (p->initfunc == NULL) {
2162 PyErr_Format(PyExc_ImportError,
2163 "Cannot re-init internal module %.200s",
2164 name);
2165 return -1;
2166 }
2167 if (Py_VerboseFlag)
2168 PySys_WriteStderr("import %s # builtin\n", name);
2169 mod = (*p->initfunc)();
2170 if (mod == 0)
2171 return -1;
Victor Stinner49d3f252010-10-17 01:24:53 +00002172 if (_PyImport_FixupBuiltin(mod, name) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002173 return -1;
2174 /* FixupExtension has put the module into sys.modules,
2175 so we can release our own reference. */
2176 Py_DECREF(mod);
2177 return 1;
2178 }
2179 }
2180 return 0;
Guido van Rossum7f133ed1991-02-19 12:23:57 +00002181}
Guido van Rossumf56e3db1993-04-01 20:59:32 +00002182
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002183
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002184/* Frozen modules */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002185
Guido van Rossumcfd0a221996-06-17 17:06:34 +00002186static struct _frozen *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002187find_frozen(char *name)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002188{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002189 struct _frozen *p;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002190
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002191 if (!name)
2192 return NULL;
Benjamin Petersond968e272008-11-05 22:48:33 +00002193
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002194 for (p = PyImport_FrozenModules; ; p++) {
2195 if (p->name == NULL)
2196 return NULL;
2197 if (strcmp(p->name, name) == 0)
2198 break;
2199 }
2200 return p;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002201}
2202
Guido van Rossum79f25d91997-04-29 20:08:16 +00002203static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002204get_frozen_object(char *name)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002205{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002206 struct _frozen *p = find_frozen(name);
2207 int size;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002208
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002209 if (p == NULL) {
2210 PyErr_Format(PyExc_ImportError,
2211 "No such frozen object named %.200s",
2212 name);
2213 return NULL;
2214 }
2215 if (p->code == NULL) {
2216 PyErr_Format(PyExc_ImportError,
2217 "Excluded frozen object named %.200s",
2218 name);
2219 return NULL;
2220 }
2221 size = p->size;
2222 if (size < 0)
2223 size = -size;
2224 return PyMarshal_ReadObjectFromString((char *)p->code, size);
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002225}
2226
Brett Cannon8d110132009-03-15 02:20:16 +00002227static PyObject *
2228is_frozen_package(char *name)
2229{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002230 struct _frozen *p = find_frozen(name);
2231 int size;
Brett Cannon8d110132009-03-15 02:20:16 +00002232
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002233 if (p == NULL) {
2234 PyErr_Format(PyExc_ImportError,
2235 "No such frozen object named %.200s",
2236 name);
2237 return NULL;
2238 }
Brett Cannon8d110132009-03-15 02:20:16 +00002239
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002240 size = p->size;
Brett Cannon8d110132009-03-15 02:20:16 +00002241
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002242 if (size < 0)
2243 Py_RETURN_TRUE;
2244 else
2245 Py_RETURN_FALSE;
Brett Cannon8d110132009-03-15 02:20:16 +00002246}
2247
2248
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002249/* Initialize a frozen module.
Brett Cannon3c2ac442009-03-08 20:49:47 +00002250 Return 1 for success, 0 if the module is not found, and -1 with
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002251 an exception set if the initialization failed.
2252 This function is also used from frozenmain.c */
Guido van Rossum0b344901995-02-07 15:35:27 +00002253
2254int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002255PyImport_ImportFrozenModule(char *name)
Guido van Rossumf56e3db1993-04-01 20:59:32 +00002256{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002257 struct _frozen *p = find_frozen(name);
2258 PyObject *co;
2259 PyObject *m;
2260 int ispackage;
2261 int size;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002262
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002263 if (p == NULL)
2264 return 0;
2265 if (p->code == NULL) {
2266 PyErr_Format(PyExc_ImportError,
2267 "Excluded frozen object named %.200s",
2268 name);
2269 return -1;
2270 }
2271 size = p->size;
2272 ispackage = (size < 0);
2273 if (ispackage)
2274 size = -size;
2275 if (Py_VerboseFlag)
2276 PySys_WriteStderr("import %s # frozen%s\n",
2277 name, ispackage ? " package" : "");
2278 co = PyMarshal_ReadObjectFromString((char *)p->code, size);
2279 if (co == NULL)
2280 return -1;
2281 if (!PyCode_Check(co)) {
2282 PyErr_Format(PyExc_TypeError,
2283 "frozen object %.200s is not a code object",
2284 name);
2285 goto err_return;
2286 }
2287 if (ispackage) {
2288 /* Set __path__ to the package name */
2289 PyObject *d, *s, *l;
2290 int err;
2291 m = PyImport_AddModule(name);
2292 if (m == NULL)
2293 goto err_return;
2294 d = PyModule_GetDict(m);
2295 s = PyUnicode_InternFromString(name);
2296 if (s == NULL)
2297 goto err_return;
2298 l = PyList_New(1);
2299 if (l == NULL) {
2300 Py_DECREF(s);
2301 goto err_return;
2302 }
2303 PyList_SET_ITEM(l, 0, s);
2304 err = PyDict_SetItemString(d, "__path__", l);
2305 Py_DECREF(l);
2306 if (err != 0)
2307 goto err_return;
2308 }
2309 m = PyImport_ExecCodeModuleEx(name, co, "<frozen>");
2310 if (m == NULL)
2311 goto err_return;
2312 Py_DECREF(co);
2313 Py_DECREF(m);
2314 return 1;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002315err_return:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002316 Py_DECREF(co);
2317 return -1;
Guido van Rossumf56e3db1993-04-01 20:59:32 +00002318}
Guido van Rossum74e6a111994-08-29 12:54:38 +00002319
2320
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002321/* Import a module, either built-in, frozen, or external, and return
Guido van Rossum7f9fa971995-01-20 16:53:12 +00002322 its module object WITH INCREMENTED REFERENCE COUNT */
Guido van Rossum74e6a111994-08-29 12:54:38 +00002323
Guido van Rossum79f25d91997-04-29 20:08:16 +00002324PyObject *
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00002325PyImport_ImportModule(const char *name)
Guido van Rossum74e6a111994-08-29 12:54:38 +00002326{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002327 PyObject *pname;
2328 PyObject *result;
Marc-André Lemburg3c61c352001-02-09 19:40:15 +00002329
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002330 pname = PyUnicode_FromString(name);
2331 if (pname == NULL)
2332 return NULL;
2333 result = PyImport_Import(pname);
2334 Py_DECREF(pname);
2335 return result;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002336}
2337
Christian Heimes072c0f12008-01-03 23:01:04 +00002338/* Import a module without blocking
2339 *
2340 * At first it tries to fetch the module from sys.modules. If the module was
2341 * never loaded before it loads it with PyImport_ImportModule() unless another
2342 * thread holds the import lock. In the latter case the function raises an
2343 * ImportError instead of blocking.
2344 *
2345 * Returns the module object with incremented ref count.
2346 */
2347PyObject *
2348PyImport_ImportModuleNoBlock(const char *name)
2349{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002350 PyObject *result;
2351 PyObject *modules;
Victor Stinner0af03062011-09-02 00:11:43 +02002352#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002353 long me;
Victor Stinner0af03062011-09-02 00:11:43 +02002354#endif
Christian Heimes072c0f12008-01-03 23:01:04 +00002355
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002356 /* Try to get the module from sys.modules[name] */
2357 modules = PyImport_GetModuleDict();
2358 if (modules == NULL)
2359 return NULL;
Christian Heimes072c0f12008-01-03 23:01:04 +00002360
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002361 result = PyDict_GetItemString(modules, name);
2362 if (result != NULL) {
2363 Py_INCREF(result);
2364 return result;
2365 }
2366 else {
2367 PyErr_Clear();
2368 }
Benjamin Peterson3e4f0552008-09-02 00:31:15 +00002369#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002370 /* check the import lock
2371 * me might be -1 but I ignore the error here, the lock function
2372 * takes care of the problem */
2373 me = PyThread_get_thread_ident();
2374 if (import_lock_thread == -1 || import_lock_thread == me) {
2375 /* no thread or me is holding the lock */
2376 return PyImport_ImportModule(name);
2377 }
2378 else {
2379 PyErr_Format(PyExc_ImportError,
2380 "Failed to import %.200s because the import lock"
2381 "is held by another thread.",
2382 name);
2383 return NULL;
2384 }
Benjamin Peterson3e4f0552008-09-02 00:31:15 +00002385#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002386 return PyImport_ImportModule(name);
Benjamin Peterson3e4f0552008-09-02 00:31:15 +00002387#endif
Christian Heimes072c0f12008-01-03 23:01:04 +00002388}
2389
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002390/* Forward declarations for helper routines */
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002391static PyObject *get_parent(PyObject *globals, char *buf,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002392 Py_ssize_t *p_buflen, int level);
Tim Petersdbd9ba62000-07-09 03:09:57 +00002393static PyObject *load_next(PyObject *mod, PyObject *altmod,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002394 char **p_name, char *buf, Py_ssize_t *p_buflen);
Tim Petersdbd9ba62000-07-09 03:09:57 +00002395static int mark_miss(char *name);
2396static int ensure_fromlist(PyObject *mod, PyObject *fromlist,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002397 char *buf, Py_ssize_t buflen, int recursive);
Tim Petersdbd9ba62000-07-09 03:09:57 +00002398static PyObject * import_submodule(PyObject *mod, char *name, char *fullname);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002399
2400/* The Magnum Opus of dotted-name import :-) */
2401
Guido van Rossum75acc9c1998-03-03 22:26:50 +00002402static PyObject *
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002403import_module_level(char *name, PyObject *globals, PyObject *locals,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002404 PyObject *fromlist, int level)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002405{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002406 char buf[MAXPATHLEN+1];
2407 Py_ssize_t buflen = 0;
2408 PyObject *parent, *head, *next, *tail;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002409
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002410 if (strchr(name, '/') != NULL
Christian Heimes454f37b2008-01-10 00:10:02 +00002411#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002412 || strchr(name, '\\') != NULL
Christian Heimes454f37b2008-01-10 00:10:02 +00002413#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002414 ) {
2415 PyErr_SetString(PyExc_ImportError,
2416 "Import by filename is not supported.");
2417 return NULL;
2418 }
Christian Heimes454f37b2008-01-10 00:10:02 +00002419
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002420 parent = get_parent(globals, buf, &buflen, level);
2421 if (parent == NULL)
2422 return NULL;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002423
Benjamin Peterson556d8002010-06-27 22:37:28 +00002424 head = load_next(parent, level < 0 ? Py_None : parent, &name, buf,
2425 &buflen);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002426 if (head == NULL)
2427 return NULL;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002428
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002429 tail = head;
2430 Py_INCREF(tail);
2431 while (name) {
2432 next = load_next(tail, tail, &name, buf, &buflen);
2433 Py_DECREF(tail);
2434 if (next == NULL) {
2435 Py_DECREF(head);
2436 return NULL;
2437 }
2438 tail = next;
2439 }
2440 if (tail == Py_None) {
2441 /* If tail is Py_None, both get_parent and load_next found
2442 an empty module name: someone called __import__("") or
2443 doctored faulty bytecode */
2444 Py_DECREF(tail);
2445 Py_DECREF(head);
2446 PyErr_SetString(PyExc_ValueError,
2447 "Empty module name");
2448 return NULL;
2449 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002450
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002451 if (fromlist != NULL) {
2452 if (fromlist == Py_None || !PyObject_IsTrue(fromlist))
2453 fromlist = NULL;
2454 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002455
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002456 if (fromlist == NULL) {
2457 Py_DECREF(tail);
2458 return head;
2459 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002460
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002461 Py_DECREF(head);
2462 if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {
2463 Py_DECREF(tail);
2464 return NULL;
2465 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002466
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002467 return tail;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002468}
2469
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002470PyObject *
2471PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002472 PyObject *fromlist, int level)
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002473{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002474 PyObject *result;
2475 _PyImport_AcquireLock();
2476 result = import_module_level(name, globals, locals, fromlist, level);
2477 if (_PyImport_ReleaseLock() < 0) {
2478 Py_XDECREF(result);
2479 PyErr_SetString(PyExc_RuntimeError,
2480 "not holding the import lock");
2481 return NULL;
2482 }
2483 return result;
Guido van Rossum75acc9c1998-03-03 22:26:50 +00002484}
2485
Fred Drake87590902004-05-28 20:21:36 +00002486/* Return the package that an import is being performed in. If globals comes
2487 from the module foo.bar.bat (not itself a package), this returns the
2488 sys.modules entry for foo.bar. If globals is from a package's __init__.py,
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002489 the package's entry in sys.modules is returned, as a borrowed reference.
Fred Drake87590902004-05-28 20:21:36 +00002490
2491 The *name* of the returned package is returned in buf, with the length of
2492 the name in *p_buflen.
2493
2494 If globals doesn't come from a package or a module in a package, or a
2495 corresponding entry is not found in sys.modules, Py_None is returned.
2496*/
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002497static PyObject *
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002498get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen, int level)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002499{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002500 static PyObject *namestr = NULL;
2501 static PyObject *pathstr = NULL;
2502 static PyObject *pkgstr = NULL;
2503 PyObject *pkgname, *modname, *modpath, *modules, *parent;
2504 int orig_level = level;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002505
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002506 if (globals == NULL || !PyDict_Check(globals) || !level)
2507 return Py_None;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002508
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002509 if (namestr == NULL) {
2510 namestr = PyUnicode_InternFromString("__name__");
2511 if (namestr == NULL)
2512 return NULL;
2513 }
2514 if (pathstr == NULL) {
2515 pathstr = PyUnicode_InternFromString("__path__");
2516 if (pathstr == NULL)
2517 return NULL;
2518 }
2519 if (pkgstr == NULL) {
2520 pkgstr = PyUnicode_InternFromString("__package__");
2521 if (pkgstr == NULL)
2522 return NULL;
2523 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002524
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002525 *buf = '\0';
2526 *p_buflen = 0;
2527 pkgname = PyDict_GetItem(globals, pkgstr);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002528
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002529 if ((pkgname != NULL) && (pkgname != Py_None)) {
2530 /* __package__ is set, so use it */
2531 char *pkgname_str;
2532 Py_ssize_t len;
Alexandre Vassalottia85998a2008-05-03 18:24:43 +00002533
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002534 if (!PyUnicode_Check(pkgname)) {
2535 PyErr_SetString(PyExc_ValueError,
2536 "__package__ set to non-string");
2537 return NULL;
2538 }
2539 pkgname_str = _PyUnicode_AsStringAndSize(pkgname, &len);
2540 if (len == 0) {
2541 if (level > 0) {
2542 PyErr_SetString(PyExc_ValueError,
2543 "Attempted relative import in non-package");
2544 return NULL;
2545 }
2546 return Py_None;
2547 }
2548 if (len > MAXPATHLEN) {
2549 PyErr_SetString(PyExc_ValueError,
2550 "Package name too long");
2551 return NULL;
2552 }
2553 strcpy(buf, pkgname_str);
2554 } else {
2555 /* __package__ not set, so figure it out and set it */
2556 modname = PyDict_GetItem(globals, namestr);
2557 if (modname == NULL || !PyUnicode_Check(modname))
2558 return Py_None;
Brett Cannon9a5b25a2010-03-01 02:09:17 +00002559
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002560 modpath = PyDict_GetItem(globals, pathstr);
2561 if (modpath != NULL) {
2562 /* __path__ is set, so modname is already the package name */
2563 char *modname_str;
2564 Py_ssize_t len;
2565 int error;
Alexandre Vassalottia85998a2008-05-03 18:24:43 +00002566
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002567 modname_str = _PyUnicode_AsStringAndSize(modname, &len);
2568 if (len > MAXPATHLEN) {
2569 PyErr_SetString(PyExc_ValueError,
2570 "Module name too long");
2571 return NULL;
2572 }
2573 strcpy(buf, modname_str);
2574 error = PyDict_SetItem(globals, pkgstr, modname);
2575 if (error) {
2576 PyErr_SetString(PyExc_ValueError,
2577 "Could not set __package__");
2578 return NULL;
2579 }
2580 } else {
2581 /* Normal module, so work out the package name if any */
2582 char *start = _PyUnicode_AsString(modname);
2583 char *lastdot = strrchr(start, '.');
2584 size_t len;
2585 int error;
2586 if (lastdot == NULL && level > 0) {
2587 PyErr_SetString(PyExc_ValueError,
2588 "Attempted relative import in non-package");
2589 return NULL;
2590 }
2591 if (lastdot == NULL) {
2592 error = PyDict_SetItem(globals, pkgstr, Py_None);
2593 if (error) {
2594 PyErr_SetString(PyExc_ValueError,
2595 "Could not set __package__");
2596 return NULL;
2597 }
2598 return Py_None;
2599 }
2600 len = lastdot - start;
2601 if (len >= MAXPATHLEN) {
2602 PyErr_SetString(PyExc_ValueError,
2603 "Module name too long");
2604 return NULL;
2605 }
2606 strncpy(buf, start, len);
2607 buf[len] = '\0';
2608 pkgname = PyUnicode_FromString(buf);
2609 if (pkgname == NULL) {
2610 return NULL;
2611 }
2612 error = PyDict_SetItem(globals, pkgstr, pkgname);
2613 Py_DECREF(pkgname);
2614 if (error) {
2615 PyErr_SetString(PyExc_ValueError,
2616 "Could not set __package__");
2617 return NULL;
2618 }
2619 }
2620 }
2621 while (--level > 0) {
2622 char *dot = strrchr(buf, '.');
2623 if (dot == NULL) {
2624 PyErr_SetString(PyExc_ValueError,
2625 "Attempted relative import beyond "
2626 "toplevel package");
2627 return NULL;
2628 }
2629 *dot = '\0';
2630 }
2631 *p_buflen = strlen(buf);
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002632
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002633 modules = PyImport_GetModuleDict();
2634 parent = PyDict_GetItemString(modules, buf);
2635 if (parent == NULL) {
2636 if (orig_level < 1) {
2637 PyObject *err_msg = PyBytes_FromFormat(
2638 "Parent module '%.200s' not found "
2639 "while handling absolute import", buf);
2640 if (err_msg == NULL) {
2641 return NULL;
2642 }
2643 if (!PyErr_WarnEx(PyExc_RuntimeWarning,
2644 PyBytes_AsString(err_msg), 1)) {
2645 *buf = '\0';
2646 *p_buflen = 0;
2647 parent = Py_None;
2648 }
2649 Py_DECREF(err_msg);
2650 } else {
2651 PyErr_Format(PyExc_SystemError,
2652 "Parent module '%.200s' not loaded, "
2653 "cannot perform relative import", buf);
2654 }
2655 }
2656 return parent;
2657 /* We expect, but can't guarantee, if parent != None, that:
2658 - parent.__name__ == buf
2659 - parent.__dict__ is globals
2660 If this is violated... Who cares? */
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002661}
2662
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002663/* altmod is either None or same as mod */
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002664static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002665load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002666 Py_ssize_t *p_buflen)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002667{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002668 char *name = *p_name;
2669 char *dot = strchr(name, '.');
2670 size_t len;
2671 char *p;
2672 PyObject *result;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002673
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002674 if (strlen(name) == 0) {
2675 /* completely empty module name should only happen in
2676 'from . import' (or '__import__("")')*/
2677 Py_INCREF(mod);
2678 *p_name = NULL;
2679 return mod;
2680 }
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002681
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002682 if (dot == NULL) {
2683 *p_name = NULL;
2684 len = strlen(name);
2685 }
2686 else {
2687 *p_name = dot+1;
2688 len = dot-name;
2689 }
2690 if (len == 0) {
2691 PyErr_SetString(PyExc_ValueError,
2692 "Empty module name");
2693 return NULL;
2694 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002695
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002696 p = buf + *p_buflen;
2697 if (p != buf)
2698 *p++ = '.';
2699 if (p+len-buf >= MAXPATHLEN) {
2700 PyErr_SetString(PyExc_ValueError,
2701 "Module name too long");
2702 return NULL;
2703 }
2704 strncpy(p, name, len);
2705 p[len] = '\0';
2706 *p_buflen = p+len-buf;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002707
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002708 result = import_submodule(mod, p, buf);
2709 if (result == Py_None && altmod != mod) {
2710 Py_DECREF(result);
2711 /* Here, altmod must be None and mod must not be None */
2712 result = import_submodule(altmod, p, p);
2713 if (result != NULL && result != Py_None) {
2714 if (mark_miss(buf) != 0) {
2715 Py_DECREF(result);
2716 return NULL;
2717 }
2718 strncpy(buf, name, len);
2719 buf[len] = '\0';
2720 *p_buflen = len;
2721 }
2722 }
2723 if (result == NULL)
2724 return NULL;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002725
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002726 if (result == Py_None) {
2727 Py_DECREF(result);
2728 PyErr_Format(PyExc_ImportError,
2729 "No module named %.200s", name);
2730 return NULL;
2731 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002732
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002733 return result;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002734}
2735
2736static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002737mark_miss(char *name)
Guido van Rossumf5f5fdb1997-09-06 20:29:52 +00002738{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002739 PyObject *modules = PyImport_GetModuleDict();
2740 return PyDict_SetItemString(modules, name, Py_None);
Guido van Rossumf5f5fdb1997-09-06 20:29:52 +00002741}
2742
2743static int
Martin v. Löwis18e16552006-02-15 17:27:45 +00002744ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002745 int recursive)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002746{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002747 int i;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002748
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002749 if (!PyObject_HasAttrString(mod, "__path__"))
2750 return 1;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002751
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002752 for (i = 0; ; i++) {
2753 PyObject *item = PySequence_GetItem(fromlist, i);
2754 int hasit;
2755 if (item == NULL) {
2756 if (PyErr_ExceptionMatches(PyExc_IndexError)) {
2757 PyErr_Clear();
2758 return 1;
2759 }
2760 return 0;
2761 }
2762 if (!PyUnicode_Check(item)) {
2763 PyErr_SetString(PyExc_TypeError,
2764 "Item in ``from list'' not a string");
2765 Py_DECREF(item);
2766 return 0;
2767 }
2768 if (PyUnicode_AS_UNICODE(item)[0] == '*') {
2769 PyObject *all;
2770 Py_DECREF(item);
2771 /* See if the package defines __all__ */
2772 if (recursive)
2773 continue; /* Avoid endless recursion */
2774 all = PyObject_GetAttrString(mod, "__all__");
2775 if (all == NULL)
2776 PyErr_Clear();
2777 else {
2778 int ret = ensure_fromlist(mod, all, buf, buflen, 1);
2779 Py_DECREF(all);
2780 if (!ret)
2781 return 0;
2782 }
2783 continue;
2784 }
2785 hasit = PyObject_HasAttr(mod, item);
2786 if (!hasit) {
2787 PyObject *item8;
2788 char *subname;
2789 PyObject *submod;
2790 char *p;
Victor Stinnerae6265f2010-05-15 16:27:27 +00002791 item8 = PyUnicode_EncodeFSDefault(item);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002792 if (!item8) {
2793 PyErr_SetString(PyExc_ValueError, "Cannot encode path item");
2794 return 0;
2795 }
2796 subname = PyBytes_AS_STRING(item8);
2797 if (buflen + strlen(subname) >= MAXPATHLEN) {
2798 PyErr_SetString(PyExc_ValueError,
2799 "Module name too long");
2800 Py_DECREF(item);
2801 return 0;
2802 }
2803 p = buf + buflen;
2804 *p++ = '.';
2805 strcpy(p, subname);
2806 submod = import_submodule(mod, subname, buf);
2807 Py_DECREF(item8);
2808 Py_XDECREF(submod);
2809 if (submod == NULL) {
2810 Py_DECREF(item);
2811 return 0;
2812 }
2813 }
2814 Py_DECREF(item);
2815 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002816
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002817 /* NOTREACHED */
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002818}
2819
Neil Schemenauer00b09662003-06-16 21:03:07 +00002820static int
2821add_submodule(PyObject *mod, PyObject *submod, char *fullname, char *subname,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002822 PyObject *modules)
Neil Schemenauer00b09662003-06-16 21:03:07 +00002823{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002824 if (mod == Py_None)
2825 return 1;
2826 /* Irrespective of the success of this load, make a
2827 reference to it in the parent package module. A copy gets
2828 saved in the modules dictionary under the full name, so get a
2829 reference from there, if need be. (The exception is when the
2830 load failed with a SyntaxError -- then there's no trace in
2831 sys.modules. In that case, of course, do nothing extra.) */
2832 if (submod == NULL) {
2833 submod = PyDict_GetItemString(modules, fullname);
2834 if (submod == NULL)
2835 return 1;
2836 }
2837 if (PyModule_Check(mod)) {
2838 /* We can't use setattr here since it can give a
2839 * spurious warning if the submodule name shadows a
2840 * builtin name */
2841 PyObject *dict = PyModule_GetDict(mod);
2842 if (!dict)
2843 return 0;
2844 if (PyDict_SetItemString(dict, subname, submod) < 0)
2845 return 0;
2846 }
2847 else {
2848 if (PyObject_SetAttrString(mod, subname, submod) < 0)
2849 return 0;
2850 }
2851 return 1;
Neil Schemenauer00b09662003-06-16 21:03:07 +00002852}
2853
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002854static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002855import_submodule(PyObject *mod, char *subname, char *fullname)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002856{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002857 PyObject *modules = PyImport_GetModuleDict();
2858 PyObject *m = NULL;
Guido van Rossum74e6a111994-08-29 12:54:38 +00002859
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002860 /* Require:
2861 if mod == None: subname == fullname
2862 else: mod.__name__ + "." + subname == fullname
2863 */
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002864
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002865 if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
2866 Py_INCREF(m);
2867 }
2868 else {
2869 PyObject *path, *loader = NULL;
2870 char buf[MAXPATHLEN+1];
2871 struct filedescr *fdp;
2872 FILE *fp = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002873
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002874 if (mod == Py_None)
2875 path = NULL;
2876 else {
2877 path = PyObject_GetAttrString(mod, "__path__");
2878 if (path == NULL) {
2879 PyErr_Clear();
2880 Py_INCREF(Py_None);
2881 return Py_None;
2882 }
2883 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002884
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002885 buf[0] = '\0';
2886 fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
2887 &fp, &loader);
2888 Py_XDECREF(path);
2889 if (fdp == NULL) {
2890 if (!PyErr_ExceptionMatches(PyExc_ImportError))
2891 return NULL;
2892 PyErr_Clear();
2893 Py_INCREF(Py_None);
2894 return Py_None;
2895 }
2896 m = load_module(fullname, fp, buf, fdp->type, loader);
2897 Py_XDECREF(loader);
2898 if (fp)
2899 fclose(fp);
2900 if (!add_submodule(mod, m, fullname, subname, modules)) {
2901 Py_XDECREF(m);
2902 m = NULL;
2903 }
2904 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002905
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002906 return m;
Guido van Rossum74e6a111994-08-29 12:54:38 +00002907}
2908
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002909
2910/* Re-import a module of any kind and return its module object, WITH
2911 INCREMENTED REFERENCE COUNT */
2912
Guido van Rossum79f25d91997-04-29 20:08:16 +00002913PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002914PyImport_ReloadModule(PyObject *m)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002915{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002916 PyInterpreterState *interp = PyThreadState_Get()->interp;
2917 PyObject *modules_reloading = interp->modules_reloading;
2918 PyObject *modules = PyImport_GetModuleDict();
2919 PyObject *path = NULL, *loader = NULL, *existing_m = NULL;
2920 char *name, *subname;
2921 char buf[MAXPATHLEN+1];
2922 struct filedescr *fdp;
2923 FILE *fp = NULL;
2924 PyObject *newm;
Brett Cannon9a5b25a2010-03-01 02:09:17 +00002925
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002926 if (modules_reloading == NULL) {
2927 Py_FatalError("PyImport_ReloadModule: "
2928 "no modules_reloading dictionary!");
2929 return NULL;
2930 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002931
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002932 if (m == NULL || !PyModule_Check(m)) {
2933 PyErr_SetString(PyExc_TypeError,
2934 "reload() argument must be module");
2935 return NULL;
2936 }
2937 name = (char*)PyModule_GetName(m);
2938 if (name == NULL)
2939 return NULL;
2940 if (m != PyDict_GetItemString(modules, name)) {
2941 PyErr_Format(PyExc_ImportError,
2942 "reload(): module %.200s not in sys.modules",
2943 name);
2944 return NULL;
2945 }
2946 existing_m = PyDict_GetItemString(modules_reloading, name);
2947 if (existing_m != NULL) {
2948 /* Due to a recursive reload, this module is already
2949 being reloaded. */
2950 Py_INCREF(existing_m);
2951 return existing_m;
2952 }
2953 if (PyDict_SetItemString(modules_reloading, name, m) < 0)
2954 return NULL;
Guido van Rossumd8faa362007-04-27 19:54:29 +00002955
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002956 subname = strrchr(name, '.');
2957 if (subname == NULL)
2958 subname = name;
2959 else {
2960 PyObject *parentname, *parent;
2961 parentname = PyUnicode_FromStringAndSize(name, (subname-name));
2962 if (parentname == NULL) {
2963 imp_modules_reloading_clear();
2964 return NULL;
2965 }
2966 parent = PyDict_GetItem(modules, parentname);
2967 if (parent == NULL) {
2968 PyErr_Format(PyExc_ImportError,
2969 "reload(): parent %U not in sys.modules",
2970 parentname);
2971 Py_DECREF(parentname);
2972 imp_modules_reloading_clear();
2973 return NULL;
2974 }
2975 Py_DECREF(parentname);
2976 subname++;
2977 path = PyObject_GetAttrString(parent, "__path__");
2978 if (path == NULL)
2979 PyErr_Clear();
2980 }
2981 buf[0] = '\0';
2982 fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader);
2983 Py_XDECREF(path);
Phillip J. Eby7ec642a2004-09-23 04:37:36 +00002984
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002985 if (fdp == NULL) {
2986 Py_XDECREF(loader);
2987 imp_modules_reloading_clear();
2988 return NULL;
2989 }
Phillip J. Eby7ec642a2004-09-23 04:37:36 +00002990
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002991 newm = load_module(name, fp, buf, fdp->type, loader);
2992 Py_XDECREF(loader);
Phillip J. Eby7ec642a2004-09-23 04:37:36 +00002993
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002994 if (fp)
2995 fclose(fp);
2996 if (newm == NULL) {
2997 /* load_module probably removed name from modules because of
2998 * the error. Put back the original module object. We're
2999 * going to return NULL in this case regardless of whether
3000 * replacing name succeeds, so the return value is ignored.
3001 */
3002 PyDict_SetItemString(modules, name, m);
3003 }
3004 imp_modules_reloading_clear();
3005 return newm;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003006}
3007
3008
Guido van Rossumd47a0a81997-08-14 20:11:26 +00003009/* Higher-level import emulator which emulates the "import" statement
3010 more accurately -- it invokes the __import__() function from the
3011 builtins of the current globals. This means that the import is
3012 done using whatever import hooks are installed in the current
Brett Cannonbc2eff32010-09-19 21:39:02 +00003013 environment.
Guido van Rossum6058eb41998-12-21 19:51:00 +00003014 A dummy list ["__doc__"] is passed as the 4th argument so that
Neal Norwitz80e7f272007-08-26 06:45:23 +00003015 e.g. PyImport_Import(PyUnicode_FromString("win32com.client.gencache"))
Guido van Rossum6058eb41998-12-21 19:51:00 +00003016 will return <module "gencache"> instead of <module "win32com">. */
Guido van Rossumd47a0a81997-08-14 20:11:26 +00003017
3018PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003019PyImport_Import(PyObject *module_name)
Guido van Rossumd47a0a81997-08-14 20:11:26 +00003020{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003021 static PyObject *silly_list = NULL;
3022 static PyObject *builtins_str = NULL;
3023 static PyObject *import_str = NULL;
3024 PyObject *globals = NULL;
3025 PyObject *import = NULL;
3026 PyObject *builtins = NULL;
Brett Cannonbc2eff32010-09-19 21:39:02 +00003027 PyObject *modules = NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003028 PyObject *r = NULL;
Guido van Rossumd47a0a81997-08-14 20:11:26 +00003029
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003030 /* Initialize constant string objects */
3031 if (silly_list == NULL) {
3032 import_str = PyUnicode_InternFromString("__import__");
3033 if (import_str == NULL)
3034 return NULL;
3035 builtins_str = PyUnicode_InternFromString("__builtins__");
3036 if (builtins_str == NULL)
3037 return NULL;
Brett Cannonbc2eff32010-09-19 21:39:02 +00003038 silly_list = PyList_New(0);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003039 if (silly_list == NULL)
3040 return NULL;
3041 }
Guido van Rossumd47a0a81997-08-14 20:11:26 +00003042
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003043 /* Get the builtins from current globals */
3044 globals = PyEval_GetGlobals();
3045 if (globals != NULL) {
3046 Py_INCREF(globals);
3047 builtins = PyObject_GetItem(globals, builtins_str);
3048 if (builtins == NULL)
3049 goto err;
3050 }
3051 else {
3052 /* No globals -- use standard builtins, and fake globals */
3053 builtins = PyImport_ImportModuleLevel("builtins",
3054 NULL, NULL, NULL, 0);
3055 if (builtins == NULL)
3056 return NULL;
3057 globals = Py_BuildValue("{OO}", builtins_str, builtins);
3058 if (globals == NULL)
3059 goto err;
3060 }
Guido van Rossumd47a0a81997-08-14 20:11:26 +00003061
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003062 /* Get the __import__ function from the builtins */
3063 if (PyDict_Check(builtins)) {
3064 import = PyObject_GetItem(builtins, import_str);
3065 if (import == NULL)
3066 PyErr_SetObject(PyExc_KeyError, import_str);
3067 }
3068 else
3069 import = PyObject_GetAttr(builtins, import_str);
3070 if (import == NULL)
3071 goto err;
Guido van Rossumd47a0a81997-08-14 20:11:26 +00003072
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003073 /* Call the __import__ function with the proper argument list
Brett Cannonbc2eff32010-09-19 21:39:02 +00003074 Always use absolute import here.
3075 Calling for side-effect of import. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003076 r = PyObject_CallFunction(import, "OOOOi", module_name, globals,
3077 globals, silly_list, 0, NULL);
Brett Cannonbc2eff32010-09-19 21:39:02 +00003078 if (r == NULL)
3079 goto err;
3080 Py_DECREF(r);
3081
3082 modules = PyImport_GetModuleDict();
3083 r = PyDict_GetItem(modules, module_name);
3084 if (r != NULL)
3085 Py_INCREF(r);
Guido van Rossumd47a0a81997-08-14 20:11:26 +00003086
3087 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003088 Py_XDECREF(globals);
3089 Py_XDECREF(builtins);
3090 Py_XDECREF(import);
Tim Peters50d8d372001-02-28 05:34:27 +00003091
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003092 return r;
Guido van Rossumd47a0a81997-08-14 20:11:26 +00003093}
3094
3095
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003096/* Module 'imp' provides Python access to the primitives used for
3097 importing modules.
3098*/
3099
Guido van Rossum79f25d91997-04-29 20:08:16 +00003100static PyObject *
Barry Warsaw28a691b2010-04-17 00:19:56 +00003101imp_make_magic(long magic)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003102{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003103 char buf[4];
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003104
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003105 buf[0] = (char) ((magic >> 0) & 0xff);
3106 buf[1] = (char) ((magic >> 8) & 0xff);
3107 buf[2] = (char) ((magic >> 16) & 0xff);
3108 buf[3] = (char) ((magic >> 24) & 0xff);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003109
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003110 return PyBytes_FromStringAndSize(buf, 4);
Victor Stinner3e2b7172010-11-09 09:32:19 +00003111}
Barry Warsaw28a691b2010-04-17 00:19:56 +00003112
3113static PyObject *
3114imp_get_magic(PyObject *self, PyObject *noargs)
3115{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003116 return imp_make_magic(pyc_magic);
Barry Warsaw28a691b2010-04-17 00:19:56 +00003117}
3118
3119static PyObject *
3120imp_get_tag(PyObject *self, PyObject *noargs)
3121{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003122 return PyUnicode_FromString(pyc_tag);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003123}
3124
Guido van Rossum79f25d91997-04-29 20:08:16 +00003125static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +00003126imp_get_suffixes(PyObject *self, PyObject *noargs)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003127{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003128 PyObject *list;
3129 struct filedescr *fdp;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003130
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003131 list = PyList_New(0);
3132 if (list == NULL)
3133 return NULL;
3134 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
3135 PyObject *item = Py_BuildValue("ssi",
3136 fdp->suffix, fdp->mode, fdp->type);
3137 if (item == NULL) {
3138 Py_DECREF(list);
3139 return NULL;
3140 }
3141 if (PyList_Append(list, item) < 0) {
3142 Py_DECREF(list);
3143 Py_DECREF(item);
3144 return NULL;
3145 }
3146 Py_DECREF(item);
3147 }
3148 return list;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003149}
3150
Guido van Rossum79f25d91997-04-29 20:08:16 +00003151static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003152call_find_module(char *name, PyObject *path)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003153{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003154 extern int fclose(FILE *);
3155 PyObject *fob, *ret;
3156 PyObject *pathobj;
3157 struct filedescr *fdp;
3158 char pathname[MAXPATHLEN+1];
3159 FILE *fp = NULL;
3160 int fd = -1;
3161 char *found_encoding = NULL;
3162 char *encoding = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003163
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003164 pathname[0] = '\0';
3165 if (path == Py_None)
3166 path = NULL;
3167 fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL);
3168 if (fdp == NULL)
3169 return NULL;
3170 if (fp != NULL) {
3171 fd = fileno(fp);
3172 if (fd != -1)
3173 fd = dup(fd);
3174 fclose(fp);
3175 fp = NULL;
3176 }
3177 if (fd != -1) {
3178 if (strchr(fdp->mode, 'b') == NULL) {
3179 /* PyTokenizer_FindEncoding() returns PyMem_MALLOC'ed
3180 memory. */
3181 found_encoding = PyTokenizer_FindEncoding(fd);
3182 lseek(fd, 0, 0); /* Reset position */
3183 if (found_encoding == NULL && PyErr_Occurred())
3184 return NULL;
3185 encoding = (found_encoding != NULL) ? found_encoding :
3186 (char*)PyUnicode_GetDefaultEncoding();
3187 }
3188 fob = PyFile_FromFd(fd, pathname, fdp->mode, -1,
3189 (char*)encoding, NULL, NULL, 1);
3190 if (fob == NULL) {
3191 close(fd);
3192 PyMem_FREE(found_encoding);
3193 return NULL;
3194 }
3195 }
3196 else {
3197 fob = Py_None;
3198 Py_INCREF(fob);
3199 }
3200 pathobj = PyUnicode_DecodeFSDefault(pathname);
3201 ret = Py_BuildValue("NN(ssi)",
3202 fob, pathobj, fdp->suffix, fdp->mode, fdp->type);
3203 PyMem_FREE(found_encoding);
Brett Cannon3bb42d92007-10-20 03:43:15 +00003204
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003205 return ret;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003206}
3207
Guido van Rossum79f25d91997-04-29 20:08:16 +00003208static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003209imp_find_module(PyObject *self, PyObject *args)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003210{
Victor Stinnerebc00522010-12-03 17:06:43 +00003211 PyObject *name;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003212 PyObject *ret, *path = NULL;
Victor Stinnerebc00522010-12-03 17:06:43 +00003213 if (!PyArg_ParseTuple(args, "O&|O:find_module",
3214 PyUnicode_FSConverter, &name,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003215 &path))
3216 return NULL;
Victor Stinnerebc00522010-12-03 17:06:43 +00003217 ret = call_find_module(PyBytes_AS_STRING(name), path);
3218 Py_DECREF(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003219 return ret;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003220}
3221
3222static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003223imp_init_builtin(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003224{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003225 char *name;
3226 int ret;
3227 PyObject *m;
3228 if (!PyArg_ParseTuple(args, "s:init_builtin", &name))
3229 return NULL;
3230 ret = init_builtin(name);
3231 if (ret < 0)
3232 return NULL;
3233 if (ret == 0) {
3234 Py_INCREF(Py_None);
3235 return Py_None;
3236 }
3237 m = PyImport_AddModule(name);
3238 Py_XINCREF(m);
3239 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003240}
3241
Guido van Rossum79f25d91997-04-29 20:08:16 +00003242static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003243imp_init_frozen(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003244{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003245 char *name;
3246 int ret;
3247 PyObject *m;
3248 if (!PyArg_ParseTuple(args, "s:init_frozen", &name))
3249 return NULL;
3250 ret = PyImport_ImportFrozenModule(name);
3251 if (ret < 0)
3252 return NULL;
3253 if (ret == 0) {
3254 Py_INCREF(Py_None);
3255 return Py_None;
3256 }
3257 m = PyImport_AddModule(name);
3258 Py_XINCREF(m);
3259 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003260}
3261
Guido van Rossum79f25d91997-04-29 20:08:16 +00003262static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003263imp_get_frozen_object(PyObject *self, PyObject *args)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00003264{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003265 char *name;
Jack Jansen95ffa231995-10-03 14:38:41 +00003266
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003267 if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name))
3268 return NULL;
3269 return get_frozen_object(name);
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00003270}
3271
Guido van Rossum79f25d91997-04-29 20:08:16 +00003272static PyObject *
Brett Cannon8d110132009-03-15 02:20:16 +00003273imp_is_frozen_package(PyObject *self, PyObject *args)
3274{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003275 char *name;
Brett Cannon8d110132009-03-15 02:20:16 +00003276
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003277 if (!PyArg_ParseTuple(args, "s:is_frozen_package", &name))
3278 return NULL;
3279 return is_frozen_package(name);
Brett Cannon8d110132009-03-15 02:20:16 +00003280}
3281
3282static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003283imp_is_builtin(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003284{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003285 char *name;
3286 if (!PyArg_ParseTuple(args, "s:is_builtin", &name))
3287 return NULL;
3288 return PyLong_FromLong(is_builtin(name));
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003289}
3290
Guido van Rossum79f25d91997-04-29 20:08:16 +00003291static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003292imp_is_frozen(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003293{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003294 char *name;
3295 struct _frozen *p;
3296 if (!PyArg_ParseTuple(args, "s:is_frozen", &name))
3297 return NULL;
3298 p = find_frozen(name);
3299 return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003300}
3301
3302static FILE *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003303get_file(char *pathname, PyObject *fob, char *mode)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003304{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003305 FILE *fp;
3306 if (mode[0] == 'U')
3307 mode = "r" PY_STDIOTEXTMODE;
3308 if (fob == NULL) {
3309 fp = fopen(pathname, mode);
3310 }
3311 else {
3312 int fd = PyObject_AsFileDescriptor(fob);
3313 if (fd == -1)
3314 return NULL;
3315 if (!_PyVerify_fd(fd))
3316 goto error;
3317 /* the FILE struct gets a new fd, so that it can be closed
3318 * independently of the file descriptor given
3319 */
3320 fd = dup(fd);
3321 if (fd == -1)
3322 goto error;
3323 fp = fdopen(fd, mode);
3324 }
3325 if (fp)
3326 return fp;
Kristján Valur Jónssone1b04452009-03-31 17:43:39 +00003327error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003328 PyErr_SetFromErrno(PyExc_IOError);
3329 return NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003330}
3331
Guido van Rossum79f25d91997-04-29 20:08:16 +00003332static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003333imp_load_compiled(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003334{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003335 char *name;
Victor Stinnerebc00522010-12-03 17:06:43 +00003336 PyObject *pathname;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003337 PyObject *fob = NULL;
3338 PyObject *m;
3339 FILE *fp;
Victor Stinnerebc00522010-12-03 17:06:43 +00003340 if (!PyArg_ParseTuple(args, "sO&|O:load_compiled",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003341 &name,
Victor Stinnerebc00522010-12-03 17:06:43 +00003342 PyUnicode_FSConverter, &pathname,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003343 &fob))
3344 return NULL;
Victor Stinnerebc00522010-12-03 17:06:43 +00003345 fp = get_file(PyBytes_AS_STRING(pathname), fob, "rb");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003346 if (fp == NULL) {
Victor Stinnerebc00522010-12-03 17:06:43 +00003347 Py_DECREF(pathname);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003348 return NULL;
3349 }
Victor Stinnerebc00522010-12-03 17:06:43 +00003350 m = load_compiled_module(name, PyBytes_AS_STRING(pathname), fp);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003351 fclose(fp);
Victor Stinnerebc00522010-12-03 17:06:43 +00003352 Py_DECREF(pathname);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003353 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003354}
3355
Guido van Rossum96a8fb71999-12-22 14:09:35 +00003356#ifdef HAVE_DYNAMIC_LOADING
3357
Guido van Rossum79f25d91997-04-29 20:08:16 +00003358static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003359imp_load_dynamic(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003360{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003361 char *name;
Victor Stinner8dbf6292010-10-15 12:48:01 +00003362 PyObject *pathbytes;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003363 char *pathname;
3364 PyObject *fob = NULL;
3365 PyObject *m;
3366 FILE *fp = NULL;
Victor Stinner8dbf6292010-10-15 12:48:01 +00003367 if (!PyArg_ParseTuple(args, "sO&|O:load_dynamic",
3368 &name, PyUnicode_FSConverter, &pathbytes, &fob))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003369 return NULL;
Victor Stinner8dbf6292010-10-15 12:48:01 +00003370 pathname = PyBytes_AS_STRING(pathbytes);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003371 if (fob) {
3372 fp = get_file(pathname, fob, "r");
3373 if (fp == NULL) {
Victor Stinner8dbf6292010-10-15 12:48:01 +00003374 Py_DECREF(pathbytes);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003375 return NULL;
3376 }
3377 }
3378 m = _PyImport_LoadDynamicModule(name, pathname, fp);
Victor Stinner8dbf6292010-10-15 12:48:01 +00003379 Py_DECREF(pathbytes);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003380 if (fp)
3381 fclose(fp);
3382 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003383}
3384
Guido van Rossum96a8fb71999-12-22 14:09:35 +00003385#endif /* HAVE_DYNAMIC_LOADING */
3386
Guido van Rossum79f25d91997-04-29 20:08:16 +00003387static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003388imp_load_source(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003389{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003390 char *name;
Victor Stinnerebc00522010-12-03 17:06:43 +00003391 PyObject *pathname;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003392 PyObject *fob = NULL;
3393 PyObject *m;
3394 FILE *fp;
Victor Stinnerebc00522010-12-03 17:06:43 +00003395 if (!PyArg_ParseTuple(args, "sO&|O:load_source",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003396 &name,
Victor Stinnerebc00522010-12-03 17:06:43 +00003397 PyUnicode_FSConverter, &pathname,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003398 &fob))
3399 return NULL;
Victor Stinnerebc00522010-12-03 17:06:43 +00003400 fp = get_file(PyBytes_AS_STRING(pathname), fob, "r");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003401 if (fp == NULL) {
Victor Stinnerebc00522010-12-03 17:06:43 +00003402 Py_DECREF(pathname);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003403 return NULL;
3404 }
Victor Stinnerebc00522010-12-03 17:06:43 +00003405 m = load_source_module(name, PyBytes_AS_STRING(pathname), fp);
3406 Py_DECREF(pathname);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003407 fclose(fp);
3408 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003409}
3410
Guido van Rossum79f25d91997-04-29 20:08:16 +00003411static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003412imp_load_module(PyObject *self, PyObject *args)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003413{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003414 char *name;
3415 PyObject *fob;
Victor Stinner1a563032010-10-15 22:43:10 +00003416 PyObject *pathname;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003417 PyObject * ret;
3418 char *suffix; /* Unused */
3419 char *mode;
3420 int type;
3421 FILE *fp;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003422
Victor Stinner1a563032010-10-15 22:43:10 +00003423 if (!PyArg_ParseTuple(args, "sOO&(ssi):load_module",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003424 &name, &fob,
Victor Stinner1a563032010-10-15 22:43:10 +00003425 PyUnicode_FSConverter, &pathname,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003426 &suffix, &mode, &type))
3427 return NULL;
3428 if (*mode) {
3429 /* Mode must start with 'r' or 'U' and must not contain '+'.
3430 Implicit in this test is the assumption that the mode
3431 may contain other modifiers like 'b' or 't'. */
Guido van Rossum5e2c5fa2002-05-30 17:33:07 +00003432
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003433 if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) {
3434 PyErr_Format(PyExc_ValueError,
3435 "invalid file open mode %.200s", mode);
Victor Stinner1a563032010-10-15 22:43:10 +00003436 Py_DECREF(pathname);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003437 return NULL;
3438 }
3439 }
3440 if (fob == Py_None)
3441 fp = NULL;
3442 else {
3443 fp = get_file(NULL, fob, mode);
3444 if (fp == NULL) {
Victor Stinner1a563032010-10-15 22:43:10 +00003445 Py_DECREF(pathname);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003446 return NULL;
3447 }
3448 }
Victor Stinner1a563032010-10-15 22:43:10 +00003449 ret = load_module(name, fp, PyBytes_AS_STRING(pathname), type, NULL);
3450 Py_DECREF(pathname);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003451 if (fp)
3452 fclose(fp);
3453 return ret;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003454}
3455
3456static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003457imp_load_package(PyObject *self, PyObject *args)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003458{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003459 char *name;
Victor Stinnerebc00522010-12-03 17:06:43 +00003460 PyObject *pathname;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003461 PyObject * ret;
Victor Stinnerebc00522010-12-03 17:06:43 +00003462 if (!PyArg_ParseTuple(args, "sO&:load_package",
3463 &name, PyUnicode_FSConverter, &pathname))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003464 return NULL;
Victor Stinnerebc00522010-12-03 17:06:43 +00003465 ret = load_package(name, PyBytes_AS_STRING(pathname));
3466 Py_DECREF(pathname);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003467 return ret;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003468}
3469
3470static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003471imp_new_module(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003472{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003473 char *name;
3474 if (!PyArg_ParseTuple(args, "s:new_module", &name))
3475 return NULL;
3476 return PyModule_New(name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003477}
3478
Christian Heimes13a7a212008-01-07 17:13:09 +00003479static PyObject *
3480imp_reload(PyObject *self, PyObject *v)
3481{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003482 return PyImport_ReloadModule(v);
Christian Heimes13a7a212008-01-07 17:13:09 +00003483}
3484
3485PyDoc_STRVAR(doc_reload,
3486"reload(module) -> module\n\
3487\n\
3488Reload the module. The module must have been successfully imported before.");
3489
Barry Warsaw28a691b2010-04-17 00:19:56 +00003490static PyObject *
3491imp_cache_from_source(PyObject *self, PyObject *args, PyObject *kws)
3492{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003493 static char *kwlist[] = {"path", "debug_override", NULL};
Barry Warsaw28a691b2010-04-17 00:19:56 +00003494
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003495 char buf[MAXPATHLEN+1];
Victor Stinner3ea23dd2010-10-15 20:34:32 +00003496 PyObject *pathbytes;
3497 char *cpathname;
Benjamin Peterson294a9fc2010-10-16 03:12:39 +00003498 PyObject *debug_override = NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003499 int debug = !Py_OptimizeFlag;
Barry Warsaw28a691b2010-04-17 00:19:56 +00003500
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003501 if (!PyArg_ParseTupleAndKeywords(
Victor Stinner3ea23dd2010-10-15 20:34:32 +00003502 args, kws, "O&|O", kwlist,
3503 PyUnicode_FSConverter, &pathbytes, &debug_override))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003504 return NULL;
Barry Warsaw28a691b2010-04-17 00:19:56 +00003505
Benjamin Peterson294a9fc2010-10-16 03:12:39 +00003506 if (debug_override != NULL &&
3507 (debug = PyObject_IsTrue(debug_override)) < 0) {
3508 Py_DECREF(pathbytes);
3509 return NULL;
3510 }
Barry Warsaw28a691b2010-04-17 00:19:56 +00003511
Victor Stinner3ea23dd2010-10-15 20:34:32 +00003512 cpathname = make_compiled_pathname(
3513 PyBytes_AS_STRING(pathbytes),
3514 buf, MAXPATHLEN+1, debug);
3515 Py_DECREF(pathbytes);
Barry Warsaw28a691b2010-04-17 00:19:56 +00003516
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003517 if (cpathname == NULL) {
3518 PyErr_Format(PyExc_SystemError, "path buffer too short");
3519 return NULL;
3520 }
Victor Stinner88bd8912010-10-15 22:46:07 +00003521 return PyUnicode_DecodeFSDefault(buf);
Barry Warsaw28a691b2010-04-17 00:19:56 +00003522}
3523
3524PyDoc_STRVAR(doc_cache_from_source,
3525"Given the path to a .py file, return the path to its .pyc/.pyo file.\n\
3526\n\
3527The .py file does not need to exist; this simply returns the path to the\n\
3528.pyc/.pyo file calculated as if the .py file were imported. The extension\n\
3529will be .pyc unless __debug__ is not defined, then it will be .pyo.\n\
3530\n\
3531If debug_override is not None, then it must be a boolean and is taken as\n\
3532the value of __debug__ instead.");
3533
3534static PyObject *
3535imp_source_from_cache(PyObject *self, PyObject *args, PyObject *kws)
3536{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003537 static char *kwlist[] = {"path", NULL};
Barry Warsaw28a691b2010-04-17 00:19:56 +00003538
Victor Stinnerebc00522010-12-03 17:06:43 +00003539 PyObject *pathname_obj;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003540 char *pathname;
3541 char buf[MAXPATHLEN+1];
Barry Warsaw28a691b2010-04-17 00:19:56 +00003542
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003543 if (!PyArg_ParseTupleAndKeywords(
Victor Stinnerebc00522010-12-03 17:06:43 +00003544 args, kws, "O&", kwlist,
3545 PyUnicode_FSConverter, &pathname_obj))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003546 return NULL;
Barry Warsaw28a691b2010-04-17 00:19:56 +00003547
Victor Stinnerebc00522010-12-03 17:06:43 +00003548 pathname = PyBytes_AS_STRING(pathname_obj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003549 if (make_source_pathname(pathname, buf) == NULL) {
3550 PyErr_Format(PyExc_ValueError, "Not a PEP 3147 pyc path: %s",
3551 pathname);
Victor Stinnerebc00522010-12-03 17:06:43 +00003552 Py_DECREF(pathname_obj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003553 return NULL;
3554 }
Victor Stinnerebc00522010-12-03 17:06:43 +00003555 Py_DECREF(pathname_obj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003556 return PyUnicode_FromString(buf);
Barry Warsaw28a691b2010-04-17 00:19:56 +00003557}
3558
3559PyDoc_STRVAR(doc_source_from_cache,
3560"Given the path to a .pyc./.pyo file, return the path to its .py file.\n\
3561\n\
3562The .pyc/.pyo file does not need to exist; this simply returns the path to\n\
3563the .py file calculated to correspond to the .pyc/.pyo file. If path\n\
3564does not conform to PEP 3147 format, ValueError will be raised.");
3565
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003566/* Doc strings */
3567
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003568PyDoc_STRVAR(doc_imp,
3569"This module provides the components needed to build your own\n\
3570__import__ function. Undocumented functions are obsolete.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003571
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003572PyDoc_STRVAR(doc_find_module,
3573"find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003574Search for a module. If path is omitted or None, search for a\n\
3575built-in, frozen or special module and continue search in sys.path.\n\
3576The module name cannot contain '.'; to search for a submodule of a\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003577package, pass the submodule name and the package's __path__.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003578
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003579PyDoc_STRVAR(doc_load_module,
3580"load_module(name, file, filename, (suffix, mode, type)) -> module\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003581Load a module, given information returned by find_module().\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003582The module name must include the full package name, if any.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003583
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003584PyDoc_STRVAR(doc_get_magic,
3585"get_magic() -> string\n\
3586Return the magic number for .pyc or .pyo files.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003587
Barry Warsaw28a691b2010-04-17 00:19:56 +00003588PyDoc_STRVAR(doc_get_tag,
3589"get_tag() -> string\n\
3590Return the magic tag for .pyc or .pyo files.");
3591
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003592PyDoc_STRVAR(doc_get_suffixes,
3593"get_suffixes() -> [(suffix, mode, type), ...]\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003594Return a list of (suffix, mode, type) tuples describing the files\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003595that find_module() looks for.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003596
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003597PyDoc_STRVAR(doc_new_module,
3598"new_module(name) -> module\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003599Create a new module. Do not enter it in sys.modules.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003600The module name must include the full package name, if any.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00003601
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003602PyDoc_STRVAR(doc_lock_held,
Tim Petersa7c65092004-08-01 23:26:05 +00003603"lock_held() -> boolean\n\
3604Return True if the import lock is currently held, else False.\n\
3605On platforms without threads, return False.");
Tim Peters69232342001-08-30 05:16:13 +00003606
Guido van Rossumc4f4ca92003-02-12 21:46:11 +00003607PyDoc_STRVAR(doc_acquire_lock,
3608"acquire_lock() -> None\n\
Neal Norwitz2294c0d2003-02-12 23:02:21 +00003609Acquires the interpreter's import lock for the current thread.\n\
3610This lock should be used by import hooks to ensure thread-safety\n\
3611when importing modules.\n\
Guido van Rossumc4f4ca92003-02-12 21:46:11 +00003612On platforms without threads, this function does nothing.");
3613
3614PyDoc_STRVAR(doc_release_lock,
3615"release_lock() -> None\n\
3616Release the interpreter's import lock.\n\
3617On platforms without threads, this function does nothing.");
3618
Guido van Rossum79f25d91997-04-29 20:08:16 +00003619static PyMethodDef imp_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003620 {"find_module", imp_find_module, METH_VARARGS, doc_find_module},
3621 {"get_magic", imp_get_magic, METH_NOARGS, doc_get_magic},
3622 {"get_tag", imp_get_tag, METH_NOARGS, doc_get_tag},
3623 {"get_suffixes", imp_get_suffixes, METH_NOARGS, doc_get_suffixes},
3624 {"load_module", imp_load_module, METH_VARARGS, doc_load_module},
3625 {"new_module", imp_new_module, METH_VARARGS, doc_new_module},
3626 {"lock_held", imp_lock_held, METH_NOARGS, doc_lock_held},
3627 {"acquire_lock", imp_acquire_lock, METH_NOARGS, doc_acquire_lock},
3628 {"release_lock", imp_release_lock, METH_NOARGS, doc_release_lock},
3629 {"reload", imp_reload, METH_O, doc_reload},
3630 {"cache_from_source", (PyCFunction)imp_cache_from_source,
3631 METH_VARARGS | METH_KEYWORDS, doc_cache_from_source},
3632 {"source_from_cache", (PyCFunction)imp_source_from_cache,
3633 METH_VARARGS | METH_KEYWORDS, doc_source_from_cache},
3634 /* The rest are obsolete */
3635 {"get_frozen_object", imp_get_frozen_object, METH_VARARGS},
3636 {"is_frozen_package", imp_is_frozen_package, METH_VARARGS},
3637 {"init_builtin", imp_init_builtin, METH_VARARGS},
3638 {"init_frozen", imp_init_frozen, METH_VARARGS},
3639 {"is_builtin", imp_is_builtin, METH_VARARGS},
3640 {"is_frozen", imp_is_frozen, METH_VARARGS},
3641 {"load_compiled", imp_load_compiled, METH_VARARGS},
Guido van Rossum96a8fb71999-12-22 14:09:35 +00003642#ifdef HAVE_DYNAMIC_LOADING
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003643 {"load_dynamic", imp_load_dynamic, METH_VARARGS},
Guido van Rossum96a8fb71999-12-22 14:09:35 +00003644#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003645 {"load_package", imp_load_package, METH_VARARGS},
3646 {"load_source", imp_load_source, METH_VARARGS},
3647 {NULL, NULL} /* sentinel */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003648};
3649
Guido van Rossum1a8791e1998-08-04 22:46:29 +00003650static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003651setint(PyObject *d, char *name, int value)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003652{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003653 PyObject *v;
3654 int err;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003655
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003656 v = PyLong_FromLong((long)value);
3657 err = PyDict_SetItemString(d, name, v);
3658 Py_XDECREF(v);
3659 return err;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003660}
3661
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003662typedef struct {
3663 PyObject_HEAD
3664} NullImporter;
3665
3666static int
3667NullImporter_init(NullImporter *self, PyObject *args, PyObject *kwds)
3668{
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003669#ifndef MS_WINDOWS
3670 PyObject *path;
3671 struct stat statbuf;
3672 int rv;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003673
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003674 if (!_PyArg_NoKeywords("NullImporter()", kwds))
3675 return -1;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003676
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003677 if (!PyArg_ParseTuple(args, "O&:NullImporter",
3678 PyUnicode_FSConverter, &path))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003679 return -1;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003680
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003681 if (PyBytes_GET_SIZE(path) == 0) {
3682 Py_DECREF(path);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003683 PyErr_SetString(PyExc_ImportError, "empty pathname");
3684 return -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003685 }
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003686
3687 rv = stat(PyBytes_AS_STRING(path), &statbuf);
3688 Py_DECREF(path);
3689 if (rv == 0) {
3690 /* it exists */
3691 if (S_ISDIR(statbuf.st_mode)) {
3692 /* it's a directory */
3693 PyErr_SetString(PyExc_ImportError, "existing directory");
3694 return -1;
3695 }
3696 }
3697#else /* MS_WINDOWS */
3698 PyObject *pathobj;
3699 DWORD rv;
Victor Stinner255dfdb2010-09-29 10:28:51 +00003700 wchar_t *path;
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003701
3702 if (!_PyArg_NoKeywords("NullImporter()", kwds))
3703 return -1;
3704
3705 if (!PyArg_ParseTuple(args, "U:NullImporter",
3706 &pathobj))
3707 return -1;
3708
3709 if (PyUnicode_GET_SIZE(pathobj) == 0) {
3710 PyErr_SetString(PyExc_ImportError, "empty pathname");
3711 return -1;
3712 }
3713
Victor Stinnerbeb4135b2010-10-07 01:02:42 +00003714 path = PyUnicode_AsWideCharString(pathobj, NULL);
Victor Stinner255dfdb2010-09-29 10:28:51 +00003715 if (path == NULL)
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003716 return -1;
3717 /* see issue1293 and issue3677:
3718 * stat() on Windows doesn't recognise paths like
3719 * "e:\\shared\\" and "\\\\whiterab-c2znlh\\shared" as dirs.
3720 */
3721 rv = GetFileAttributesW(path);
Victor Stinner255dfdb2010-09-29 10:28:51 +00003722 PyMem_Free(path);
Victor Stinner1a4d12d2010-08-13 13:07:29 +00003723 if (rv != INVALID_FILE_ATTRIBUTES) {
3724 /* it exists */
3725 if (rv & FILE_ATTRIBUTE_DIRECTORY) {
3726 /* it's a directory */
3727 PyErr_SetString(PyExc_ImportError, "existing directory");
3728 return -1;
3729 }
3730 }
3731#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003732 return 0;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003733}
3734
3735static PyObject *
3736NullImporter_find_module(NullImporter *self, PyObject *args)
3737{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003738 Py_RETURN_NONE;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003739}
3740
3741static PyMethodDef NullImporter_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003742 {"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,
3743 "Always return None"
3744 },
3745 {NULL} /* Sentinel */
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003746};
3747
3748
Christian Heimes9cd17752007-11-18 19:35:23 +00003749PyTypeObject PyNullImporter_Type = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003750 PyVarObject_HEAD_INIT(NULL, 0)
3751 "imp.NullImporter", /*tp_name*/
3752 sizeof(NullImporter), /*tp_basicsize*/
3753 0, /*tp_itemsize*/
3754 0, /*tp_dealloc*/
3755 0, /*tp_print*/
3756 0, /*tp_getattr*/
3757 0, /*tp_setattr*/
3758 0, /*tp_reserved*/
3759 0, /*tp_repr*/
3760 0, /*tp_as_number*/
3761 0, /*tp_as_sequence*/
3762 0, /*tp_as_mapping*/
3763 0, /*tp_hash */
3764 0, /*tp_call*/
3765 0, /*tp_str*/
3766 0, /*tp_getattro*/
3767 0, /*tp_setattro*/
3768 0, /*tp_as_buffer*/
3769 Py_TPFLAGS_DEFAULT, /*tp_flags*/
3770 "Null importer object", /* tp_doc */
3771 0, /* tp_traverse */
3772 0, /* tp_clear */
3773 0, /* tp_richcompare */
3774 0, /* tp_weaklistoffset */
3775 0, /* tp_iter */
3776 0, /* tp_iternext */
3777 NullImporter_methods, /* tp_methods */
3778 0, /* tp_members */
3779 0, /* tp_getset */
3780 0, /* tp_base */
3781 0, /* tp_dict */
3782 0, /* tp_descr_get */
3783 0, /* tp_descr_set */
3784 0, /* tp_dictoffset */
3785 (initproc)NullImporter_init, /* tp_init */
3786 0, /* tp_alloc */
3787 PyType_GenericNew /* tp_new */
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003788};
3789
Martin v. Löwis1a214512008-06-11 05:26:20 +00003790static struct PyModuleDef impmodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003791 PyModuleDef_HEAD_INIT,
3792 "imp",
3793 doc_imp,
3794 0,
3795 imp_methods,
3796 NULL,
3797 NULL,
3798 NULL,
3799 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +00003800};
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003801
Jason Tishler6bc06ec2003-09-04 11:59:50 +00003802PyMODINIT_FUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +00003803PyInit_imp(void)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003804{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003805 PyObject *m, *d;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003806
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003807 if (PyType_Ready(&PyNullImporter_Type) < 0)
3808 return NULL;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003809
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003810 m = PyModule_Create(&impmodule);
3811 if (m == NULL)
3812 goto failure;
3813 d = PyModule_GetDict(m);
3814 if (d == NULL)
3815 goto failure;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003816
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003817 if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;
3818 if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;
3819 if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;
3820 if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;
3821 if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;
3822 if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;
3823 if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;
3824 if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;
3825 if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;
3826 if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003827
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003828 Py_INCREF(&PyNullImporter_Type);
3829 PyModule_AddObject(m, "NullImporter", (PyObject *)&PyNullImporter_Type);
3830 return m;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00003831 failure:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003832 Py_XDECREF(m);
3833 return NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003834}
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003835
3836
Guido van Rossumb18618d2000-05-03 23:44:39 +00003837/* API for embedding applications that want to add their own entries
3838 to the table of built-in modules. This should normally be called
3839 *before* Py_Initialize(). When the table resize fails, -1 is
3840 returned and the existing table is unchanged.
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003841
3842 After a similar function by Just van Rossum. */
3843
3844int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003845PyImport_ExtendInittab(struct _inittab *newtab)
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003846{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003847 static struct _inittab *our_copy = NULL;
3848 struct _inittab *p;
3849 int i, n;
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003850
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003851 /* Count the number of entries in both tables */
3852 for (n = 0; newtab[n].name != NULL; n++)
3853 ;
3854 if (n == 0)
3855 return 0; /* Nothing to do */
3856 for (i = 0; PyImport_Inittab[i].name != NULL; i++)
3857 ;
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003858
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003859 /* Allocate new memory for the combined table */
3860 p = our_copy;
3861 PyMem_RESIZE(p, struct _inittab, i+n+1);
3862 if (p == NULL)
3863 return -1;
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003864
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003865 /* Copy the tables into the new memory */
3866 if (our_copy != PyImport_Inittab)
3867 memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
3868 PyImport_Inittab = our_copy = p;
3869 memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003870
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003871 return 0;
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003872}
3873
3874/* Shorthand to add a single entry given a name and a function */
3875
3876int
Brett Cannona826f322009-04-02 03:41:46 +00003877PyImport_AppendInittab(const char *name, PyObject* (*initfunc)(void))
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003878{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003879 struct _inittab newtab[2];
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003880
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003881 memset(newtab, '\0', sizeof newtab);
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003882
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003883 newtab[0].name = (char *)name;
3884 newtab[0].initfunc = initfunc;
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003885
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003886 return PyImport_ExtendInittab(newtab);
Guido van Rossum09cae1f1998-05-14 02:32:54 +00003887}
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00003888
3889#ifdef __cplusplus
3890}
3891#endif