patch [#34103] use booleans for extensions testing.
[blender.git] / source / blender / python / intern / bpy_interface.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): Michel Selten, Willian P. Germano, Stephen Swaney,
19  * Chris Keith, Chris Want, Ken Hughes, Campbell Barton
20  *
21  * ***** END GPL LICENSE BLOCK *****
22  */
23
24 /** \file blender/python/intern/bpy_interface.c
25  *  \ingroup pythonintern
26  *
27  * This file deals with embedding the python interpreter within blender,
28  * starting and stopping python and exposing blender/python modules so they can
29  * be accesses from scripts.
30  */
31
32  
33 /* grr, python redefines */
34 #ifdef _POSIX_C_SOURCE
35 #  undef _POSIX_C_SOURCE
36 #endif
37
38 #include <Python.h>
39
40 #include "MEM_guardedalloc.h"
41
42 #include "BLI_utildefines.h"
43 #include "BLI_path_util.h"
44 #include "BLI_fileops.h"
45 #include "BLI_listbase.h"
46 #include "BLI_math_base.h"
47 #include "BLI_string.h"
48 #include "BLI_string_utf8.h"
49 #include "BLI_threads.h"
50
51 #include "RNA_types.h"
52
53 #include "bpy.h"
54 #include "gpu.h"
55 #include "bpy_rna.h"
56 #include "bpy_path.h"
57 #include "bpy_util.h"
58 #include "bpy_traceback.h"
59 #include "bpy_intern_string.h"
60
61 #include "DNA_space_types.h"
62 #include "DNA_text_types.h"
63
64 #include "BKE_context.h"
65 #include "BKE_text.h"
66 #include "BKE_main.h"
67 #include "BKE_global.h" /* only for script checking */
68
69 #include "CCL_api.h"
70
71 #include "BPY_extern.h"
72
73 #include "../generic/bpy_internal_import.h"  /* our own imports */
74 #include "../generic/py_capi_utils.h"
75
76 /* inittab initialization functions */
77 #include "../generic/bgl.h"
78 #include "../generic/blf_py_api.h"
79 #include "../generic/idprop_py_api.h"
80 #include "../bmesh/bmesh_py_api.h"
81 #include "../mathutils/mathutils.h"
82
83
84 /* for internal use, when starting and ending python scripts */
85
86 /* in case a python script triggers another python call, stop bpy_context_clear from invalidating */
87 static int py_call_level = 0;
88 BPy_StructRNA *bpy_context_module = NULL; /* for fast access */
89
90 // #define TIME_PY_RUN // simple python tests. prints on exit.
91
92 #ifdef TIME_PY_RUN
93 #include "PIL_time.h"
94 static int     bpy_timer_count = 0;
95 static double  bpy_timer;   /* time since python starts */
96 static double  bpy_timer_run;   /* time for each python script run */
97 static double  bpy_timer_run_tot;   /* accumulate python runs */
98 #endif
99
100 /* use for updating while a python script runs - in case of file load */
101 void BPY_context_update(bContext *C)
102 {
103         /* don't do this from a non-main (e.g. render) thread, it can cause a race
104          * condition on C->data.recursion. ideal solution would be to disable
105          * context entirely from non-main threads, but that's more complicated */
106         if (!BLI_thread_is_main())
107                 return;
108
109         BPy_SetContext(C);
110         bpy_import_main_set(CTX_data_main(C));
111         BPY_modules_update(C); /* can give really bad results if this isn't here */
112 }
113
114 void bpy_context_set(bContext *C, PyGILState_STATE *gilstate)
115 {
116         py_call_level++;
117
118         if (gilstate)
119                 *gilstate = PyGILState_Ensure();
120
121         if (py_call_level == 1) {
122                 BPY_context_update(C);
123
124 #ifdef TIME_PY_RUN
125                 if (bpy_timer_count == 0) {
126                         /* record time from the beginning */
127                         bpy_timer = PIL_check_seconds_timer();
128                         bpy_timer_run = bpy_timer_run_tot = 0.0;
129                 }
130                 bpy_timer_run = PIL_check_seconds_timer();
131
132
133                 bpy_timer_count++;
134 #endif
135         }
136 }
137
138 /* context should be used but not now because it causes some bugs */
139 void bpy_context_clear(bContext *UNUSED(C), PyGILState_STATE *gilstate)
140 {
141         py_call_level--;
142
143         if (gilstate)
144                 PyGILState_Release(*gilstate);
145
146         if (py_call_level < 0) {
147                 fprintf(stderr, "ERROR: Python context internal state bug. this should not happen!\n");
148         }
149         else if (py_call_level == 0) {
150                 /* XXX - Calling classes currently wont store the context :\,
151                  * cant set NULL because of this. but this is very flakey still. */
152 #if 0
153                 BPy_SetContext(NULL);
154                 bpy_import_main_set(NULL);
155 #endif
156
157 #ifdef TIME_PY_RUN
158                 bpy_timer_run_tot += PIL_check_seconds_timer() - bpy_timer_run;
159                 bpy_timer_count++;
160 #endif
161
162         }
163 }
164
165 void BPY_text_free_code(Text *text)
166 {
167         if (text->compiled) {
168                 PyGILState_STATE gilstate;
169                 bool use_gil = !PYC_INTERPRETER_ACTIVE;
170
171                 if (use_gil)
172                         gilstate = PyGILState_Ensure();
173
174                 Py_DECREF((PyObject *)text->compiled);
175                 text->compiled = NULL;
176
177                 if (use_gil)
178                         PyGILState_Release(gilstate);
179         }
180 }
181
182 void BPY_modules_update(bContext *C)
183 {
184 #if 0  /* slow, this runs all the time poll, draw etc 100's of time a sec. */
185         PyObject *mod = PyImport_ImportModuleLevel("bpy", NULL, NULL, NULL, 0);
186         PyModule_AddObject(mod, "data", BPY_rna_module());
187         PyModule_AddObject(mod, "types", BPY_rna_types());  /* atm this does not need updating */
188 #endif
189
190         /* refreshes the main struct */
191         BPY_update_rna_module();
192         if (bpy_context_module)
193                 bpy_context_module->ptr.data = (void *)C;
194 }
195
196 void BPY_context_set(bContext *C)
197 {
198         BPy_SetContext(C);
199 }
200
201 /* defined in AUD_C-API.cpp */
202 extern PyObject *AUD_initPython(void);
203
204 #ifdef WITH_CYCLES
205 /* defined in cycles module */
206 static PyObject *CCL_initPython(void)
207 {
208         return (PyObject *)CCL_python_module_init();
209 }
210 #endif
211
212 static struct _inittab bpy_internal_modules[] = {
213         {(char *)"mathutils", PyInit_mathutils},
214 //      {(char *)"mathutils.geometry", PyInit_mathutils_geometry},
215 //      {(char *)"mathutils.noise", PyInit_mathutils_noise},
216         {(char *)"_bpy_path", BPyInit__bpy_path},
217         {(char *)"bgl", BPyInit_bgl},
218         {(char *)"blf", BPyInit_blf},
219         {(char *)"bmesh", BPyInit_bmesh},
220         // {(char *)"bmesh.types", BPyInit_bmesh_types},
221         // {(char *)"bmesh.utils", BPyInit_bmesh_utils},
222 #ifdef WITH_AUDASPACE
223         {(char *)"aud", AUD_initPython},
224 #endif
225 #ifdef WITH_CYCLES
226         {(char *)"_cycles", CCL_initPython},
227 #endif
228         {(char *)"gpu", GPU_initPython},
229         {(char *)"idprop", BPyInit_idprop},
230         {NULL, NULL}
231 };
232
233 /* call BPY_context_set first */
234 void BPY_python_start(int argc, const char **argv)
235 {
236 #ifndef WITH_PYTHON_MODULE
237         PyThreadState *py_tstate = NULL;
238         const char *py_path_bundle = BLI_get_folder(BLENDER_SYSTEM_PYTHON, NULL);
239
240         /* not essential but nice to set our name */
241         static wchar_t program_path_wchar[FILE_MAX]; /* python holds a reference */
242         BLI_strncpy_wchar_from_utf8(program_path_wchar, BLI_program_path(), sizeof(program_path_wchar) / sizeof(wchar_t));
243         Py_SetProgramName(program_path_wchar);
244
245         /* must run before python initializes */
246         PyImport_ExtendInittab(bpy_internal_modules);
247
248         /* allow to use our own included python */
249         PyC_SetHomePath(py_path_bundle);
250
251         /* without this the sys.stdout may be set to 'ascii'
252          * (it is on my system at least), where printing unicode values will raise
253          * an error, this is highly annoying, another stumbling block for devs,
254          * so use a more relaxed error handler and enforce utf-8 since the rest of
255          * blender is utf-8 too - campbell */
256
257         /* XXX, update: this is unreliable! 'PYTHONIOENCODING' is ignored in MS-Windows
258          * when dynamically linked, see: [#31555] for details.
259          * Python doesn't expose a good way to set this. */
260         BLI_setenv("PYTHONIOENCODING", "utf-8:surrogateescape");
261
262         /* Python 3.2 now looks for '2.xx/python/include/python3.2d/pyconfig.h' to
263          * parse from the 'sysconfig' module which is used by 'site',
264          * so for now disable site. alternatively we could copy the file. */
265         if (py_path_bundle) {
266                 Py_NoSiteFlag = 1;
267         }
268
269         Py_FrozenFlag = 1;
270
271         Py_Initialize();
272
273         /* THIS IS BAD: see http://bugs.python.org/issue16129 */
274         /* this clobbers the stdout on exit (no 'MEM_printmemlist_stats') */
275 #if 0
276         /* until python provides a reliable way to set the env var */
277         PyRun_SimpleString("import sys, io\n"
278                            "sys.__backup_stdio__ = sys.__stdout__, sys.__stderr__\n"  /* else we loose the FD's [#32720] */
279                            "sys.__stdout__ = sys.stdout = io.TextIOWrapper(io.open(sys.stdout.fileno(), 'wb', -1), "
280                            "encoding='utf-8', errors='surrogateescape', newline='\\n', line_buffering=True)\n"
281                            "sys.__stderr__ = sys.stderr = io.TextIOWrapper(io.open(sys.stderr.fileno(), 'wb', -1), "
282                            "encoding='utf-8', errors='surrogateescape', newline='\\n', line_buffering=True)\n");
283         if (PyErr_Occurred()) {
284                 PyErr_Print();
285                 PyErr_Clear();
286         }
287 #endif
288         /* end the baddness */
289
290
291         // PySys_SetArgv(argc, argv);  /* broken in py3, not a huge deal */
292         /* sigh, why do python guys not have a (char **) version anymore? */
293         {
294                 int i;
295                 PyObject *py_argv = PyList_New(argc);
296                 for (i = 0; i < argc; i++) {
297                         /* should fix bug #20021 - utf path name problems, by replacing
298                          * PyUnicode_FromString, with this one */
299                         PyList_SET_ITEM(py_argv, i, PyC_UnicodeFromByte(argv[i]));
300                 }
301
302                 PySys_SetObject("argv", py_argv);
303                 Py_DECREF(py_argv);
304         }
305         
306         /* Initialize thread support (also acquires lock) */
307         PyEval_InitThreads();
308 #else
309         (void)argc;
310         (void)argv;
311
312         /* must run before python initializes */
313         /* broken in py3.3, load explicitly below */
314         // PyImport_ExtendInittab(bpy_internal_modules);
315 #endif
316
317         bpy_intern_string_init();
318
319
320 #ifdef WITH_PYTHON_MODULE
321         {
322                 /* Manually load all modules */
323                 struct _inittab *inittab_item;
324                 PyObject *sys_modules = PyImport_GetModuleDict();
325
326                 for (inittab_item = bpy_internal_modules; inittab_item->name; inittab_item++) {
327                         PyObject *mod = inittab_item->initfunc();
328                         if (mod) {
329                                 PyDict_SetItemString(sys_modules, inittab_item->name, mod);
330                         }
331                         else {
332                                 PyErr_Print();
333                                 PyErr_Clear();
334                         }
335                         // Py_DECREF(mod); /* ideally would decref, but in this case we never want to free */
336                 }
337         }
338 #endif
339
340         /* bpy.* and lets us import it */
341         BPy_init_modules();
342
343         bpy_import_init(PyEval_GetBuiltins());
344         
345         pyrna_alloc_types();
346
347 #ifndef WITH_PYTHON_MODULE
348         /* py module runs atexit when bpy is freed */
349         BPY_atexit_register(); /* this can init any time */
350
351         py_tstate = PyGILState_GetThisThreadState();
352         PyEval_ReleaseThread(py_tstate);
353 #endif
354 }
355
356 void BPY_python_end(void)
357 {
358         // fprintf(stderr, "Ending Python!\n");
359
360         PyGILState_Ensure(); /* finalizing, no need to grab the state */
361         
362         /* free other python data. */
363         pyrna_free_types();
364
365         /* clear all python data from structs */
366
367         bpy_intern_string_exit();
368
369 #ifndef WITH_PYTHON_MODULE
370         BPY_atexit_unregister(); /* without this we get recursive calls to WM_exit */
371 #endif
372
373         Py_Finalize();
374         
375 #ifdef TIME_PY_RUN
376         /* measure time since py started */
377         bpy_timer = PIL_check_seconds_timer() - bpy_timer;
378
379         printf("*bpy stats* - ");
380         printf("tot exec: %d,  ", bpy_timer_count);
381         printf("tot run: %.4fsec,  ", bpy_timer_run_tot);
382         if (bpy_timer_count > 0)
383                 printf("average run: %.6fsec,  ", (bpy_timer_run_tot / bpy_timer_count));
384
385         if (bpy_timer > 0.0)
386                 printf("tot usage %.4f%%", (bpy_timer_run_tot / bpy_timer) * 100.0);
387
388         printf("\n");
389
390         // fprintf(stderr, "Ending Python Done!\n");
391
392 #endif
393
394 }
395
396 static void python_script_error_jump_text(struct Text *text)
397 {
398         int lineno;
399         int offset;
400         python_script_error_jump(text->id.name + 2, &lineno, &offset);
401         if (lineno != -1) {
402                 /* select the line with the error */
403                 txt_move_to(text, lineno - 1, INT_MAX, false);
404                 txt_move_to(text, lineno - 1, offset, true);
405         }
406 }
407
408 /* super annoying, undo _PyModule_Clear(), bug [#23871] */
409 #define PYMODULE_CLEAR_WORKAROUND
410
411 #ifdef PYMODULE_CLEAR_WORKAROUND
412 /* bad!, we should never do this, but currently only safe way I could find to keep namespace.
413  * from being cleared. - campbell */
414 typedef struct {
415         PyObject_HEAD
416         PyObject *md_dict;
417         /* ommit other values, we only want the dict. */
418 } PyModuleObject;
419 #endif
420
421 static int python_script_exec(bContext *C, const char *fn, struct Text *text,
422                               struct ReportList *reports, const bool do_jump)
423 {
424         Main *bmain_old = CTX_data_main(C);
425         PyObject *main_mod = NULL;
426         PyObject *py_dict = NULL, *py_result = NULL;
427         PyGILState_STATE gilstate;
428
429         BLI_assert(fn || text);
430
431         if (fn == NULL && text == NULL) {
432                 return 0;
433         }
434
435         bpy_context_set(C, &gilstate);
436
437         PyC_MainModule_Backup(&main_mod);
438
439         if (text) {
440                 char fn_dummy[FILE_MAXDIR];
441                 bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);
442
443                 if (text->compiled == NULL) {   /* if it wasn't already compiled, do it now */
444                         char *buf = txt_to_buf(text);
445
446                         text->compiled = Py_CompileString(buf, fn_dummy, Py_file_input);
447
448                         MEM_freeN(buf);
449
450                         if (PyErr_Occurred()) {
451                                 if (do_jump) {
452                                         python_script_error_jump_text(text);
453                                 }
454                                 BPY_text_free_code(text);
455                         }
456                 }
457
458                 if (text->compiled) {
459                         py_dict = PyC_DefaultNameSpace(fn_dummy);
460                         py_result =  PyEval_EvalCode(text->compiled, py_dict, py_dict);
461                 }
462
463         }
464         else {
465                 FILE *fp = BLI_fopen(fn, "r");
466
467                 if (fp) {
468                         py_dict = PyC_DefaultNameSpace(fn);
469
470 #ifdef _WIN32
471                         /* Previously we used PyRun_File to run directly the code on a FILE
472                          * object, but as written in the Python/C API Ref Manual, chapter 2,
473                          * 'FILE structs for different C libraries can be different and
474                          * incompatible'.
475                          * So now we load the script file data to a buffer */
476                         {
477                                 char *pystring;
478
479                                 fclose(fp);
480
481                                 pystring = MEM_mallocN(strlen(fn) + 37, "pystring");
482                                 pystring[0] = '\0';
483                                 sprintf(pystring, "f=open(r'%s');exec(f.read());f.close()", fn);
484                                 py_result = PyRun_String(pystring, Py_file_input, py_dict, py_dict);
485                                 MEM_freeN(pystring);
486                         }
487 #else
488                         py_result = PyRun_File(fp, fn, Py_file_input, py_dict, py_dict);
489                         fclose(fp);
490 #endif
491                 }
492                 else {
493                         PyErr_Format(PyExc_IOError,
494                                      "Python file \"%s\" could not be opened: %s",
495                                      fn, strerror(errno));
496                         py_result = NULL;
497                 }
498         }
499
500         if (!py_result) {
501                 if (text) {
502                         if (do_jump) {
503                                 /* ensure text is valid before use, the script may have freed its self */
504                                 Main *bmain_new = CTX_data_main(C);
505                                 if ((bmain_old == bmain_new) && (BLI_findindex(&bmain_new->text, text) != -1)) {
506                                         python_script_error_jump_text(text);
507                                 }
508                         }
509                 }
510                 BPy_errors_to_report(reports);
511         }
512         else {
513                 Py_DECREF(py_result);
514         }
515
516         if (py_dict) {
517 #ifdef PYMODULE_CLEAR_WORKAROUND
518                 PyModuleObject *mmod = (PyModuleObject *)PyDict_GetItemString(PyThreadState_GET()->interp->modules, "__main__");
519                 PyObject *dict_back = mmod->md_dict;
520                 /* freeing the module will clear the namespace,
521                  * gives problems running classes defined in this namespace being used later. */
522                 mmod->md_dict = NULL;
523                 Py_DECREF(dict_back);
524 #endif
525
526 #undef PYMODULE_CLEAR_WORKAROUND
527         }
528
529         PyC_MainModule_Restore(main_mod);
530
531         bpy_context_clear(C, &gilstate);
532
533         return (py_result != NULL);
534 }
535
536 /* Can run a file or text block */
537 int BPY_filepath_exec(bContext *C, const char *filepath, struct ReportList *reports)
538 {
539         return python_script_exec(C, filepath, NULL, reports, false);
540 }
541
542
543 int BPY_text_exec(bContext *C, struct Text *text, struct ReportList *reports, const bool do_jump)
544 {
545         return python_script_exec(C, NULL, text, reports, do_jump);
546 }
547
548 void BPY_DECREF(void *pyob_ptr)
549 {
550         PyGILState_STATE gilstate = PyGILState_Ensure();
551         Py_DECREF((PyObject *)pyob_ptr);
552         PyGILState_Release(gilstate);
553 }
554
555 void BPY_DECREF_RNA_INVALIDATE(void *pyob_ptr)
556 {
557         PyGILState_STATE gilstate = PyGILState_Ensure();
558         const int do_invalidate = (Py_REFCNT((PyObject *)pyob_ptr) > 1);
559         Py_DECREF((PyObject *)pyob_ptr);
560         if (do_invalidate) {
561                 pyrna_invalidate(pyob_ptr);
562         }
563         PyGILState_Release(gilstate);
564 }
565
566
567 /* return -1 on error, else 0 */
568 int BPY_button_exec(bContext *C, const char *expr, double *value, const short verbose)
569 {
570         PyGILState_STATE gilstate;
571         PyObject *py_dict, *mod, *retval;
572         int error_ret = 0;
573         PyObject *main_mod = NULL;
574         
575         if (!value || !expr) return -1;
576
577         if (expr[0] == '\0') {
578                 *value = 0.0;
579                 return error_ret;
580         }
581
582         bpy_context_set(C, &gilstate);
583
584         PyC_MainModule_Backup(&main_mod);
585
586         py_dict = PyC_DefaultNameSpace("<blender button>");
587
588         mod = PyImport_ImportModule("math");
589         if (mod) {
590                 PyDict_Merge(py_dict, PyModule_GetDict(mod), 0); /* 0 - don't overwrite existing values */
591                 Py_DECREF(mod);
592         }
593         else { /* highly unlikely but possibly */
594                 PyErr_Print();
595                 PyErr_Clear();
596         }
597         
598         retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict);
599         
600         if (retval == NULL) {
601                 error_ret = -1;
602         }
603         else {
604                 double val;
605
606                 if (PyTuple_Check(retval)) {
607                         /* Users my have typed in 10km, 2m
608                          * add up all values */
609                         int i;
610                         val = 0.0;
611
612                         for (i = 0; i < PyTuple_GET_SIZE(retval); i++) {
613                                 const double val_item = PyFloat_AsDouble(PyTuple_GET_ITEM(retval, i));
614                                 if (val_item == -1 && PyErr_Occurred()) {
615                                         val = -1;
616                                         break;
617                                 }
618                                 val += val_item;
619                         }
620                 }
621                 else {
622                         val = PyFloat_AsDouble(retval);
623                 }
624                 Py_DECREF(retval);
625                 
626                 if (val == -1 && PyErr_Occurred()) {
627                         error_ret = -1;
628                 }
629                 else if (!finite(val)) {
630                         *value = 0.0;
631                 }
632                 else {
633                         *value = val;
634                 }
635         }
636         
637         if (error_ret) {
638                 if (verbose) {
639                         BPy_errors_to_report(CTX_wm_reports(C));
640                 }
641                 else {
642                         PyErr_Clear();
643                 }
644         }
645
646         PyC_MainModule_Restore(main_mod);
647         
648         bpy_context_clear(C, &gilstate);
649         
650         return error_ret;
651 }
652
653 int BPY_string_exec(bContext *C, const char *expr)
654 {
655         PyGILState_STATE gilstate;
656         PyObject *main_mod = NULL;
657         PyObject *py_dict, *retval;
658         int error_ret = 0;
659         Main *bmain_back; /* XXX, quick fix for release (Copy Settings crash), needs further investigation */
660
661         if (!expr) return -1;
662
663         if (expr[0] == '\0') {
664                 return error_ret;
665         }
666
667         bpy_context_set(C, &gilstate);
668
669         PyC_MainModule_Backup(&main_mod);
670
671         py_dict = PyC_DefaultNameSpace("<blender string>");
672
673         bmain_back = bpy_import_main_get();
674         bpy_import_main_set(CTX_data_main(C));
675
676         retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict);
677
678         bpy_import_main_set(bmain_back);
679
680         if (retval == NULL) {
681                 error_ret = -1;
682
683                 BPy_errors_to_report(CTX_wm_reports(C));
684         }
685         else {
686                 Py_DECREF(retval);
687         }
688
689         PyC_MainModule_Restore(main_mod);
690
691         bpy_context_clear(C, &gilstate);
692         
693         return error_ret;
694 }
695
696
697 void BPY_modules_load_user(bContext *C)
698 {
699         PyGILState_STATE gilstate;
700         Main *bmain = CTX_data_main(C);
701         Text *text;
702
703         /* can happen on file load */
704         if (bmain == NULL)
705                 return;
706
707         /* update pointers since this can run from a nested script
708          * on file load */
709         if (py_call_level) {
710                 BPY_context_update(C);
711         }
712
713         bpy_context_set(C, &gilstate);
714
715         for (text = bmain->text.first; text; text = text->id.next) {
716                 if (text->flags & TXT_ISSCRIPT && BLI_testextensie(text->id.name + 2, ".py")) {
717                         if (!(G.f & G_SCRIPT_AUTOEXEC)) {
718                                 printf("scripts disabled for \"%s\", skipping '%s'\n", bmain->name, text->id.name + 2);
719                         }
720                         else {
721                                 PyObject *module = bpy_text_import(text);
722
723                                 if (module == NULL) {
724                                         PyErr_Print();
725                                         PyErr_Clear();
726                                 }
727                                 else {
728                                         Py_DECREF(module);
729                                 }
730
731                                 /* check if the script loaded a new file */
732                                 if (bmain != CTX_data_main(C)) {
733                                         break;
734                                 }
735                         }
736                 }
737         }
738         bpy_context_clear(C, &gilstate);
739 }
740
741 int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *result)
742 {
743         PyGILState_STATE gilstate;
744         bool use_gil = !PYC_INTERPRETER_ACTIVE;
745
746         PyObject *pyctx;
747         PyObject *item;
748         PointerRNA *ptr = NULL;
749         bool done = false;
750
751         if (use_gil)
752                 gilstate = PyGILState_Ensure();
753
754         pyctx = (PyObject *)CTX_py_dict_get(C);
755         item = PyDict_GetItemString(pyctx, member);
756
757         if (item == NULL) {
758                 /* pass */
759         }
760         else if (item == Py_None) {
761                 /* pass */
762         }
763         else if (BPy_StructRNA_Check(item)) {
764                 ptr = &(((BPy_StructRNA *)item)->ptr);
765
766                 //result->ptr = ((BPy_StructRNA *)item)->ptr;
767                 CTX_data_pointer_set(result, ptr->id.data, ptr->type, ptr->data);
768                 CTX_data_type_set(result, CTX_DATA_TYPE_POINTER);
769                 done = true;
770         }
771         else if (PySequence_Check(item)) {
772                 PyObject *seq_fast = PySequence_Fast(item, "bpy_context_get sequence conversion");
773                 if (seq_fast == NULL) {
774                         PyErr_Print();
775                         PyErr_Clear();
776                 }
777                 else {
778                         int len = PySequence_Fast_GET_SIZE(seq_fast);
779                         int i;
780                         for (i = 0; i < len; i++) {
781                                 PyObject *list_item = PySequence_Fast_GET_ITEM(seq_fast, i);
782
783                                 if (BPy_StructRNA_Check(list_item)) {
784 #if 0
785                                         CollectionPointerLink *link = MEM_callocN(sizeof(CollectionPointerLink), "bpy_context_get");
786                                         link->ptr = ((BPy_StructRNA *)item)->ptr;
787                                         BLI_addtail(&result->list, link);
788 #endif
789                                         ptr = &(((BPy_StructRNA *)list_item)->ptr);
790                                         CTX_data_list_add(result, ptr->id.data, ptr->type, ptr->data);
791                                 }
792                                 else {
793                                         printf("PyContext: '%s' list item not a valid type in sequece type '%s'\n",
794                                                member, Py_TYPE(item)->tp_name);
795                                 }
796
797                         }
798                         Py_DECREF(seq_fast);
799                         CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
800                         done = true;
801                 }
802         }
803
804         if (done == false) {
805                 if (item) printf("PyContext '%s' not a valid type\n", member);
806                 else      printf("PyContext '%s' not found\n", member);
807         }
808         else {
809                 if (G.debug & G_DEBUG_PYTHON) {
810                         printf("PyContext '%s' found\n", member);
811                 }
812         }
813
814         if (use_gil)
815                 PyGILState_Release(gilstate);
816
817         return done;
818 }
819
820 #ifdef WITH_PYTHON_MODULE
821 #include "BLI_fileops.h"
822 /* TODO, reloading the module isn't functional at the moment. */
823
824 static void bpy_module_free(void *mod);
825 extern int main_python_enter(int argc, const char **argv);
826 extern void main_python_exit(void);
827 static struct PyModuleDef bpy_proxy_def = {
828         PyModuleDef_HEAD_INIT,
829         "bpy",  /* m_name */
830         NULL,  /* m_doc */
831         0,  /* m_size */
832         NULL,  /* m_methods */
833         NULL,  /* m_reload */
834         NULL,  /* m_traverse */
835         NULL,  /* m_clear */
836         bpy_module_free,  /* m_free */
837 };
838
839 typedef struct {
840         PyObject_HEAD
841         /* Type-specific fields go here. */
842         PyObject *mod;
843 } dealloc_obj;
844
845 /* call once __file__ is set */
846 static void bpy_module_delay_init(PyObject *bpy_proxy)
847 {
848         const int argc = 1;
849         const char *argv[2];
850
851         /* updating the module dict below will loose the reference to __file__ */
852         PyObject *filename_obj = PyModule_GetFilenameObject(bpy_proxy);
853
854         const char *filename_rel = _PyUnicode_AsString(filename_obj); /* can be relative */
855         char filename_abs[1024];
856
857         BLI_strncpy(filename_abs, filename_rel, sizeof(filename_abs));
858         BLI_path_cwd(filename_abs);
859
860         argv[0] = filename_abs;
861         argv[1] = NULL;
862         
863         // printf("module found %s\n", argv[0]);
864
865         main_python_enter(argc, argv);
866
867         /* initialized in BPy_init_modules() */
868         PyDict_Update(PyModule_GetDict(bpy_proxy), PyModule_GetDict(bpy_package_py));
869 }
870
871 static void dealloc_obj_dealloc(PyObject *self);
872
873 static PyTypeObject dealloc_obj_Type = {{{0}}};
874
875 /* use our own dealloc so we can free a property if we use one */
876 static void dealloc_obj_dealloc(PyObject *self)
877 {
878         bpy_module_delay_init(((dealloc_obj *)self)->mod);
879
880         /* Note, for subclassed PyObjects we cant just call PyObject_DEL() directly or it will crash */
881         dealloc_obj_Type.tp_free(self);
882 }
883
884 PyMODINIT_FUNC
885 PyInit_bpy(void);
886
887 PyMODINIT_FUNC
888 PyInit_bpy(void)
889 {
890         PyObject *bpy_proxy = PyModule_Create(&bpy_proxy_def);
891         
892         /* Problem:
893          * 1) this init function is expected to have a private member defined - 'md_def'
894          *    but this is only set for C defined modules (not py packages)
895          *    so we cant return 'bpy_package_py' as is.
896          *
897          * 2) there is a 'bpy' C module for python to load which is basically all of blender,
898          *    and there is scripts/bpy/__init__.py, 
899          *    we may end up having to rename this module so there is no naming conflict here eg:
900          *    'from blender import bpy'
901          *
902          * 3) we don't know the filename at this point, workaround by assigning a dummy value
903          *    which calls back when its freed so the real loading can take place.
904          */
905
906         /* assign an object which is freed after __file__ is assigned */
907         dealloc_obj *dob;
908         
909         /* assign dummy type */
910         dealloc_obj_Type.tp_name = "dealloc_obj";
911         dealloc_obj_Type.tp_basicsize = sizeof(dealloc_obj);
912         dealloc_obj_Type.tp_dealloc = dealloc_obj_dealloc;
913         dealloc_obj_Type.tp_flags = Py_TPFLAGS_DEFAULT;
914         
915         if (PyType_Ready(&dealloc_obj_Type) < 0)
916                 return NULL;
917
918         dob = (dealloc_obj *) dealloc_obj_Type.tp_alloc(&dealloc_obj_Type, 0);
919         dob->mod = bpy_proxy; /* borrow */
920         PyModule_AddObject(bpy_proxy, "__file__", (PyObject *)dob); /* borrow */
921
922         return bpy_proxy;
923 }
924
925 static void bpy_module_free(void *UNUSED(mod))
926 {
927         main_python_exit();
928 }
929
930 #endif
931
932
933 /* EVIL, define text.c functions here... */
934 extern int text_check_identifier_unicode(const unsigned int ch);
935 extern int text_check_identifier_nodigit_unicode(const unsigned int ch);
936 extern int text_check_identifier(const char ch);
937 extern int text_check_identifier_nodigit(const char ch);
938
939 int text_check_identifier_unicode(const unsigned int ch)
940 {
941         return (ch < 255 && text_check_identifier((char)ch)) || Py_UNICODE_ISALNUM(ch);
942 }
943
944 int text_check_identifier_nodigit_unicode(const unsigned int ch)
945 {
946         return (ch < 255 && text_check_identifier_nodigit((char)ch)) || Py_UNICODE_ISALPHA(ch);
947 }