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