source/blender/python/generic/bpy_internal_import.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * Contributor(s): Willian P. Germano, Campbell Barton
  19  *
  20  * ***** END GPL LICENSE BLOCK *****
  21  */
  22
  23 /** \file blender/python/generic/bpy_internal_import.c
  24  *  \ingroup pygen
  25  *
  26  * This file defines replacements for pythons '__import__' and 'imp.reload'
  27  * functions which can import from blender textblocks.
  28  *
  29  * \note
  30  * This should eventually be replaced by import hooks (pep 302).
  31  */
  32
  33
  34 #include <Python.h>
  35 #include <stddef.h>
  36
  37 #include "MEM_guardedalloc.h"
  38
  39 #include "DNA_text_types.h"
  40
  41 #include "BLI_listbase.h"
  42 #include "BLI_path_util.h"
  43 #include "BLI_string.h"
  44 #include "BLI_utildefines.h"
  45
  46 /* UNUSED */
  47 #include "BKE_text.h"  /* txt_to_buf */
  48 #include "BKE_main.h"
  49
  50 #include "bpy_internal_import.h"  /* own include */
  51
  52 static Main *bpy_import_main = NULL;
  53 static ListBase bpy_import_main_list;
  54
  55 static PyMethodDef bpy_import_meth;
  56 static PyMethodDef bpy_reload_meth;
  57 static PyObject   *imp_reload_orig = NULL;
  58
  59 /* 'builtins' is most likely PyEval_GetBuiltins() */
  60
  61 /**
  62  * \note to the discerning developer, yes - this is nasty
  63  * monkey-patching our own import into Python's builtin 'imp' module.
  64  *
  65  * However Python's alternative is to use import hooks,
  66  * which are implemented in a way that we can't use our own importer as a
  67  * fall-back (instead we must try and fail - raise an exception every time).
  68  * Since importing from blenders text-blocks is not the common case
  69  * I prefer to use Pythons import by default and fall-back to
  70  * Blenders - which we can only do by intercepting import calls I'm afraid.
  71  * - Campbell
  72  */
  73 void bpy_import_init(PyObject *builtins)
  74 {
  75         PyObject *item;
  76         PyObject *mod;
  77
  78         PyDict_SetItemString(builtins, "__import__", item = PyCFunction_New(&bpy_import_meth, NULL)); Py_DECREF(item);
  79
  80         /* move reload here
  81          * XXX, use import hooks */
  82         mod = PyImport_ImportModuleLevel("imp", NULL, NULL, NULL, 0);
  83         if (mod) {
  84                 PyObject *mod_dict = PyModule_GetDict(mod);
  85
  86                 /* blender owns the function */
  87                 imp_reload_orig = PyDict_GetItemString(mod_dict, "reload");
  88                 Py_INCREF(imp_reload_orig);
  89
  90                 PyDict_SetItemString(mod_dict, "reload", item = PyCFunction_New(&bpy_reload_meth, NULL)); Py_DECREF(item);
  91                 Py_DECREF(mod);
  92         }
  93         else {
  94                 BLI_assert(!"unable to load 'imp' module.");
  95         }
  96 }
  97
  98
  99 static void free_compiled_text(Text *text)
 100 {
 101         if (text->compiled) {
 102                 Py_DECREF((PyObject *)text->compiled);
 103         }
 104         text->compiled = NULL;
 105 }
 106
 107 struct Main *bpy_import_main_get(void)
 108 {
 109         return bpy_import_main;
 110 }
 111
 112 void bpy_import_main_set(struct Main *maggie)
 113 {
 114         bpy_import_main = maggie;
 115 }
 116
 117 void bpy_import_main_extra_add(struct Main *maggie)
 118 {
 119         BLI_addhead(&bpy_import_main_list, maggie);
 120 }
 121
 122 void bpy_import_main_extra_remove(struct Main *maggie)
 123 {
 124         BLI_remlink_safe(&bpy_import_main_list, maggie);
 125 }
 126
 127 /* returns a dummy filename for a textblock so we can tell what file a text block comes from */
 128 void bpy_text_filename_get(char *fn, size_t fn_len, Text *text)
 129 {
 130         BLI_snprintf(fn, fn_len, "%s%c%s", ID_BLEND_PATH(bpy_import_main, &text->id), SEP, text->id.name + 2);
 131 }
 132
 133 bool bpy_text_compile(Text *text)
 134 {
 135         char fn_dummy[FILE_MAX];
 136         char *buf;
 137
 138         bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);
 139
 140         /* if previously compiled, free the object */
 141         free_compiled_text(text);
 142
 143         buf = txt_to_buf(text);
 144         text->compiled = Py_CompileString(buf, fn_dummy, Py_file_input);
 145         MEM_freeN(buf);
 146
 147         if (PyErr_Occurred()) {
 148                 PyErr_Print();
 149                 PyErr_Clear();
 150                 PySys_SetObject("last_traceback", NULL);
 151                 free_compiled_text(text);
 152                 return false;
 153         }
 154         else {
 155                 return true;
 156         }
 157 }
 158
 159 PyObject *bpy_text_import(Text *text)
 160 {
 161         char modulename[MAX_ID_NAME + 2];
 162         int len;
 163
 164         if (!text->compiled) {
 165                 if (bpy_text_compile(text) == false) {
 166                         return NULL;
 167                 }
 168         }
 169
 170         len = strlen(text->id.name + 2);
 171         BLI_strncpy(modulename, text->id.name + 2, len);
 172         modulename[len - 3] = '\0'; /* remove .py */
 173         return PyImport_ExecCodeModule(modulename, text->compiled);
 174 }
 175
 176 PyObject *bpy_text_import_name(const char *name, int *found)
 177 {
 178         Text *text;
 179         char txtname[MAX_ID_NAME - 2];
 180         int namelen = strlen(name);
 181 //XXX   Main *maggie = bpy_import_main ? bpy_import_main:G.main;
 182         Main *maggie = bpy_import_main;
 183
 184         *found = 0;
 185
 186         if (!maggie) {
 187                 printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n");
 188                 return NULL;
 189         }
 190
 191         /* we know this cant be importable, the name is too long for blender! */
 192         if (namelen >= (MAX_ID_NAME - 2) - 3)
 193                 return NULL;
 194
 195         memcpy(txtname, name, namelen);
 196         memcpy(&txtname[namelen], ".py", 4);
 197
 198         text = BLI_findstring(&maggie->text, txtname, offsetof(ID, name) + 2);
 199
 200         if (text) {
 201                 *found = 1;
 202                 return bpy_text_import(text);
 203         }
 204
 205         /* If we still haven't found the module try additional modules form bpy_import_main_list */
 206         maggie = bpy_import_main_list.first;
 207         while (maggie && !text) {
 208                 text = BLI_findstring(&maggie->text, txtname, offsetof(ID, name) + 2);
 209                 maggie = maggie->next;
 210         }
 211
 212         if (!text)
 213                 return NULL;
 214         else
 215                 *found = 1;
 216
 217         return bpy_text_import(text);
 218 }
 219
 220
 221 /*
 222  * find in-memory module and recompile
 223  */
 224
 225 PyObject *bpy_text_reimport(PyObject *module, int *found)
 226 {
 227         Text *text;
 228         const char *name;
 229         const char *filepath;
 230 //XXX   Main *maggie = bpy_import_main ? bpy_import_main:G.main;
 231         Main *maggie = bpy_import_main;
 232
 233         if (!maggie) {
 234                 printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n");
 235                 return NULL;
 236         }
 237
 238         *found = 0;
 239
 240         /* get name, filename from the module itself */
 241         if ((name = PyModule_GetName(module)) == NULL)
 242                 return NULL;
 243
 244         if ((filepath = (char *)PyModule_GetFilename(module)) == NULL)
 245                 return NULL;
 246
 247         /* look up the text object */
 248         text = BLI_findstring(&maggie->text, BLI_path_basename(filepath), offsetof(ID, name) + 2);
 249
 250         /* uh-oh.... didn't find it */
 251         if (!text)
 252                 return NULL;
 253         else
 254                 *found = 1;
 255
 256         if (bpy_text_compile(text) == false) {
 257                 return NULL;
 258         }
 259
 260         /* make into a module */
 261         return PyImport_ExecCodeModule((char *)name, text->compiled);
 262 }
 263
 264
 265 static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
 266 {
 267         PyObject *exception, *err, *tb;
 268         const char *name;
 269         int found = 0;
 270         PyObject *globals = NULL, *locals = NULL, *fromlist = NULL;
 271         int level = 0; /* relative imports */
 272
 273         PyObject *newmodule;
 274         //PyObject_Print(args, stderr, 0);
 275         static const char *kwlist[] = {"name", "globals", "locals", "fromlist", "level", NULL};
 276
 277         if (!PyArg_ParseTupleAndKeywords(args, kw, "s|OOOi:bpy_import_meth", (char **)kwlist,
 278                                          &name, &globals, &locals, &fromlist, &level))
 279         {
 280                 return NULL;
 281         }
 282
 283         /* import existing builtin modules or modules that have been imported already */
 284         newmodule = PyImport_ImportModuleLevel(name, globals, locals, fromlist, level);
 285
 286         if (newmodule)
 287                 return newmodule;
 288
 289         PyErr_Fetch(&exception, &err, &tb); /* get the python error in case we cant import as blender text either */
 290
 291         /* importing from existing modules failed, see if we have this module as blender text */
 292         newmodule = bpy_text_import_name(name, &found);
 293
 294         if (newmodule) { /* found module as blender text, ignore above exception */
 295                 PyErr_Clear();
 296                 Py_XDECREF(exception);
 297                 Py_XDECREF(err);
 298                 Py_XDECREF(tb);
 299                 /* printf("imported from text buffer...\n"); */
 300         }
 301         else if (found == 1) { /* blender text module failed to execute but was found, use its error message */
 302                 Py_XDECREF(exception);
 303                 Py_XDECREF(err);
 304                 Py_XDECREF(tb);
 305                 return NULL;
 306         }
 307         else {
 308                 /* no blender text was found that could import the module
 309                  * reuse the original error from PyImport_ImportModuleEx */
 310                 PyErr_Restore(exception, err, tb);
 311         }
 312         return newmodule;
 313 }
 314
 315
 316 /*
 317  * our reload() module, to handle reloading in-memory scripts
 318  */
 319
 320 static PyObject *blender_reload(PyObject *UNUSED(self), PyObject *module)
 321 {
 322         PyObject *exception, *err, *tb;
 323         PyObject *newmodule = NULL;
 324         int found = 0;
 325
 326         /* try reimporting from file */
 327
 328         /* in Py3.3 this just calls imp.reload() which we overwrite, causing recursive calls */
 329         //newmodule = PyImport_ReloadModule(module);
 330
 331         newmodule = PyObject_CallFunctionObjArgs(imp_reload_orig, module, NULL);
 332
 333         if (newmodule)
 334                 return newmodule;
 335
 336         /* no file, try importing from memory */
 337         PyErr_Fetch(&exception, &err, &tb); /*restore for probable later use */
 338
 339         newmodule = bpy_text_reimport(module, &found);
 340         if (newmodule) { /* found module as blender text, ignore above exception */
 341                 PyErr_Clear();
 342                 Py_XDECREF(exception);
 343                 Py_XDECREF(err);
 344                 Py_XDECREF(tb);
 345                 /* printf("imported from text buffer...\n"); */
 346         }
 347         else if (found == 1) { /* blender text module failed to execute but was found, use its error message */
 348                 Py_XDECREF(exception);
 349                 Py_XDECREF(err);
 350                 Py_XDECREF(tb);
 351                 return NULL;
 352         }
 353         else {
 354                 /* no blender text was found that could import the module
 355                  * reuse the original error from PyImport_ImportModuleEx */
 356                 PyErr_Restore(exception, err, tb);
 357         }
 358
 359         return newmodule;
 360 }
 361
 362 static PyMethodDef bpy_import_meth = {"bpy_import_meth", (PyCFunction)blender_import, METH_VARARGS | METH_KEYWORDS, "blenders import"};
 363 static PyMethodDef bpy_reload_meth = {"bpy_reload_meth", (PyCFunction)blender_reload, METH_O, "blenders reload"};