use Py_SetPythonHome rather then setting environment vars PYTHONHOME and PYTHONPATH
[blender-staging.git] / source / blender / python / intern / bpy_interface.c
1 /**
2  * $Id:
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * Contributor(s): Michel Selten, Willian P. Germano, Stephen Swaney,
21  * Chris Keith, Chris Want, Ken Hughes, Campbell Barton
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25  
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <sys/stat.h>
30
31
32 /* grr, python redefines */
33 #ifdef _POSIX_C_SOURCE
34 #undef _POSIX_C_SOURCE
35 #endif
36
37 #include <Python.h>
38 #include "compile.h"            /* for the PyCodeObject */
39 #include "eval.h"               /* for PyEval_EvalCode */
40
41 #include "bpy_rna.h"
42 #include "bpy_operator.h"
43 #include "bpy_ui.h"
44 #include "bpy_util.h"
45
46 #ifndef WIN32
47 #include <dirent.h>
48 #else
49 #include "BLI_winstuff.h"
50 #endif
51
52 #include "DNA_anim_types.h"
53 #include "DNA_space_types.h"
54 #include "DNA_text_types.h"
55
56 #include "MEM_guardedalloc.h"
57
58 #include "BLI_util.h"
59 #include "BLI_storage.h"
60 #include "BLI_fileops.h"
61 #include "BLI_string.h"
62
63 #include "BKE_context.h"
64 #include "BKE_fcurve.h"
65 #include "BKE_text.h"
66
67 #include "BPY_extern.h"
68
69 #include "../generic/bpy_internal_import.h" // our own imports
70 /* external util modules */
71
72 #include "../generic/Mathutils.h"
73 #include "../generic/Geometry.h"
74 #include "../generic/BGL.h"
75
76
77 /* for internal use, when starting and ending python scripts */
78
79 /* incase a python script triggers another python call, stop bpy_context_clear from invalidating */
80 static int py_call_level= 0;
81
82
83 // only for tests
84 #define TIME_PY_RUN
85
86 #ifdef TIME_PY_RUN
87 #include "PIL_time.h"
88 static int              bpy_timer_count = 0;
89 static double   bpy_timer; /* time since python starts */
90 static double   bpy_timer_run; /* time for each python script run */
91 static double   bpy_timer_run_tot; /* accumulate python runs */
92 #endif
93
94 void bpy_context_set(bContext *C, PyGILState_STATE *gilstate)
95 {
96         py_call_level++;
97
98         if(gilstate)
99                 *gilstate = PyGILState_Ensure();
100
101         if(py_call_level==1) {
102
103                 BPY_update_modules(); /* can give really bad results if this isnt here */
104
105                 if(C) { // XXX - should always be true.
106                         BPy_SetContext(C);
107                         bpy_import_main_set(CTX_data_main(C));
108                 }
109                 else {
110                         fprintf(stderr, "ERROR: Python context called with a NULL Context. this should not happen!\n");
111                 }
112
113 #ifdef TIME_PY_RUN
114                 if(bpy_timer_count==0) {
115                         /* record time from the beginning */
116                         bpy_timer= PIL_check_seconds_timer();
117                         bpy_timer_run = bpy_timer_run_tot = 0.0;
118                 }
119                 bpy_timer_run= PIL_check_seconds_timer();
120
121
122                 bpy_timer_count++;
123 #endif
124         }
125 }
126
127 void bpy_context_clear(bContext *C, PyGILState_STATE *gilstate)
128 {
129         py_call_level--;
130
131         if(gilstate)
132                 PyGILState_Release(*gilstate);
133
134         if(py_call_level < 0) {
135                 fprintf(stderr, "ERROR: Python context internal state bug. this should not happen!\n");
136         }
137         else if(py_call_level==0) {
138                 // XXX - Calling classes currently wont store the context :\, cant set NULL because of this. but this is very flakey still.
139                 //BPy_SetContext(NULL);
140                 //bpy_import_main_set(NULL);
141
142 #ifdef TIME_PY_RUN
143                 bpy_timer_run_tot += PIL_check_seconds_timer() - bpy_timer_run;
144                 bpy_timer_count++;
145 #endif
146
147         }
148 }
149
150
151 void BPY_free_compiled_text( struct Text *text )
152 {
153         if( text->compiled ) {
154                 Py_DECREF( ( PyObject * ) text->compiled );
155                 text->compiled = NULL;
156         }
157 }
158
159 /*****************************************************************************
160 * Description: Creates the bpy module and adds it to sys.modules for importing
161 *****************************************************************************/
162 static void bpy_init_modules( void )
163 {
164         PyObject *mod;
165         
166         mod = PyModule_New("bpy");
167         
168         PyModule_AddObject( mod, "data", BPY_rna_module() );
169         /* PyModule_AddObject( mod, "doc", BPY_rna_doc() ); */
170         PyModule_AddObject( mod, "types", BPY_rna_types() );
171         PyModule_AddObject( mod, "props", BPY_rna_props() );
172         PyModule_AddObject( mod, "__ops__", BPY_operator_module() ); /* ops is now a python module that does the conversion from SOME_OT_foo -> some.foo */
173         PyModule_AddObject( mod, "ui", BPY_ui_module() ); // XXX very experimental, consider this a test, especially PyCObject is not meant to be permanent
174         
175         /* add the module so we can import it */
176         PyDict_SetItemString(PySys_GetObject("modules"), "bpy", mod);
177         Py_DECREF(mod);
178
179
180         /* stand alone utility modules not related to blender directly */
181         Geometry_Init();
182         Mathutils_Init();
183         BGL_Init();
184 }
185
186 void BPY_update_modules( void )
187 {
188 #if 0 // slow, this runs all the time poll, draw etc 100's of time a sec.
189         PyObject *mod= PyImport_ImportModuleLevel("bpy", NULL, NULL, NULL, 0);
190         PyModule_AddObject( mod, "data", BPY_rna_module() );
191         PyModule_AddObject( mod, "types", BPY_rna_types() ); // atm this does not need updating
192 #endif
193
194         /* refreshes the main struct */
195         BPY_update_rna_module();
196
197 }
198
199 /*****************************************************************************
200 * Description: This function creates a new Python dictionary object.
201 *****************************************************************************/
202 static PyObject *CreateGlobalDictionary( bContext *C )
203 {
204         PyObject *mod;
205         PyObject *dict = PyDict_New(  );
206         PyObject *item = PyUnicode_FromString( "__main__" );
207         PyDict_SetItemString( dict, "__builtins__", PyEval_GetBuiltins(  ) );
208         PyDict_SetItemString( dict, "__name__", item );
209         Py_DECREF(item);
210         
211         // XXX - put somewhere more logical
212         {
213                 PyMethodDef *ml;
214                 static PyMethodDef bpy_prop_meths[] = {
215                         {"FloatProperty", (PyCFunction)BPy_FloatProperty, METH_VARARGS|METH_KEYWORDS, ""},
216                         {"IntProperty", (PyCFunction)BPy_IntProperty, METH_VARARGS|METH_KEYWORDS, ""},
217                         {"BoolProperty", (PyCFunction)BPy_BoolProperty, METH_VARARGS|METH_KEYWORDS, ""},
218                         {"StringProperty", (PyCFunction)BPy_StringProperty, METH_VARARGS|METH_KEYWORDS, ""},
219                         {NULL, NULL, 0, NULL}
220                 };
221                 
222                 for(ml = bpy_prop_meths; ml->ml_name; ml++) {
223                         PyDict_SetItemString( dict, ml->ml_name, PyCFunction_New(ml, NULL));
224                 }
225         }
226         
227         /* add bpy to global namespace */
228         mod= PyImport_ImportModuleLevel("bpy", NULL, NULL, NULL, 0);
229         PyDict_SetItemString( dict, "bpy", mod );
230         Py_DECREF(mod);
231         
232         return dict;
233 }
234
235 /* Use this so we can include our own python bundle */
236 #if 0
237 wchar_t* Py_GetPath(void)
238 {
239         int i;
240         static wchar_t py_path[FILE_MAXDIR] = L"";
241         char *dirname= BLI_gethome_folder("python");
242         if(dirname) {
243                 i= mbstowcs(py_path, dirname, FILE_MAXDIR);
244                 printf("py path %s, %d\n", dirname, i);
245         }
246         return py_path;
247 }
248 #endif
249
250
251 /* must be called before Py_Initialize */
252 void BPY_start_python_path(void)
253 {
254         char *py_path_bundle= BLI_gethome_folder("python");
255
256         if(py_path_bundle==NULL)
257                 return;
258
259         /* set the environment path */
260         printf("found bundled python: %s\n", py_path_bundle);
261
262 #if 0
263         BLI_setenv("PYTHONHOME", py_path_bundle);
264         BLI_setenv("PYTHONPATH", py_path_bundle);
265 #endif
266
267         {
268                 static wchar_t py_path_bundle_wchar[FILE_MAXDIR];
269
270                 mbstowcs(py_path_bundle_wchar, py_path_bundle, FILE_MAXDIR);
271                 Py_SetPythonHome(py_path_bundle_wchar);
272         }
273 }
274
275
276 void BPY_start_python( int argc, char **argv )
277 {
278         PyThreadState *py_tstate = NULL;
279         
280         BPY_start_python_path(); /* allow to use our own included python */
281
282         Py_Initialize(  );
283         
284         // PySys_SetArgv( argc, argv); // broken in py3, not a huge deal
285         /* sigh, why do python guys not have a char** version anymore? :( */
286         {
287                 int i;
288                 PyObject *py_argv= PyList_New(argc);
289
290                 for (i=0; i<argc; i++)
291                         PyList_SET_ITEM(py_argv, i, PyUnicode_FromString(argv[i]));
292
293                 PySys_SetObject("argv", py_argv);
294                 Py_DECREF(py_argv);
295         }
296         
297         /* Initialize thread support (also acquires lock) */
298         PyEval_InitThreads();
299         
300         
301         /* bpy.* and lets us import it */
302         bpy_init_modules(); 
303
304         { /* our own import and reload functions */
305                 PyObject *item;
306                 //PyObject *m = PyImport_AddModule("__builtin__");
307                 //PyObject *d = PyModule_GetDict(m);
308                 PyObject *d = PyEval_GetBuiltins(  );
309                 PyDict_SetItemString(d, "reload",               item=PyCFunction_New(bpy_reload_meth, NULL));   Py_DECREF(item);
310                 PyDict_SetItemString(d, "__import__",   item=PyCFunction_New(bpy_import_meth, NULL));   Py_DECREF(item);
311         }
312         
313         pyrna_alloc_types();
314
315         py_tstate = PyGILState_GetThisThreadState();
316         PyEval_ReleaseThread(py_tstate);
317 }
318
319 void BPY_end_python( void )
320 {
321         // fprintf(stderr, "Ending Python!\n");
322
323         PyGILState_Ensure(); /* finalizing, no need to grab the state */
324         
325         // free other python data.
326         pyrna_free_types();
327
328         /* clear all python data from structs */
329         
330         Py_Finalize(  );
331         
332 #ifdef TIME_PY_RUN
333         // measure time since py started
334         bpy_timer = PIL_check_seconds_timer() - bpy_timer;
335
336         printf("*bpy stats* - ");
337         printf("tot exec: %d,  ", bpy_timer_count);
338         printf("tot run: %.4fsec,  ", bpy_timer_run_tot);
339         if(bpy_timer_count>0)
340                 printf("average run: %.6fsec,  ", (bpy_timer_run_tot/bpy_timer_count));
341
342         if(bpy_timer>0.0)
343                 printf("tot usage %.4f%%", (bpy_timer_run_tot/bpy_timer)*100.0);
344
345         printf("\n");
346
347         // fprintf(stderr, "Ending Python Done!\n");
348
349 #endif
350
351 }
352
353 /* Can run a file or text block */
354 int BPY_run_python_script( bContext *C, const char *fn, struct Text *text, struct ReportList *reports)
355 {
356         PyObject *py_dict, *py_result= NULL;
357         PyGILState_STATE gilstate;
358         
359         if (fn==NULL && text==NULL) {
360                 return 0;
361         }
362         
363         bpy_context_set(C, &gilstate);
364         
365         py_dict = CreateGlobalDictionary(C);
366
367         if (text) {
368                 
369                 if( !text->compiled ) { /* if it wasn't already compiled, do it now */
370                         char *buf = txt_to_buf( text );
371
372                         text->compiled =
373                                 Py_CompileString( buf, text->id.name+2, Py_file_input );
374
375                         MEM_freeN( buf );
376
377                         if( PyErr_Occurred(  ) ) {
378                                 BPY_free_compiled_text( text );
379                         }
380                 }
381                 if(text->compiled)
382                         py_result =  PyEval_EvalCode( text->compiled, py_dict, py_dict );
383                 
384         } else {
385 #if 0
386                 char *pystring;
387                 pystring= malloc(strlen(fn) + 32);
388                 pystring[0]= '\0';
389                 sprintf(pystring, "exec(open(r'%s').read())", fn);
390                 py_result = PyRun_String( pystring, Py_file_input, py_dict, py_dict );
391                 free(pystring);
392 #else
393                 FILE *fp= fopen(fn, "r");               
394                 if(fp) {
395                         py_result = PyRun_File(fp, fn, Py_file_input, py_dict, py_dict);
396                         fclose(fp);
397                 }
398                 else {
399                         PyErr_Format(PyExc_SystemError, "Python file \"%s\" could not be opened: %s", fn, strerror(errno));
400                         py_result= NULL;
401                 }
402 #endif
403         }
404         
405         if (!py_result) {
406                 BPy_errors_to_report(reports);
407         } else {
408                 Py_DECREF( py_result );
409         }
410         
411         Py_DECREF(py_dict);
412         
413         bpy_context_clear(C, &gilstate);
414
415         return py_result ? 1:0;
416 }
417
418
419 /* TODO - move into bpy_space.c ? */
420 /* GUI interface routines */
421
422 /* Copied from Draw.c */
423 static void exit_pydraw( SpaceScript * sc, short err )
424 {
425         Script *script = NULL;
426
427         if( !sc || !sc->script )
428                 return;
429
430         script = sc->script;
431
432         if( err ) {
433                 BPy_errors_to_report(NULL); // TODO, reports
434                 script->flags = 0;      /* mark script struct for deletion */
435                 SCRIPT_SET_NULL(script);
436                 script->scriptname[0] = '\0';
437                 script->scriptarg[0] = '\0';
438 // XXX 2.5              error_pyscript();
439 // XXX 2.5              scrarea_queue_redraw( sc->area );
440         }
441
442 #if 0 // XXX 2.5
443         BPy_Set_DrawButtonsList(sc->but_refs);
444         BPy_Free_DrawButtonsList(); /*clear all temp button references*/
445 #endif
446
447         sc->but_refs = NULL;
448         
449         Py_XDECREF( ( PyObject * ) script->py_draw );
450         Py_XDECREF( ( PyObject * ) script->py_event );
451         Py_XDECREF( ( PyObject * ) script->py_button );
452
453         script->py_draw = script->py_event = script->py_button = NULL;
454 }
455
456 static int bpy_run_script_init(bContext *C, SpaceScript * sc)
457 {
458         if (sc->script==NULL) 
459                 return 0;
460         
461         if (sc->script->py_draw==NULL && sc->script->scriptname[0] != '\0')
462                 BPY_run_python_script(C, sc->script->scriptname, NULL, NULL);
463                 
464         if (sc->script->py_draw==NULL)
465                 return 0;
466         
467         return 1;
468 }
469
470 int BPY_run_script_space_draw(const struct bContext *C, SpaceScript * sc)
471 {
472         if (bpy_run_script_init( (bContext *)C, sc)) {
473                 PyGILState_STATE gilstate = PyGILState_Ensure();
474                 PyObject *result = PyObject_CallObject( sc->script->py_draw, NULL );
475                 
476                 if (result==NULL)
477                         exit_pydraw(sc, 1);
478                         
479                 PyGILState_Release(gilstate);
480         }
481         return 1;
482 }
483
484 // XXX - not used yet, listeners dont get a context
485 int BPY_run_script_space_listener(bContext *C, SpaceScript * sc)
486 {
487         if (bpy_run_script_init(C, sc)) {
488                 PyGILState_STATE gilstate = PyGILState_Ensure();
489                 
490                 PyObject *result = PyObject_CallObject( sc->script->py_draw, NULL );
491                 
492                 if (result==NULL)
493                         exit_pydraw(sc, 1);
494                         
495                 PyGILState_Release(gilstate);
496         }
497         return 1;
498 }
499
500 void BPY_DECREF(void *pyob_ptr)
501 {
502         Py_DECREF((PyObject *)pyob_ptr);
503 }
504
505 #if 0
506 /* called from the the scripts window, assume context is ok */
507 int BPY_run_python_script_space(const char *modulename, const char *func)
508 {
509         PyObject *py_dict, *py_result= NULL;
510         char pystring[512];
511         PyGILState_STATE gilstate;
512         
513         /* for calling the module function */
514         PyObject *py_func, 
515         
516         gilstate = PyGILState_Ensure();
517         
518         py_dict = CreateGlobalDictionary(C);
519         
520         PyObject *module = PyImport_ImportModule(scpt->script.filename);
521         if (module==NULL) {
522                 PyErr_SetFormat(PyExc_SystemError, "could not import '%s'", scpt->script.filename);
523         }
524         else {
525                 py_func = PyObject_GetAttrString(modulename, func);
526                 if (py_func==NULL) {
527                         PyErr_SetFormat(PyExc_SystemError, "module has no function '%s.%s'\n", scpt->script.filename, func);
528                 }
529                 else {
530                         Py_DECREF(py_func);
531                         if (!PyCallable_Check(py_func)) {
532                                 PyErr_SetFormat(PyExc_SystemError, "module item is not callable '%s.%s'\n", scpt->script.filename, func);
533                         }
534                         else {
535                                 py_result= PyObject_CallObject(py_func, NULL); // XXX will need args eventually
536                         }
537                 }
538         }
539         
540         if (!py_result) {
541                 BPy_errors_to_report(NULL); // TODO - reports
542         } else
543                 Py_DECREF( py_result );
544         
545         Py_XDECREF(module);
546         
547         Py_DECREF(py_dict);
548         
549         PyGILState_Release(gilstate);
550         return 1;
551 }
552 #endif
553
554 // #define TIME_REGISTRATION
555
556 #ifdef TIME_REGISTRATION
557 #include "PIL_time.h"
558 #endif
559
560 /* for use by BPY_run_ui_scripts only */
561 static int bpy_import_module(char *modname, int reload)
562 {
563         PyObject *mod= PyImport_ImportModuleLevel(modname, NULL, NULL, NULL, 0);
564         if (mod) {
565                 if (reload) {
566                         PyObject *mod_orig= mod;
567                         mod= PyImport_ReloadModule(mod);
568                         Py_DECREF(mod_orig);
569                 }
570         }
571
572         if(mod) {
573                 Py_DECREF(mod); /* could be NULL from reloading */
574                 return 0;
575         } else {
576                 return -1;
577         }
578 }
579
580 /* XXX this is temporary, need a proper script registration system for 2.5 */
581 void BPY_run_ui_scripts(bContext *C, int reload)
582 {
583 #ifdef TIME_REGISTRATION
584         double time = PIL_check_seconds_timer();
585 #endif
586         DIR *dir; 
587         struct dirent *de;
588         char *file_extension;
589         char *dirname;
590         char path[FILE_MAX];
591         char *dirs[] = {"ui", "io", NULL};
592         int a, err;
593         
594         PyGILState_STATE gilstate;
595         PyObject *sys_path;
596
597         bpy_context_set(C, &gilstate);
598
599         sys_path= PySys_GetObject("path"); /* borrow */
600         PyList_Insert(sys_path, 0, Py_None); /* place holder, resizes the list */
601
602         for(a=0; dirs[a]; a++) {
603                 dirname= BLI_gethome_folder(dirs[a]);
604
605                 if(!dirname)
606                         continue;
607
608                 dir = opendir(dirname);
609
610                 if(!dir)
611                         continue;
612                 
613                 /* set the first dir in the sys.path for fast importing of modules */
614                 PyList_SetItem(sys_path, 0, PyUnicode_FromString(dirname)); /* steals the ref */
615                         
616                 while((de = readdir(dir)) != NULL) {
617                         /* We could stat the file but easier just to let python
618                          * import it and complain if theres a problem */
619                         err = 0;
620
621                         if (de->d_name[0] == '.') {
622                                 /* do nothing, probably .svn */
623                         }
624                         else if ((file_extension = strstr(de->d_name, ".py"))) {
625                                 /* normal py files? */
626                                 if(file_extension && file_extension[3] == '\0') {
627                                         de->d_name[(file_extension - de->d_name)] = '\0';
628                                         err= bpy_import_module(de->d_name, reload);
629                                 }
630                         }
631 #ifndef __linux__
632                         else if( BLI_join_dirfile(path, dirname, de->d_name), S_ISDIR(BLI_exist(path))) {
633 #else
634                         else if(de->d_type==DT_DIR) {
635                                 BLI_join_dirfile(path, dirname, de->d_name);
636 #endif
637                                 /* support packages */
638                                 BLI_join_dirfile(path, path, "__init__.py");
639
640                                 if(BLI_exists(path)) {
641                                         err= bpy_import_module(de->d_name, reload);
642                                 }
643                         }
644
645                         if(err==-1) {
646                                 BPy_errors_to_report(NULL);
647                                 fprintf(stderr, "unable to import %s/%s\n", dirname, de->d_name);
648                         }
649                 }
650
651                 closedir(dir);
652         }
653         
654         PyList_SetSlice(sys_path, 0, 1, NULL); /* remove the first item */
655
656         bpy_context_clear(C, &gilstate);
657         
658 #ifdef TIME_REGISTRATION
659         printf("script time %f\n", (PIL_check_seconds_timer()-time));
660 #endif
661
662         /* reset the timer so as not to take loading into the stats */
663         bpy_timer_count = 0;
664 }
665
666 /* ****************************************** */
667 /* Drivers - PyExpression Evaluation */
668
669 /* for pydrivers (drivers using one-line Python expressions to express relationships between targets) */
670 PyObject *bpy_pydriver_Dict = NULL;
671
672 /* For faster execution we keep a special dictionary for pydrivers, with
673  * the needed modules and aliases. 
674  */
675 static int bpy_pydriver_create_dict(void)
676 {
677         PyObject *d, *mod;
678         
679         /* validate namespace for driver evaluation */
680         if (bpy_pydriver_Dict) return -1;
681
682         d = PyDict_New();
683         if (d == NULL) 
684                 return -1;
685         else
686                 bpy_pydriver_Dict = d;
687
688         /* import some modules: builtins, bpy, math, (Blender.noise )*/
689         PyDict_SetItemString(d, "__builtins__", PyEval_GetBuiltins());
690
691         mod = PyImport_ImportModule("math");
692         if (mod) {
693                 PyDict_Merge(d, PyModule_GetDict(mod), 0); /* 0 - dont overwrite existing values */
694                 
695                 /* Only keep for backwards compat! - just import all math into root, they are standard */
696                 PyDict_SetItemString(d, "math", mod);
697                 PyDict_SetItemString(d, "m", mod);
698                 Py_DECREF(mod);
699         } 
700         
701         /* add bpy to global namespace */
702         mod= PyImport_ImportModuleLevel("bpy", NULL, NULL, NULL, 0);
703         if (mod) {
704                 PyDict_SetItemString(bpy_pydriver_Dict, "bpy", mod);
705                 Py_DECREF(mod);
706         }
707         
708         
709 #if 0 // non existant yet
710         mod = PyImport_ImportModule("Blender.Noise");
711         if (mod) {
712                 PyDict_SetItemString(d, "noise", mod);
713                 PyDict_SetItemString(d, "n", mod);
714                 Py_DECREF(mod);
715         } else {
716                 PyErr_Clear();
717         }
718         
719         /* If there's a Blender text called pydrivers.py, import it.
720          * Users can add their own functions to this module. 
721          */
722         if (G.f & G_DOSCRIPTLINKS) {
723                 mod = importText("pydrivers"); /* can also use PyImport_Import() */
724                 if (mod) {
725                         PyDict_SetItemString(d, "pydrivers", mod);
726                         PyDict_SetItemString(d, "p", mod);
727                         Py_DECREF(mod);
728                 } else {
729                         PyErr_Clear();
730                 }
731         }
732 #endif // non existant yet
733         
734         return 0;
735 }
736
737 /* Update function, it gets rid of pydrivers global dictionary, forcing
738  * BPY_pydriver_eval to recreate it. This function is used to force
739  * reloading the Blender text module "pydrivers.py", if available, so
740  * updates in it reach pydriver evaluation. 
741  */
742 void BPY_pydriver_update(void)
743 {
744         PyGILState_STATE gilstate = PyGILState_Ensure();
745
746         if (bpy_pydriver_Dict) { /* free the global dict used by pydrivers */
747                 PyDict_Clear(bpy_pydriver_Dict);
748                 Py_DECREF(bpy_pydriver_Dict);
749                 bpy_pydriver_Dict = NULL;
750         }
751
752         PyGILState_Release(gilstate);
753
754         return;
755 }
756
757 /* error return function for BPY_eval_pydriver */
758 static float pydriver_error(ChannelDriver *driver) 
759 {
760         if (bpy_pydriver_Dict) { /* free the global dict used by pydrivers */
761                 PyDict_Clear(bpy_pydriver_Dict);
762                 Py_DECREF(bpy_pydriver_Dict);
763                 bpy_pydriver_Dict = NULL;
764         }
765
766         driver->flag |= DRIVER_FLAG_INVALID; /* py expression failed */
767         fprintf(stderr, "\nError in Driver: The following Python expression failed:\n\t'%s'\n\n", driver->expression);
768         
769         BPy_errors_to_report(NULL); // TODO - reports
770
771         return 0.0f;
772 }
773
774 /* This evals py driver expressions, 'expr' is a Python expression that
775  * should evaluate to a float number, which is returned. 
776  */
777 float BPY_pydriver_eval (ChannelDriver *driver)
778 {
779         PyObject *driver_vars=NULL;
780         PyObject *retval;
781         PyGILState_STATE gilstate;
782         
783         DriverTarget *dtar;
784         float result = 0.0f; /* default return */
785         char *expr = NULL;
786         short targets_ok= 1;
787         
788         /* sanity checks - should driver be executed? */
789         if ((driver == NULL) /*|| (G.f & G_DOSCRIPTLINKS)==0*/) 
790                 return result;
791         
792         /* get the py expression to be evaluated */
793         expr = driver->expression; 
794         if ((expr == NULL) || (expr[0]=='\0')) 
795                 return result;
796
797         gilstate = PyGILState_Ensure();
798         
799         /* init global dictionary for py-driver evaluation settings */
800         if (!bpy_pydriver_Dict) {
801                 if (bpy_pydriver_create_dict() != 0) {
802                         fprintf(stderr, "Pydriver error: couldn't create Python dictionary");
803                         PyGILState_Release(gilstate);
804                         return result;
805                 }
806         }
807         
808         /* add target values to a dict that will be used as '__locals__' dict */
809         driver_vars = PyDict_New(); // XXX do we need to decref this?
810         for (dtar= driver->targets.first; dtar; dtar= dtar->next) {
811                 PyObject *driver_arg = NULL;
812                 float tval = 0.0f;
813                 
814                 /* try to get variable value */
815                 tval= driver_get_target_value(driver, dtar);
816                 driver_arg= PyFloat_FromDouble((double)tval);
817                 
818                 /* try to add to dictionary */
819                 if (PyDict_SetItemString(driver_vars, dtar->name, driver_arg)) {
820                         /* this target failed - bad name */
821                         if (targets_ok) {
822                                 /* first one - print some extra info for easier identification */
823                                 fprintf(stderr, "\nBPY_pydriver_eval() - Error while evaluating PyDriver:\n");
824                                 targets_ok= 0;
825                         }
826                         
827                         fprintf(stderr, "\tBPY_pydriver_eval() - couldn't add variable '%s' to namespace \n", dtar->name);
828                         BPy_errors_to_report(NULL); // TODO - reports
829                 }
830         }
831         
832         /* execute expression to get a value */
833         retval = PyRun_String(expr, Py_eval_input, bpy_pydriver_Dict, driver_vars);
834         
835         /* decref the driver vars first...  */
836         Py_DECREF(driver_vars);
837         
838         /* process the result */
839         if (retval == NULL) {
840                 result = pydriver_error(driver);
841                 PyGILState_Release(gilstate);
842                 return result;
843         }
844
845         result = (float)PyFloat_AsDouble(retval);
846         Py_DECREF(retval);
847         
848         if ((result == -1) && PyErr_Occurred()) {
849                 result = pydriver_error(driver);
850                 PyGILState_Release(gilstate);
851                 return result;
852         }
853         
854         /* all fine, make sure the "invalid expression" flag is cleared */
855         driver->flag &= ~DRIVER_FLAG_INVALID;
856
857         PyGILState_Release(gilstate);
858
859         return result;
860 }
861
862 int BPY_button_eval(bContext *C, char *expr, double *value)
863 {
864         PyGILState_STATE gilstate;
865         PyObject *dict, *retval;
866         int error_ret = 0;
867         
868         if (!value || !expr || expr[0]=='\0') return -1;
869         
870         bpy_context_set(C, &gilstate);
871         
872         dict= CreateGlobalDictionary(C);
873         retval = PyRun_String(expr, Py_eval_input, dict, dict);
874         
875         if (retval == NULL) {
876                 error_ret= -1;
877         }
878         else {
879                 double val;
880
881                 if(PyTuple_Check(retval)) {
882                         /* Users my have typed in 10km, 2m
883                          * add up all values */
884                         int i;
885                         val= 0.0;
886
887                         for(i=0; i<PyTuple_GET_SIZE(retval); i++) {
888                                 val+= PyFloat_AsDouble(PyTuple_GET_ITEM(retval, i));
889                         }
890                 }
891                 else {
892                         val = PyFloat_AsDouble(retval);
893                 }
894                 Py_DECREF(retval);
895                 
896                 if(val==-1 && PyErr_Occurred()) {
897                         error_ret= -1;
898                 }
899                 else {
900                         *value= val;
901                 }
902         }
903         
904         if(error_ret) {
905                 BPy_errors_to_report(CTX_wm_reports(C));
906         }
907         
908         Py_DECREF(dict);
909         bpy_context_clear(C, &gilstate);
910         
911         return error_ret;
912 }
913