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