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