- remove debug printf
[blender.git] / source / blender / python / api2_2x / bpy_internal_import.c
1 /* 
2  * $Id: bpy_types.h 14444 2008-04-16 22:40:48Z hos $
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 "BKE_global.h"
34 #include "MEM_guardedalloc.h"
35 #include "BKE_text.h" /* txt_to_buf */  
36 #include "BKE_main.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
59 PyObject *importText( char *name )
60 {
61         Text *text;
62         char txtname[22]; /* 21+NULL */
63         char *buf = NULL;
64         int namelen = strlen( name );
65         Main *maggie= bpy_import_main ? bpy_import_main:G.main;
66         
67         if (namelen>21-3) return NULL; /* we know this cant be importable, the name is too long for blender! */
68         
69         memcpy( txtname, name, namelen );
70         memcpy( &txtname[namelen], ".py", 4 );
71
72         for(text = maggie->text.first; text; text = text->id.next) {
73                 if( !strcmp( txtname, text->id.name+2 ) )
74                         break;
75         }
76
77         if( !text )
78                 return NULL;
79
80         if( !text->compiled ) {
81                 buf = txt_to_buf( text );
82                 text->compiled = Py_CompileString( buf, text->id.name+2, Py_file_input );
83                 MEM_freeN( buf );
84
85                 if( PyErr_Occurred(  ) ) {
86                         PyErr_Print(  );
87                         free_compiled_text( text );
88                         return NULL;
89                 }
90         }
91
92         return PyImport_ExecCodeModule( name, text->compiled );
93 }
94
95
96 /*
97  * find in-memory module and recompile
98  */
99
100 PyObject *reimportText( PyObject *module )
101 {
102         Text *text;
103         char *txtname;
104         char *name;
105         char *buf = NULL;
106         Main *maggie= bpy_import_main ? bpy_import_main:G.main;
107         
108         /* get name, filename from the module itself */
109
110         txtname = PyModule_GetFilename( module );
111         name = PyModule_GetName( module );
112         if( !txtname || !name)
113                 return NULL;
114
115         /* look up the text object */
116         text = ( Text * ) & ( maggie->text.first );
117         while( text ) {
118                 if( !strcmp( txtname, text->id.name+2 ) )
119                         break;
120                 text = text->id.next;
121         }
122
123         /* uh-oh.... didn't find it */
124         if( !text )
125                 return NULL;
126
127         /* if previously compiled, free the object */
128         /* (can't see how could be NULL, but check just in case) */ 
129         if( text->compiled ){
130                 Py_DECREF( (PyObject *)text->compiled );
131         }
132
133         /* compile the buffer */
134         buf = txt_to_buf( text );
135         text->compiled = Py_CompileString( buf, text->id.name+2, Py_file_input );
136         MEM_freeN( buf );
137
138         /* if compile failed.... return this error */
139         if( PyErr_Occurred(  ) ) {
140                 PyErr_Print(  );
141                 free_compiled_text( text );
142                 return NULL;
143         }
144
145         /* make into a module */
146         return PyImport_ExecCodeModule( name, text->compiled );
147 }
148
149
150 static PyObject *blender_import( PyObject * self, PyObject * args,  PyObject * kw)
151 {
152         PyObject *exception, *err, *tb;
153         char *name;
154         PyObject *globals = NULL, *locals = NULL, *fromlist = NULL;
155         PyObject *m;
156         
157         //PyObject_Print(args, stderr, 0);
158 #if (PY_VERSION_HEX >= 0x02060000)
159         int dummy_val; /* what does this do?*/
160         static char *kwlist[] = {"name", "globals", "locals", "fromlist", "level", 0};
161         
162         if( !PyArg_ParseTupleAndKeywords( args, kw, "s|OOOi:bpy_import", kwlist,
163                                &name, &globals, &locals, &fromlist, &dummy_val) )
164                 return NULL;
165 #else
166         static char *kwlist[] = {"name", "globals", "locals", "fromlist", 0};
167         
168         if( !PyArg_ParseTupleAndKeywords( args, kw, "s|OOO:bpy_import", kwlist,
169                                &name, &globals, &locals, &fromlist ) )
170                 return NULL;
171 #endif
172         m = PyImport_ImportModuleEx( name, globals, locals, fromlist );
173
174         if( m )
175                 return m;
176         else
177                 PyErr_Fetch( &exception, &err, &tb );   /*restore for probable later use */
178
179         m = importText( name );
180         if( m ) {               /* found module, ignore above exception */
181                 PyErr_Clear(  );
182                 Py_XDECREF( exception );
183                 Py_XDECREF( err );
184                 Py_XDECREF( tb );
185                 printf( "imported from text buffer...\n" );
186         } else {
187                 PyErr_Restore( exception, err, tb );
188         }
189         return m;
190 }
191
192
193 /*
194  * our reload() module, to handle reloading in-memory scripts
195  */
196
197 static PyObject *blender_reload( PyObject * self, PyObject * args )
198 {
199         PyObject *exception, *err, *tb;
200         PyObject *module = NULL;
201         PyObject *newmodule = NULL;
202
203         /* check for a module arg */
204         if( !PyArg_ParseTuple( args, "O:bpy_reload", &module ) )
205                 return NULL;
206
207         /* try reimporting from file */
208         newmodule = PyImport_ReloadModule( module );
209         if( newmodule )
210                 return newmodule;
211
212         /* no file, try importing from memory */
213         PyErr_Fetch( &exception, &err, &tb );   /*restore for probable later use */
214
215         newmodule = reimportText( module );
216         if( newmodule ) {               /* found module, ignore above exception */
217                 PyErr_Clear(  );
218                 Py_XDECREF( exception );
219                 Py_XDECREF( err );
220                 Py_XDECREF( tb );
221         } else
222                 PyErr_Restore( exception, err, tb );
223
224         return newmodule;
225 }
226
227 PyMethodDef bpy_import[] = { {"bpy_import", blender_import, METH_KEYWORDS, "blenders import"} };
228 PyMethodDef bpy_reload[] = { {"bpy_reload", blender_reload, METH_VARARGS, "blenders reload"} };
229