Merging r39948 through r39988 from trunk into vgroup_modifiers.
[blender.git] / source / blender / python / generic / bpy_internal_import.c
1 /* 
2  * $Id$
3  * ***** BEGIN GPL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20  * All rights reserved.
21  *
22  * This is a new part of Blender.
23  *
24  * Contributor(s): Willian P. Germano
25  *
26  * ***** END GPL LICENSE BLOCK *****
27 */
28
29 /** \file blender/python/generic/bpy_internal_import.c
30  *  \ingroup pygen
31  */
32
33
34 #include <Python.h>
35 #include <stddef.h>
36
37 #include "bpy_internal_import.h"
38
39 #include "MEM_guardedalloc.h"
40
41 #include "DNA_text_types.h"
42
43 #include "BLI_listbase.h"
44 #include "BLI_path_util.h"
45 #include "BLI_string.h"
46 #include "BLI_utildefines.h"
47
48  /* UNUSED */   
49 #include "BKE_text.h" /* txt_to_buf */  
50 #include "BKE_main.h"
51
52 static Main *bpy_import_main= NULL;
53
54 /* 'builtins' is most likely PyEval_GetBuiltins() */
55 void bpy_import_init(PyObject *builtins)
56 {
57         PyObject *item;
58         PyObject *mod;
59
60         PyDict_SetItemString(builtins, "__import__",    item=PyCFunction_New(&bpy_import_meth, NULL));  Py_DECREF(item);
61
62         /* move reload here
63          * XXX, use import hooks */
64         mod= PyImport_ImportModuleLevel((char *)"imp", NULL, NULL, NULL, 0);
65         if(mod) {
66                 PyDict_SetItemString(PyModule_GetDict(mod), "reload", item=PyCFunction_New(&bpy_reload_meth, NULL)); Py_DECREF(item);
67                 Py_DECREF(mod);
68         }
69         else {
70                 BLI_assert(!"unable to load 'imp' module.");
71         }
72 }
73
74
75 static void free_compiled_text(Text *text)
76 {
77         if(text->compiled) {
78                 Py_DECREF((PyObject *)text->compiled);
79         }
80         text->compiled= NULL;
81 }
82
83 struct Main *bpy_import_main_get(void)
84 {
85         return bpy_import_main;
86 }
87
88 void bpy_import_main_set(struct Main *maggie)
89 {
90         bpy_import_main= maggie;
91 }
92
93 /* returns a dummy filename for a textblock so we can tell what file a text block comes from */
94 void bpy_text_filename_get(char *fn, size_t fn_len, Text *text)
95 {
96         BLI_snprintf(fn, fn_len, "%s%c%s", text->id.lib ? text->id.lib->filepath : bpy_import_main->name, SEP, text->id.name+2);
97 }
98
99 PyObject *bpy_text_import(Text *text)
100 {
101         char *buf= NULL;
102         char modulename[24];
103         int len;
104
105         if(!text->compiled) {
106                 char fn_dummy[256];
107                 bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);
108
109                 buf= txt_to_buf(text);
110                 text->compiled= Py_CompileString(buf, fn_dummy, Py_file_input);
111                 MEM_freeN(buf);
112
113                 if(PyErr_Occurred()) {
114                         PyErr_Print();
115                         PyErr_Clear();
116                         PySys_SetObject("last_traceback", NULL);
117                         free_compiled_text(text);
118                         return NULL;
119                 }
120         }
121
122         len= strlen(text->id.name+2);
123         strncpy(modulename, text->id.name+2, len);
124         modulename[len - 3]= '\0'; /* remove .py */
125         return PyImport_ExecCodeModule(modulename, text->compiled);
126 }
127
128 PyObject *bpy_text_import_name(char *name, int *found)
129 {
130         Text *text;
131         char txtname[MAX_ID_NAME-2];
132         int namelen= strlen(name);
133 //XXX   Main *maggie= bpy_import_main ? bpy_import_main:G.main;
134         Main *maggie= bpy_import_main;
135         
136         *found= 0;
137
138         if(!maggie) {
139                 printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n");
140                 return NULL;
141         }
142         
143         if (namelen >= (MAX_ID_NAME-2) - 3) return NULL; /* we know this cant be importable, the name is too long for blender! */
144         
145         memcpy(txtname, name, namelen);
146         memcpy(&txtname[namelen], ".py", 4);
147
148         text= BLI_findstring(&maggie->text, txtname, offsetof(ID, name) + 2);
149
150         if(!text)
151                 return NULL;
152         else
153                 *found= 1;
154         
155         return bpy_text_import(text);
156 }
157
158
159 /*
160  * find in-memory module and recompile
161  */
162
163 PyObject *bpy_text_reimport(PyObject *module, int *found)
164 {
165         Text *text;
166         const char *name;
167         char *filepath;
168         char *buf= NULL;
169 //XXX   Main *maggie= bpy_import_main ? bpy_import_main:G.main;
170         Main *maggie= bpy_import_main;
171         
172         if(!maggie) {
173                 printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n");
174                 return NULL;
175         }
176         
177         *found= 0;
178         
179         /* get name, filename from the module itself */
180         if((name= PyModule_GetName(module)) == NULL)
181                 return NULL;
182
183         if((filepath= (char *)PyModule_GetFilename(module)) == NULL)
184                 return NULL;
185
186         /* look up the text object */
187         text= BLI_findstring(&maggie->text, BLI_path_basename(filepath), offsetof(ID, name) + 2);
188
189         /* uh-oh.... didn't find it */
190         if(!text)
191                 return NULL;
192         else
193                 *found= 1;
194
195         /* if previously compiled, free the object */
196         /* (can't see how could be NULL, but check just in case) */ 
197         if(text->compiled){
198                 Py_DECREF((PyObject *)text->compiled);
199         }
200
201         /* compile the buffer */
202         buf= txt_to_buf(text);
203         text->compiled= Py_CompileString(buf, text->id.name+2, Py_file_input);
204         MEM_freeN(buf);
205
206         /* if compile failed.... return this error */
207         if(PyErr_Occurred()) {
208                 PyErr_Print();
209                 PyErr_Clear();
210                 PySys_SetObject("last_traceback", NULL);
211                 free_compiled_text(text);
212                 return NULL;
213         }
214
215         /* make into a module */
216         return PyImport_ExecCodeModule((char *)name, text->compiled);
217 }
218
219
220 static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
221 {
222         PyObject *exception, *err, *tb;
223         char *name;
224         int found= 0;
225         PyObject *globals= NULL, *locals= NULL, *fromlist= NULL;
226         int level= -1; /* relative imports */
227         
228         PyObject *newmodule;
229         //PyObject_Print(args, stderr, 0);
230         static const char *kwlist[]= {"name", "globals", "locals", "fromlist", "level", NULL};
231         
232         if(!PyArg_ParseTupleAndKeywords(args, kw, "s|OOOi:bpy_import_meth", (char **)kwlist,
233                                    &name, &globals, &locals, &fromlist, &level))
234                 return NULL;
235
236         /* import existing builtin modules or modules that have been imported already */
237         newmodule= PyImport_ImportModuleLevel(name, globals, locals, fromlist, level);
238         
239         if(newmodule)
240                 return newmodule;
241         
242         PyErr_Fetch(&exception, &err, &tb);     /* get the python error incase we cant import as blender text either */
243         
244         /* importing from existing modules failed, see if we have this module as blender text */
245         newmodule= bpy_text_import_name(name, &found);
246         
247         if(newmodule) {/* found module as blender text, ignore above exception */
248                 PyErr_Clear();
249                 Py_XDECREF(exception);
250                 Py_XDECREF(err);
251                 Py_XDECREF(tb);
252                 /* printf("imported from text buffer...\n"); */
253         }
254         else if (found==1) { /* blender text module failed to execute but was found, use its error message */
255                 Py_XDECREF(exception);
256                 Py_XDECREF(err);
257                 Py_XDECREF(tb);
258                 return NULL;
259         }
260         else {
261                 /* no blender text was found that could import the module
262                  * rause the original error from PyImport_ImportModuleEx */
263                 PyErr_Restore(exception, err, tb);
264         }
265         return newmodule;
266 }
267
268
269 /*
270  * our reload() module, to handle reloading in-memory scripts
271  */
272
273 static PyObject *blender_reload(PyObject *UNUSED(self), PyObject *module)
274 {
275         PyObject *exception, *err, *tb;
276         PyObject *newmodule= NULL;
277         int found= 0;
278
279         /* try reimporting from file */
280         newmodule= PyImport_ReloadModule(module);
281         if(newmodule)
282                 return newmodule;
283
284         /* no file, try importing from memory */
285         PyErr_Fetch(&exception, &err, &tb);     /*restore for probable later use */
286
287         newmodule= bpy_text_reimport(module, &found);
288         if(newmodule) {/* found module as blender text, ignore above exception */
289                 PyErr_Clear();
290                 Py_XDECREF(exception);
291                 Py_XDECREF(err);
292                 Py_XDECREF(tb);
293                 /* printf("imported from text buffer...\n"); */
294         }
295         else if (found==1) { /* blender text module failed to execute but was found, use its error message */
296                 Py_XDECREF(exception);
297                 Py_XDECREF(err);
298                 Py_XDECREF(tb);
299                 return NULL;
300         }
301         else {
302                 /* no blender text was found that could import the module
303                  * reuse the original error from PyImport_ImportModuleEx */
304                 PyErr_Restore(exception, err, tb);
305         }
306
307         return newmodule;
308 }
309
310 PyMethodDef bpy_import_meth= {"bpy_import_meth", (PyCFunction)blender_import, METH_VARARGS | METH_KEYWORDS, "blenders import"};
311 PyMethodDef bpy_reload_meth= {"bpy_reload_meth", (PyCFunction)blender_reload, METH_O, "blenders reload"};
312
313
314 /* Clear user modules.
315  * This is to clear any modules that could be defined from running scripts in blender.
316  * 
317  * Its also needed for the BGE Python api so imported scripts are not used between levels
318  * 
319  * This clears every modules that has a __file__ attribute (is not a builtin)
320  *
321  * Note that clearing external python modules is important for the BGE otherwise
322  * it wont reload scripts between loading different blend files or while making the game.
323  * - use 'clear_all' arg in this case.
324  *
325  * Since pythons built-ins include a full path even for win32.
326  * even if we remove a python module a re-import will bring it back again.
327  */
328
329 #if 0 // not used anymore but may still come in handy later
330
331 #if defined(WIN32) || defined(WIN64)
332 #define SEPSTR "\\"
333 #else
334 #define SEPSTR "/"
335 #endif
336
337
338 void bpy_text_clear_modules(int clear_all)
339 {
340         PyObject *modules= PyImport_GetModuleDict();
341         
342         char *fname;
343         char *file_extension;
344         
345         /* looping over the dict */
346         PyObject *key, *value;
347         Py_ssize_t pos= 0;
348         
349         /* new list */
350         PyObject *list;
351
352         if (modules==NULL)
353                 return; /* should never happen but just incase */
354
355         list= PyList_New(0);
356
357         /* go over sys.modules and remove anything with a 
358          * sys.modukes[x].__file__ thats ends with a .py and has no path
359          */
360         while (PyDict_Next(modules, &pos, &key, &value)) {
361                 fname= PyModule_GetFilename(value);
362                 if(fname) {
363                         if (clear_all || ((strstr(fname, SEPSTR))==0)) { /* no path ? */
364                                 file_extension= strstr(fname, ".py");
365                                 if(file_extension && (*(file_extension + 3) == '\0' || *(file_extension + 4) == '\0')) { /* .py or pyc extension? */
366                                         /* now we can be fairly sure its a python import from the blendfile */
367                                         PyList_Append(list, key); /* free'd with the list */
368                                 }
369                         }
370                 }
371                 else {
372                         PyErr_Clear();
373                 }
374         }
375         
376         /* remove all our modules */
377         for(pos=0; pos < PyList_GET_SIZE(list); pos++) {
378                 /* PyObject_Print(key, stderr, 0); */
379                 key= PyList_GET_ITEM(list, pos);
380                 PyDict_DelItem(modules, key);
381         }
382         
383         Py_DECREF(list); /* removes all references from append */
384 }
385 #endif