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