Merge branch 'blender2.7'
[blender.git] / source / blender / python / generic / bpy_internal_import.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file \ingroup pygen
18  *
19  * This file defines replacements for pythons '__import__' and 'imp.reload'
20  * functions which can import from blender textblocks.
21  *
22  * \note
23  * This should eventually be replaced by import hooks (pep 302).
24  */
25
26
27 #include <Python.h>
28 #include <stddef.h>
29
30 #include "MEM_guardedalloc.h"
31
32 #include "DNA_text_types.h"
33
34 #include "BLI_listbase.h"
35 #include "BLI_path_util.h"
36 #include "BLI_string.h"
37 #include "BLI_utildefines.h"
38
39 #include "BKE_main.h"
40 /* UNUSED */
41 #include "BKE_text.h"  /* txt_to_buf */
42
43 #include "py_capi_utils.h"
44
45 #include "bpy_internal_import.h"  /* own include */
46
47 static Main *bpy_import_main = NULL;
48 static ListBase bpy_import_main_list;
49
50 static PyMethodDef bpy_import_meth;
51 static PyMethodDef bpy_reload_meth;
52 static PyObject   *imp_reload_orig = NULL;
53
54 /* 'builtins' is most likely PyEval_GetBuiltins() */
55
56 /**
57  * \note to the discerning developer, yes - this is nasty
58  * monkey-patching our own import into Python's builtin 'imp' module.
59  *
60  * However Python's alternative is to use import hooks,
61  * which are implemented in a way that we can't use our own importer as a
62  * fall-back (instead we must try and fail - raise an exception every time).
63  * Since importing from blenders text-blocks is not the common case
64  * I prefer to use Pythons import by default and fall-back to
65  * Blenders - which we can only do by intercepting import calls I'm afraid.
66  * - Campbell
67  */
68 void bpy_import_init(PyObject *builtins)
69 {
70         PyObject *item;
71         PyObject *mod;
72
73         PyDict_SetItemString(builtins, "__import__", item = PyCFunction_New(&bpy_import_meth, NULL)); Py_DECREF(item);
74
75         /* move reload here
76          * XXX, use import hooks */
77         mod = PyImport_ImportModuleLevel("importlib", NULL, NULL, NULL, 0);
78         if (mod) {
79                 PyObject *mod_dict = PyModule_GetDict(mod);
80
81                 /* blender owns the function */
82                 imp_reload_orig = PyDict_GetItemString(mod_dict, "reload");
83                 Py_INCREF(imp_reload_orig);
84
85                 PyDict_SetItemString(mod_dict, "reload", item = PyCFunction_New(&bpy_reload_meth, NULL)); Py_DECREF(item);
86                 Py_DECREF(mod);
87         }
88         else {
89                 BLI_assert(!"unable to load 'importlib' module.");
90         }
91 }
92
93
94 static void free_compiled_text(Text *text)
95 {
96         if (text->compiled) {
97                 Py_DECREF((PyObject *)text->compiled);
98         }
99         text->compiled = NULL;
100 }
101
102 struct Main *bpy_import_main_get(void)
103 {
104         return bpy_import_main;
105 }
106
107 void bpy_import_main_set(struct Main *maggie)
108 {
109         bpy_import_main = maggie;
110 }
111
112 /* returns a dummy filename for a textblock so we can tell what file a text block comes from */
113 void bpy_text_filename_get(char *fn, size_t fn_len, Text *text)
114 {
115         BLI_snprintf(fn, fn_len, "%s%c%s", ID_BLEND_PATH(bpy_import_main, &text->id), SEP, text->id.name + 2);
116 }
117
118 bool bpy_text_compile(Text *text)
119 {
120         char fn_dummy[FILE_MAX];
121         PyObject *fn_dummy_py;
122         char *buf;
123
124         bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);
125
126         /* if previously compiled, free the object */
127         free_compiled_text(text);
128
129         fn_dummy_py = PyC_UnicodeFromByte(fn_dummy);
130
131         buf = txt_to_buf(text);
132         text->compiled = Py_CompileStringObject(buf, fn_dummy_py, Py_file_input, NULL, -1);
133         MEM_freeN(buf);
134
135         Py_DECREF(fn_dummy_py);
136
137         if (PyErr_Occurred()) {
138                 PyErr_Print();
139                 PyErr_Clear();
140                 PySys_SetObject("last_traceback", NULL);
141                 free_compiled_text(text);
142                 return false;
143         }
144         else {
145                 return true;
146         }
147 }
148
149 PyObject *bpy_text_import(Text *text)
150 {
151         char modulename[MAX_ID_NAME + 2];
152         int len;
153
154         if (!text->compiled) {
155                 if (bpy_text_compile(text) == false) {
156                         return NULL;
157                 }
158         }
159
160         len = strlen(text->id.name + 2);
161         BLI_strncpy(modulename, text->id.name + 2, len);
162         modulename[len - 3] = '\0'; /* remove .py */
163         return PyImport_ExecCodeModule(modulename, text->compiled);
164 }
165
166 PyObject *bpy_text_import_name(const char *name, int *found)
167 {
168         Text *text;
169         char txtname[MAX_ID_NAME - 2];
170         int namelen = strlen(name);
171 //XXX   Main *maggie = bpy_import_main ? bpy_import_main : G_MAIN;
172         Main *maggie = bpy_import_main;
173
174         *found = 0;
175
176         if (!maggie) {
177                 printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n");
178                 return NULL;
179         }
180
181         /* we know this cant be importable, the name is too long for blender! */
182         if (namelen >= (MAX_ID_NAME - 2) - 3)
183                 return NULL;
184
185         memcpy(txtname, name, namelen);
186         memcpy(&txtname[namelen], ".py", 4);
187
188         text = BLI_findstring(&maggie->text, txtname, offsetof(ID, name) + 2);
189
190         if (text) {
191                 *found = 1;
192                 return bpy_text_import(text);
193         }
194
195         /* If we still haven't found the module try additional modules form bpy_import_main_list */
196         maggie = bpy_import_main_list.first;
197         while (maggie && !text) {
198                 text = BLI_findstring(&maggie->text, txtname, offsetof(ID, name) + 2);
199                 maggie = maggie->next;
200         }
201
202         if (!text)
203                 return NULL;
204         else
205                 *found = 1;
206
207         return bpy_text_import(text);
208 }
209
210
211 /*
212  * find in-memory module and recompile
213  */
214
215 PyObject *bpy_text_reimport(PyObject *module, int *found)
216 {
217         Text *text;
218         const char *name;
219         const char *filepath;
220 //XXX   Main *maggie = bpy_import_main ? bpy_import_main : G_MAIN;
221         Main *maggie = bpy_import_main;
222
223         if (!maggie) {
224                 printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n");
225                 return NULL;
226         }
227
228         *found = 0;
229
230         /* get name, filename from the module itself */
231         if ((name = PyModule_GetName(module)) == NULL)
232                 return NULL;
233
234         {
235                 PyObject *module_file = PyModule_GetFilenameObject(module);
236                 if (module_file == NULL) {
237                         return NULL;
238                 }
239                 filepath = _PyUnicode_AsString(module_file);
240                 Py_DECREF(module_file);
241                 if (filepath == NULL) {
242                         return NULL;
243                 }
244         }
245
246         /* look up the text object */
247         text = BLI_findstring(&maggie->text, BLI_path_basename(filepath), offsetof(ID, name) + 2);
248
249         /* uh-oh.... didn't find it */
250         if (!text)
251                 return NULL;
252         else
253                 *found = 1;
254
255         if (bpy_text_compile(text) == false) {
256                 return NULL;
257         }
258
259         /* make into a module */
260         return PyImport_ExecCodeModule(name, text->compiled);
261 }
262
263
264 static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
265 {
266         PyObject *exception, *err, *tb;
267         const char *name;
268         int found = 0;
269         PyObject *globals = NULL, *locals = NULL, *fromlist = NULL;
270         int level = 0; /* relative imports */
271         PyObject *newmodule;
272
273         static const char *_keywords[] = {"name", "globals", "locals", "fromlist", "level", NULL};
274         static _PyArg_Parser _parser = {"s|OOOi:bpy_import_meth", _keywords, 0};
275         if (!_PyArg_ParseTupleAndKeywordsFast(
276                 args, kw, &_parser,
277                 &name, &globals, &locals, &fromlist, &level))
278         {
279                 return NULL;
280         }
281
282         /* import existing builtin modules or modules that have been imported already */
283         newmodule = PyImport_ImportModuleLevel(name, globals, locals, fromlist, level);
284
285         if (newmodule)
286                 return newmodule;
287
288         PyErr_Fetch(&exception, &err, &tb); /* get the python error in case we cant import as blender text either */
289
290         /* importing from existing modules failed, see if we have this module as blender text */
291         newmodule = bpy_text_import_name(name, &found);
292
293         if (newmodule) { /* found module as blender text, ignore above exception */
294                 PyErr_Clear();
295                 Py_XDECREF(exception);
296                 Py_XDECREF(err);
297                 Py_XDECREF(tb);
298                 /* printf("imported from text buffer...\n"); */
299         }
300         else if (found == 1) { /* blender text module failed to execute but was found, use its error message */
301                 Py_XDECREF(exception);
302                 Py_XDECREF(err);
303                 Py_XDECREF(tb);
304                 return NULL;
305         }
306         else {
307                 /* no blender text was found that could import the module
308                  * reuse the original error from PyImport_ImportModuleEx */
309                 PyErr_Restore(exception, err, tb);
310         }
311         return newmodule;
312 }
313
314
315 /*
316  * our reload() module, to handle reloading in-memory scripts
317  */
318
319 static PyObject *blender_reload(PyObject *UNUSED(self), PyObject *module)
320 {
321         PyObject *exception, *err, *tb;
322         PyObject *newmodule = NULL;
323         int found = 0;
324
325         /* try reimporting from file */
326
327         /* in Py3.3 this just calls imp.reload() which we overwrite, causing recursive calls */
328         //newmodule = PyImport_ReloadModule(module);
329
330         newmodule = PyObject_CallFunctionObjArgs(imp_reload_orig, module, NULL);
331
332         if (newmodule)
333                 return newmodule;
334
335         /* no file, try importing from memory */
336         PyErr_Fetch(&exception, &err, &tb); /*restore for probable later use */
337
338         newmodule = bpy_text_reimport(module, &found);
339         if (newmodule) { /* found module as blender text, ignore above exception */
340                 PyErr_Clear();
341                 Py_XDECREF(exception);
342                 Py_XDECREF(err);
343                 Py_XDECREF(tb);
344                 /* printf("imported from text buffer...\n"); */
345         }
346         else if (found == 1) { /* blender text module failed to execute but was found, use its error message */
347                 Py_XDECREF(exception);
348                 Py_XDECREF(err);
349                 Py_XDECREF(tb);
350                 return NULL;
351         }
352         else {
353                 /* no blender text was found that could import the module
354                  * reuse the original error from PyImport_ImportModuleEx */
355                 PyErr_Restore(exception, err, tb);
356         }
357
358         return newmodule;
359 }
360
361 static PyMethodDef bpy_import_meth = {"bpy_import_meth", (PyCFunction)blender_import, METH_VARARGS | METH_KEYWORDS, "blenders import"};
362 static PyMethodDef bpy_reload_meth = {"bpy_reload_meth", (PyCFunction)blender_reload, METH_O, "blenders reload"};