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
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 #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));
74   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));
87     Py_DECREF(item);
88     Py_DECREF(mod);
89   }
90   else {
91     BLI_assert(!"unable to load 'importlib' module.");
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 /* returns a dummy filename for a textblock so we can tell what file a text block comes from */
114 void bpy_text_filename_get(char *fn, size_t fn_len, Text *text)
115 {
116   BLI_snprintf(
117       fn, fn_len, "%s%c%s", ID_BLEND_PATH(bpy_import_main, &text->id), SEP, text->id.name + 2);
118 }
119
120 bool bpy_text_compile(Text *text)
121 {
122   char fn_dummy[FILE_MAX];
123   PyObject *fn_dummy_py;
124   char *buf;
125
126   bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);
127
128   /* if previously compiled, free the object */
129   free_compiled_text(text);
130
131   fn_dummy_py = PyC_UnicodeFromByte(fn_dummy);
132
133   buf = txt_to_buf(text);
134   text->compiled = Py_CompileStringObject(buf, fn_dummy_py, Py_file_input, NULL, -1);
135   MEM_freeN(buf);
136
137   Py_DECREF(fn_dummy_py);
138
139   if (PyErr_Occurred()) {
140     PyErr_Print();
141     PyErr_Clear();
142     PySys_SetObject("last_traceback", NULL);
143     free_compiled_text(text);
144     return false;
145   }
146   else {
147     return true;
148   }
149 }
150
151 PyObject *bpy_text_import(Text *text)
152 {
153   char modulename[MAX_ID_NAME + 2];
154   int len;
155
156   if (!text->compiled) {
157     if (bpy_text_compile(text) == false) {
158       return NULL;
159     }
160   }
161
162   len = strlen(text->id.name + 2);
163   BLI_strncpy(modulename, text->id.name + 2, len);
164   modulename[len - 3] = '\0'; /* remove .py */
165   return PyImport_ExecCodeModule(modulename, text->compiled);
166 }
167
168 PyObject *bpy_text_import_name(const char *name, int *found)
169 {
170   Text *text;
171   char txtname[MAX_ID_NAME - 2];
172   int namelen = strlen(name);
173   //XXX   Main *maggie = bpy_import_main ? bpy_import_main : G_MAIN;
174   Main *maggie = bpy_import_main;
175
176   *found = 0;
177
178   if (!maggie) {
179     printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n");
180     return NULL;
181   }
182
183   /* we know this cant be importable, the name is too long for blender! */
184   if (namelen >= (MAX_ID_NAME - 2) - 3) {
185     return NULL;
186   }
187
188   memcpy(txtname, name, namelen);
189   memcpy(&txtname[namelen], ".py", 4);
190
191   text = BLI_findstring(&maggie->texts, txtname, offsetof(ID, name) + 2);
192
193   if (text) {
194     *found = 1;
195     return bpy_text_import(text);
196   }
197
198   /* If we still haven't found the module try additional modules form bpy_import_main_list */
199   maggie = bpy_import_main_list.first;
200   while (maggie && !text) {
201     text = BLI_findstring(&maggie->texts, txtname, offsetof(ID, name) + 2);
202     maggie = maggie->next;
203   }
204
205   if (!text) {
206     return NULL;
207   }
208   else {
209     *found = 1;
210   }
211
212   return bpy_text_import(text);
213 }
214
215 /*
216  * find in-memory module and recompile
217  */
218
219 PyObject *bpy_text_reimport(PyObject *module, int *found)
220 {
221   Text *text;
222   const char *name;
223   const char *filepath;
224   //XXX   Main *maggie = bpy_import_main ? bpy_import_main : G_MAIN;
225   Main *maggie = bpy_import_main;
226
227   if (!maggie) {
228     printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n");
229     return NULL;
230   }
231
232   *found = 0;
233
234   /* get name, filename from the module itself */
235   if ((name = PyModule_GetName(module)) == NULL) {
236     return NULL;
237   }
238
239   {
240     PyObject *module_file = PyModule_GetFilenameObject(module);
241     if (module_file == NULL) {
242       return NULL;
243     }
244     filepath = _PyUnicode_AsString(module_file);
245     Py_DECREF(module_file);
246     if (filepath == NULL) {
247       return NULL;
248     }
249   }
250
251   /* look up the text object */
252   text = BLI_findstring(&maggie->texts, BLI_path_basename(filepath), offsetof(ID, name) + 2);
253
254   /* uh-oh.... didn't find it */
255   if (!text) {
256     return NULL;
257   }
258   else {
259     *found = 1;
260   }
261
262   if (bpy_text_compile(text) == false) {
263     return NULL;
264   }
265
266   /* make into a module */
267   return PyImport_ExecCodeModule(name, text->compiled);
268 }
269
270 static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
271 {
272   PyObject *exception, *err, *tb;
273   const char *name;
274   int found = 0;
275   PyObject *globals = NULL, *locals = NULL, *fromlist = NULL;
276   int level = 0; /* relative imports */
277   PyObject *newmodule;
278
279   static const char *_keywords[] = {"name", "globals", "locals", "fromlist", "level", NULL};
280   static _PyArg_Parser _parser = {"s|OOOi:bpy_import_meth", _keywords, 0};
281   if (!_PyArg_ParseTupleAndKeywordsFast(
282           args, kw, &_parser, &name, &globals, &locals, &fromlist, &level)) {
283     return NULL;
284   }
285
286   /* import existing builtin modules or modules that have been imported already */
287   newmodule = PyImport_ImportModuleLevel(name, globals, locals, fromlist, level);
288
289   if (newmodule) {
290     return newmodule;
291   }
292
293   PyErr_Fetch(&exception,
294               &err,
295               &tb); /* get the python error in case we cant import as blender text either */
296
297   /* importing from existing modules failed, see if we have this module as blender text */
298   newmodule = bpy_text_import_name(name, &found);
299
300   if (newmodule) { /* found module as blender text, ignore above exception */
301     PyErr_Clear();
302     Py_XDECREF(exception);
303     Py_XDECREF(err);
304     Py_XDECREF(tb);
305     /* printf("imported from text buffer...\n"); */
306   }
307   else if (found ==
308            1) { /* blender text module failed to execute but was found, use its error message */
309     Py_XDECREF(exception);
310     Py_XDECREF(err);
311     Py_XDECREF(tb);
312     return NULL;
313   }
314   else {
315     /* no blender text was found that could import the module
316      * reuse the original error from PyImport_ImportModuleEx */
317     PyErr_Restore(exception, err, tb);
318   }
319   return newmodule;
320 }
321
322 /*
323  * our reload() module, to handle reloading in-memory scripts
324  */
325
326 static PyObject *blender_reload(PyObject *UNUSED(self), PyObject *module)
327 {
328   PyObject *exception, *err, *tb;
329   PyObject *newmodule = NULL;
330   int found = 0;
331
332   /* try reimporting from file */
333
334   /* in Py3.3 this just calls imp.reload() which we overwrite, causing recursive calls */
335   //newmodule = PyImport_ReloadModule(module);
336
337   newmodule = PyObject_CallFunctionObjArgs(imp_reload_orig, module, NULL);
338
339   if (newmodule) {
340     return newmodule;
341   }
342
343   /* no file, try importing from memory */
344   PyErr_Fetch(&exception, &err, &tb); /*restore for probable later use */
345
346   newmodule = bpy_text_reimport(module, &found);
347   if (newmodule) { /* found module as blender text, ignore above exception */
348     PyErr_Clear();
349     Py_XDECREF(exception);
350     Py_XDECREF(err);
351     Py_XDECREF(tb);
352     /* printf("imported from text buffer...\n"); */
353   }
354   else if (found ==
355            1) { /* blender text module failed to execute but was found, use its error message */
356     Py_XDECREF(exception);
357     Py_XDECREF(err);
358     Py_XDECREF(tb);
359     return NULL;
360   }
361   else {
362     /* no blender text was found that could import the module
363      * reuse the original error from PyImport_ImportModuleEx */
364     PyErr_Restore(exception, err, tb);
365   }
366
367   return newmodule;
368 }
369
370 static PyMethodDef bpy_import_meth = {"bpy_import_meth",
371                                       (PyCFunction)blender_import,
372                                       METH_VARARGS | METH_KEYWORDS,
373                                       "blenders import"};
374 static PyMethodDef bpy_reload_meth = {
375     "bpy_reload_meth", (PyCFunction)blender_reload, METH_O, "blenders reload"};