source/blender/python/api2_2x/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 "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, int *found )
  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         *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 *reimportText( PyObject *module, int *found )
 107 {
 108         Text *text;
 109         char *txtname;
 110         char *name;
 111         char *buf = NULL;
 112         Main *maggie= bpy_import_main ? bpy_import_main:G.main;
 113
 114         *found= 0;
 115
 116         /* get name, filename from the module itself */
 117
 118         txtname = PyModule_GetFilename( module );
 119         name = PyModule_GetName( module );
 120         if( !txtname || !name)
 121                 return NULL;
 122
 123         /* look up the text object */
 124         text = ( Text * ) & ( maggie->text.first );
 125         while( text ) {
 126                 if( !strcmp( txtname, text->id.name+2 ) )
 127                         break;
 128                 text = text->id.next;
 129         }
 130
 131         /* uh-oh.... didn't find it */
 132         if( !text )
 133                 return NULL;
 134         else
 135                 *found = 1;
 136
 137         /* if previously compiled, free the object */
 138         /* (can't see how could be NULL, but check just in case) */
 139         if( text->compiled ){
 140                 Py_DECREF( (PyObject *)text->compiled );
 141         }
 142
 143         /* compile the buffer */
 144         buf = txt_to_buf( text );
 145         text->compiled = Py_CompileString( buf, text->id.name+2, Py_file_input );
 146         MEM_freeN( buf );
 147
 148         /* if compile failed.... return this error */
 149         if( PyErr_Occurred(  ) ) {
 150                 PyErr_Print(  );
 151                 PyErr_Clear(  );
 152                 PySys_SetObject("last_traceback", NULL);
 153                 free_compiled_text( text );
 154                 return NULL;
 155         }
 156
 157         /* make into a module */
 158         return PyImport_ExecCodeModule( name, text->compiled );
 159 }
 160
 161
 162 static PyObject *blender_import( PyObject * self, PyObject * args,  PyObject * kw)
 163 {
 164         PyObject *exception, *err, *tb;
 165         char *name;
 166         int found= 0;
 167         PyObject *globals = NULL, *locals = NULL, *fromlist = NULL;
 168         PyObject *newmodule;
 169
 170         //PyObject_Print(args, stderr, 0);
 171 #if (PY_VERSION_HEX >= 0x02060000)
 172         int dummy_val; /* what does this do?*/
 173         static char *kwlist[] = {"name", "globals", "locals", "fromlist", "level", 0};
 174
 175         if( !PyArg_ParseTupleAndKeywords( args, kw, "s|OOOi:bpy_import", kwlist,
 176                                &name, &globals, &locals, &fromlist, &dummy_val) )
 177                 return NULL;
 178 #else
 179         static char *kwlist[] = {"name", "globals", "locals", "fromlist", 0};
 180
 181         if( !PyArg_ParseTupleAndKeywords( args, kw, "s|OOO:bpy_import", kwlist,
 182                                &name, &globals, &locals, &fromlist ) )
 183                 return NULL;
 184 #endif
 185
 186         /* import existing builtin modules or modules that have been imported alredy */
 187         newmodule = PyImport_ImportModuleEx( name, globals, locals, fromlist );
 188
 189         if(newmodule)
 190                 return newmodule;
 191
 192         PyErr_Fetch( &exception, &err, &tb );   /* get the python error incase we cant import as blender text either */
 193
 194         /* importing from existing modules failed, see if we have this module as blender text */
 195         newmodule = importText( name, &found );
 196
 197         if( newmodule ) {/* found module as blender text, ignore above exception */
 198                 PyErr_Clear(  );
 199                 Py_XDECREF( exception );
 200                 Py_XDECREF( err );
 201                 Py_XDECREF( tb );
 202                 /* printf( "imported from text buffer...\n" ); */
 203         }
 204         else if (found==1) { /* blender text module failed to execute but was found, use its error message */
 205                 Py_XDECREF( exception );
 206                 Py_XDECREF( err );
 207                 Py_XDECREF( tb );
 208                 return NULL;
 209         }
 210         else {
 211                 /* no blender text was found that could import the module
 212                  * rause the original error from PyImport_ImportModuleEx */
 213                 PyErr_Restore( exception, err, tb );
 214         }
 215         return newmodule;
 216 }
 217
 218
 219 /*
 220  * our reload() module, to handle reloading in-memory scripts
 221  */
 222
 223 static PyObject *blender_reload( PyObject * self, PyObject * args )
 224 {
 225         PyObject *exception, *err, *tb;
 226         PyObject *module = NULL;
 227         PyObject *newmodule = NULL;
 228         int found= 0;
 229
 230         /* check for a module arg */
 231         if( !PyArg_ParseTuple( args, "O:bpy_reload", &module ) )
 232                 return NULL;
 233
 234         /* try reimporting from file */
 235         newmodule = PyImport_ReloadModule( module );
 236         if( newmodule )
 237                 return newmodule;
 238
 239         /* no file, try importing from memory */
 240         PyErr_Fetch( &exception, &err, &tb );   /*restore for probable later use */
 241
 242         newmodule = reimportText( module, &found );
 243         if( newmodule ) {/* found module as blender text, ignore above exception */
 244                 PyErr_Clear(  );
 245                 Py_XDECREF( exception );
 246                 Py_XDECREF( err );
 247                 Py_XDECREF( tb );
 248                 /* printf( "imported from text buffer...\n" ); */
 249         }
 250         else if (found==1) { /* blender text module failed to execute but was found, use its error message */
 251                 Py_XDECREF( exception );
 252                 Py_XDECREF( err );
 253                 Py_XDECREF( tb );
 254                 return NULL;
 255         }
 256         else {
 257                 /* no blender text was found that could import the module
 258                  * rause the original error from PyImport_ImportModuleEx */
 259                 PyErr_Restore( exception, err, tb );
 260         }
 261
 262         return newmodule;
 263 }
 264
 265 PyMethodDef bpy_import[] = { {"bpy_import", blender_import, METH_KEYWORDS, "blenders import"} };
 266 PyMethodDef bpy_reload[] = { {"bpy_reload", blender_reload, METH_VARARGS, "blenders reload"} };
 267
 268
 269 /* Clear user modules.
 270  * This is to clear any modules that could be defined from running scripts in blender.
 271  *
 272  * Its also needed for the BGE Python api so imported scripts are not used between levels
 273  *
 274  * This clears every modules that has a __file__ attribute (is not a builtin)
 275  * and is a filename only (no path). since pythons bultins include a full path even for win32.
 276  * even if we remove a python module a reimport will bring it back again.
 277  */
 278
 279
 280 #if defined(WIN32) || defined(WIN64)
 281 #define SEPSTR "\\"
 282 #else
 283 #define SEPSTR "/"
 284 #endif
 285
 286
 287 void importClearUserModules(void)
 288 {
 289         PyObject *modules= PySys_GetObject("modules");
 290
 291         char *fname;
 292         char *file_extension;
 293
 294         /* looping over the dict */
 295         PyObject *key, *value;
 296         Py_ssize_t pos = 0;
 297
 298         /* new list */
 299         PyObject *list= PyList_New(0);
 300
 301         /* go over sys.modules and remove anything with a
 302          * sys.modukes[x].__file__ thats ends with a .py and has no path
 303          */
 304         while (PyDict_Next(modules, &pos, &key, &value)) {
 305                 fname= PyModule_GetFilename(value);
 306                 if(fname) {
 307                         if ((strstr(fname, SEPSTR))==0) { /* no path ? */
 308                                 file_extension = strstr(fname, ".py");
 309                                 if(file_extension && *(file_extension + 3) == '\0') { /* .py extension ? */
 310                                         /* now we can be fairly sure its a python import from the blendfile */
 311                                         PyList_Append(list, key); /* free'd with the list */
 312                                 }
 313                         }
 314                 }
 315                 else {
 316                         PyErr_Clear();
 317                 }
 318         }
 319
 320         /* remove all our modules */
 321         for(pos=0; pos < PyList_Size(list); pos++) {
 322                 /* PyObject_Print(key, stderr, 0); */
 323                 key= PyList_GET_ITEM(list, pos);
 324                 PyDict_DelItem(modules, key);
 325         }
 326
 327         Py_DECREF(list); /* removes all references from append */
 328 }
 329