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