svn merge -r 21041:21301 https://svn.blender.org/svnroot/bf-blender/branches/blender2...
[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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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 #include "bpy_internal_import.h"
30 #include "DNA_text_types.h"
31 #include "DNA_ID.h"
32
33 #include "MEM_guardedalloc.h"
34 #include "BKE_text.h" /* txt_to_buf */  
35 #include "BKE_main.h"
36
37 static Main *bpy_import_main= NULL;
38
39 static void free_compiled_text(Text *text)
40 {
41         if(text->compiled) {
42                 Py_DECREF(( PyObject * )text->compiled);
43         }
44         text->compiled= NULL;
45 }
46
47 struct Main *bpy_import_main_get(void)
48 {
49         return bpy_import_main;
50 }
51
52 void bpy_import_main_set(struct Main *maggie)
53 {
54         bpy_import_main= maggie;
55 }
56
57
58 PyObject *bpy_text_import( char *name, int *found )
59 {
60         Text *text;
61         char txtname[22]; /* 21+NULL */
62         char *buf = NULL;
63         int namelen = strlen( name );
64 //XXX   Main *maggie= bpy_import_main ? bpy_import_main:G.main;
65         Main *maggie= bpy_import_main;
66         
67         *found= 0;
68         
69         if (namelen>21-3) return NULL; /* we know this cant be importable, the name is too long for blender! */
70         
71         memcpy( txtname, name, namelen );
72         memcpy( &txtname[namelen], ".py", 4 );
73
74         for(text = maggie->text.first; text; text = text->id.next) {
75                 if( !strcmp( txtname, text->id.name+2 ) )
76                         break;
77         }
78
79         if( !text )
80                 return NULL;
81         else
82                 *found = 1;
83         
84         if( !text->compiled ) {
85                 buf = txt_to_buf( text );
86                 text->compiled = Py_CompileString( buf, text->id.name+2, Py_file_input );
87                 MEM_freeN( buf );
88
89                 if( PyErr_Occurred(  ) ) {
90                         PyErr_Print(  );
91                         PyErr_Clear(  );
92                         PySys_SetObject("last_traceback", NULL);
93                         free_compiled_text( text );
94                         return NULL;
95                 }
96         }
97
98         return PyImport_ExecCodeModule( name, text->compiled );
99 }
100
101
102 /*
103  * find in-memory module and recompile
104  */
105
106 PyObject *bpy_text_reimport( PyObject *module, int *found )
107 {
108         Text *text;
109         char *txtname;
110         char *name;
111         char *buf = NULL;
112 //XXX   Main *maggie= bpy_import_main ? bpy_import_main:G.main;
113         Main *maggie= bpy_import_main;
114         
115         *found= 0;
116         
117         /* get name, filename from the module itself */
118
119         txtname = PyModule_GetFilename( module );
120         name = PyModule_GetName( module );
121         if( !txtname || !name)
122                 return NULL;
123
124         /* look up the text object */
125         text = ( Text * ) & ( maggie->text.first );
126         while( text ) {
127                 if( !strcmp( txtname, text->id.name+2 ) )
128                         break;
129                 text = text->id.next;
130         }
131
132         /* uh-oh.... didn't find it */
133         if( !text )
134                 return NULL;
135         else
136                 *found = 1;
137
138         /* if previously compiled, free the object */
139         /* (can't see how could be NULL, but check just in case) */ 
140         if( text->compiled ){
141                 Py_DECREF( (PyObject *)text->compiled );
142         }
143
144         /* compile the buffer */
145         buf = txt_to_buf( text );
146         text->compiled = Py_CompileString( buf, text->id.name+2, Py_file_input );
147         MEM_freeN( buf );
148
149         /* if compile failed.... return this error */
150         if( PyErr_Occurred(  ) ) {
151                 PyErr_Print(  );
152                 PyErr_Clear(  );
153                 PySys_SetObject("last_traceback", NULL);
154                 free_compiled_text( text );
155                 return NULL;
156         }
157
158         /* make into a module */
159         return PyImport_ExecCodeModule( name, text->compiled );
160 }
161
162
163 static PyObject *blender_import( PyObject * self, PyObject * args,  PyObject * kw)
164 {
165         PyObject *exception, *err, *tb;
166         char *name;
167         int found= 0;
168         PyObject *globals = NULL, *locals = NULL, *fromlist = NULL;
169         PyObject *newmodule;
170         
171         //PyObject_Print(args, stderr, 0);
172 #if (PY_VERSION_HEX >= 0x02060000)
173         int dummy_val; /* what does this do?*/
174         static char *kwlist[] = {"name", "globals", "locals", "fromlist", "level", 0};
175         
176         if( !PyArg_ParseTupleAndKeywords( args, kw, "s|OOOi:bpy_import_meth", kwlist,
177                                &name, &globals, &locals, &fromlist, &dummy_val) )
178                 return NULL;
179 #else
180         static char *kwlist[] = {"name", "globals", "locals", "fromlist", 0};
181         
182         if( !PyArg_ParseTupleAndKeywords( args, kw, "s|OOO:bpy_import_meth", kwlist,
183                                &name, &globals, &locals, &fromlist ) )
184                 return NULL;
185 #endif
186
187         /* import existing builtin modules or modules that have been imported alredy */
188         newmodule = PyImport_ImportModuleEx( name, globals, locals, fromlist );
189         
190         if(newmodule)
191                 return newmodule;
192         
193         PyErr_Fetch( &exception, &err, &tb );   /* get the python error incase we cant import as blender text either */
194         
195         /* importing from existing modules failed, see if we have this module as blender text */
196         newmodule = bpy_text_import( name, &found );
197         
198         if( newmodule ) {/* found module as blender text, ignore above exception */
199                 PyErr_Clear(  );
200                 Py_XDECREF( exception );
201                 Py_XDECREF( err );
202                 Py_XDECREF( tb );
203                 /* printf( "imported from text buffer...\n" ); */
204         }
205         else if (found==1) { /* blender text module failed to execute but was found, use its error message */
206                 Py_XDECREF( exception );
207                 Py_XDECREF( err );
208                 Py_XDECREF( tb );
209                 return NULL;
210         }
211         else {
212                 /* no blender text was found that could import the module
213                  * rause the original error from PyImport_ImportModuleEx */
214                 PyErr_Restore( exception, err, tb );
215         }
216         return newmodule;
217 }
218
219
220 /*
221  * our reload() module, to handle reloading in-memory scripts
222  */
223
224 static PyObject *blender_reload( PyObject * self, PyObject * args )
225 {
226         PyObject *exception, *err, *tb;
227         PyObject *module = NULL;
228         PyObject *newmodule = NULL;
229         int found= 0;
230         
231         /* check for a module arg */
232         if( !PyArg_ParseTuple( args, "O:bpy_reload_meth", &module ) )
233                 return NULL;
234
235         /* try reimporting from file */
236         newmodule = PyImport_ReloadModule( module );
237         if( newmodule )
238                 return newmodule;
239
240         /* no file, try importing from memory */
241         PyErr_Fetch( &exception, &err, &tb );   /*restore for probable later use */
242
243         newmodule = bpy_text_reimport( module, &found );
244         if( newmodule ) {/* found module as blender text, ignore above exception */
245                 PyErr_Clear(  );
246                 Py_XDECREF( exception );
247                 Py_XDECREF( err );
248                 Py_XDECREF( tb );
249                 /* printf( "imported from text buffer...\n" ); */
250         }
251         else if (found==1) { /* blender text module failed to execute but was found, use its error message */
252                 Py_XDECREF( exception );
253                 Py_XDECREF( err );
254                 Py_XDECREF( tb );
255                 return NULL;
256         }
257         else {
258                 /* no blender text was found that could import the module
259                  * rause the original error from PyImport_ImportModuleEx */
260                 PyErr_Restore( exception, err, tb );
261         }
262
263         return newmodule;
264 }
265
266 PyMethodDef bpy_import_meth[] = { {"bpy_import_meth", blender_import, METH_VARARGS | METH_KEYWORDS, "blenders import"} };
267 PyMethodDef bpy_reload_meth[] = { {"bpy_reload_meth", blender_reload, METH_VARARGS, "blenders reload"} };
268
269
270 /* Clear user modules.
271  * This is to clear any modules that could be defined from running scripts in blender.
272  * 
273  * Its also needed for the BGE Python api so imported scripts are not used between levels
274  * 
275  * This clears every modules that has a __file__ attribute (is not a builtin)
276  *
277  * Note that clearing external python modules is important for the BGE otherwise
278  * it wont reload scripts between loading different blend files or while making the game.
279  * - use 'clear_all' arg in this case.
280  *
281  * Since pythons bultins include a full path even for win32.
282  * even if we remove a python module a reimport will bring it back again.
283  */
284
285 #if 0 // not used anymore but may still come in handy later
286
287 #if defined(WIN32) || defined(WIN64)
288 #define SEPSTR "\\"
289 #else
290 #define SEPSTR "/"
291 #endif
292
293
294 void bpy_text_clear_modules(int clear_all)
295 {
296         PyObject *modules= PySys_GetObject("modules");
297         
298         char *fname;
299         char *file_extension;
300         
301         /* looping over the dict */
302         PyObject *key, *value;
303         int pos = 0;
304         
305         /* new list */
306         PyObject *list;
307
308         if (modules==NULL)
309                 return; /* should never happen but just incase */
310
311         list= PyList_New(0);
312
313         /* go over sys.modules and remove anything with a 
314          * sys.modukes[x].__file__ thats ends with a .py and has no path
315          */
316         while (PyDict_Next(modules, &pos, &key, &value)) {
317                 fname= PyModule_GetFilename(value);
318                 if(fname) {
319                         if (clear_all || ((strstr(fname, SEPSTR))==0)) { /* no path ? */
320                                 file_extension = strstr(fname, ".py");
321                                 if(file_extension && (*(file_extension + 3) == '\0' || *(file_extension + 4) == '\0')) { /* .py or pyc extension? */
322                                         /* now we can be fairly sure its a python import from the blendfile */
323                                         PyList_Append(list, key); /* free'd with the list */
324                                 }
325                         }
326                 }
327                 else {
328                         PyErr_Clear();
329                 }
330         }
331         
332         /* remove all our modules */
333         for(pos=0; pos < PyList_Size(list); pos++) {
334                 /* PyObject_Print(key, stderr, 0); */
335                 key= PyList_GET_ITEM(list, pos);
336                 PyDict_DelItem(modules, key);
337         }
338         
339         Py_DECREF(list); /* removes all references from append */
340 }
341 #endif