Fix #35665: more CUDA issues with recent kernel changes, tested on sm_20, sm_21
[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         /* Update, Py3.3 resolves attempting to parse non-existing header */
263 #if 0
264         /* Python 3.2 now looks for '2.xx/python/include/python3.2d/pyconfig.h' to
265          * parse from the 'sysconfig' module which is used by 'site',
266          * so for now disable site. alternatively we could copy the file. */
267         if (py_path_bundle) {
268                 Py_NoSiteFlag = 1;
269         }
270 #endif
271
272         Py_FrozenFlag = 1;
273
274         Py_Initialize();
275
276         /* THIS IS BAD: see http://bugs.python.org/issue16129 */
277         /* this clobbers the stdout on exit (no 'MEM_printmemlist_stats') */
278 #if 0
279         /* until python provides a reliable way to set the env var */
280         PyRun_SimpleString("import sys, io\n"
281                            "sys.__backup_stdio__ = sys.__stdout__, sys.__stderr__\n"  /* else we loose the FD's [#32720] */
282                            "sys.__stdout__ = sys.stdout = io.TextIOWrapper(io.open(sys.stdout.fileno(), 'wb', -1), "
283                            "encoding='utf-8', errors='surrogateescape', newline='\\n', line_buffering=True)\n"
284                            "sys.__stderr__ = sys.stderr = io.TextIOWrapper(io.open(sys.stderr.fileno(), 'wb', -1), "
285                            "encoding='utf-8', errors='surrogateescape', newline='\\n', line_buffering=True)\n");
286         if (PyErr_Occurred()) {
287                 PyErr_Print();
288                 PyErr_Clear();
289         }
290 #endif
291         /* end the baddness */
292
293
294         // PySys_SetArgv(argc, argv);  /* broken in py3, not a huge deal */
295         /* sigh, why do python guys not have a (char **) version anymore? */
296         {
297                 int i;
298                 PyObject *py_argv = PyList_New(argc);
299                 for (i = 0; i < argc; i++) {
300                         /* should fix bug #20021 - utf path name problems, by replacing
301                          * PyUnicode_FromString, with this one */
302                         PyList_SET_ITEM(py_argv, i, PyC_UnicodeFromByte(argv[i]));
303                 }
304
305                 PySys_SetObject("argv", py_argv);
306                 Py_DECREF(py_argv);
307         }
308         
309         /* Initialize thread support (also acquires lock) */
310         PyEval_InitThreads();
311 #else
312         (void)argc;
313         (void)argv;
314
315         /* must run before python initializes */
316         /* broken in py3.3, load explicitly below */
317         // PyImport_ExtendInittab(bpy_internal_modules);
318 #endif
319
320         bpy_intern_string_init();
321
322
323 #ifdef WITH_PYTHON_MODULE
324         {
325                 /* Manually load all modules */
326                 struct _inittab *inittab_item;
327                 PyObject *sys_modules = PyImport_GetModuleDict();
328
329                 for (inittab_item = bpy_internal_modules; inittab_item->name; inittab_item++) {
330                         PyObject *mod = inittab_item->initfunc();
331                         if (mod) {
332                                 PyDict_SetItemString(sys_modules, inittab_item->name, mod);
333                         }
334                         else {
335                                 PyErr_Print();
336                                 PyErr_Clear();
337                         }
338                         // Py_DECREF(mod); /* ideally would decref, but in this case we never want to free */
339                 }
340         }
341 #endif
342
343         /* bpy.* and lets us import it */
344         BPy_init_modules();
345
346         bpy_import_init(PyEval_GetBuiltins());
347         
348         pyrna_alloc_types();
349
350 #ifndef WITH_PYTHON_MODULE
351         /* py module runs atexit when bpy is freed */
352         BPY_atexit_register(); /* this can init any time */
353
354         py_tstate = PyGILState_GetThisThreadState();
355         PyEval_ReleaseThread(py_tstate);
356 #endif
357 }
358
359 void BPY_python_end(void)
360 {
361         // fprintf(stderr, "Ending Python!\n");
362
363         PyGILState_Ensure(); /* finalizing, no need to grab the state */
364         
365         /* free other python data. */
366         pyrna_free_types();
367
368         /* clear all python data from structs */
369
370         bpy_intern_string_exit();
371
372 #ifndef WITH_PYTHON_MODULE
373         BPY_atexit_unregister(); /* without this we get recursive calls to WM_exit */
374 #endif
375
376         Py_Finalize();
377         
378 #ifdef TIME_PY_RUN
379         /* measure time since py started */
380         bpy_timer = PIL_check_seconds_timer() - bpy_timer;
381
382         printf("*bpy stats* - ");
383         printf("tot exec: %d,  ", bpy_timer_count);
384         printf("tot run: %.4fsec,  ", bpy_timer_run_tot);
385         if (bpy_timer_count > 0)
386                 printf("average run: %.6fsec,  ", (bpy_timer_run_tot / bpy_timer_count));
387
388         if (bpy_timer > 0.0)
389                 printf("tot usage %.4f%%", (bpy_timer_run_tot / bpy_timer) * 100.0);
390
391         printf("\n");
392
393         // fprintf(stderr, "Ending Python Done!\n");
394
395 #endif
396
397 }
398
399 void BPY_python_reset(bContext *C)
400 {
401         /* unrelated security stuff */
402         G.f &= ~(G_SCRIPT_AUTOEXEC_FAIL | G_SCRIPT_AUTOEXEC_FAIL_QUIET);
403         G.autoexec_fail[0] = '\0';
404
405         BPY_driver_reset();
406         BPY_app_handlers_reset(false);
407         BPY_modules_load_user(C);
408 }
409
410 static void python_script_error_jump_text(struct Text *text)
411 {
412         int lineno;
413         int offset;
414         python_script_error_jump(text->id.name + 2, &lineno, &offset);
415         if (lineno != -1) {
416                 /* select the line with the error */
417                 txt_move_to(text, lineno - 1, INT_MAX, false);
418                 txt_move_to(text, lineno - 1, offset, true);
419         }
420 }
421
422 /* super annoying, undo _PyModule_Clear(), bug [#23871] */
423 #define PYMODULE_CLEAR_WORKAROUND
424
425 #ifdef PYMODULE_CLEAR_WORKAROUND
426 /* bad!, we should never do this, but currently only safe way I could find to keep namespace.
427  * from being cleared. - campbell */
428 typedef struct {
429         PyObject_HEAD
430         PyObject *md_dict;
431         /* ommit other values, we only want the dict. */
432 } PyModuleObject;
433 #endif
434
435 static int python_script_exec(bContext *C, const char *fn, struct Text *text,
436                               struct ReportList *reports, const bool do_jump)
437 {
438         Main *bmain_old = CTX_data_main(C);
439         PyObject *main_mod = NULL;
440         PyObject *py_dict = NULL, *py_result = NULL;
441         PyGILState_STATE gilstate;
442
443         BLI_assert(fn || text);
444
445         if (fn == NULL && text == NULL) {
446                 return 0;
447         }
448
449         bpy_context_set(C, &gilstate);
450
451         PyC_MainModule_Backup(&main_mod);
452
453         if (text) {
454                 char fn_dummy[FILE_MAXDIR];
455                 bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);
456
457                 if (text->compiled == NULL) {   /* if it wasn't already compiled, do it now */
458                         char *buf = txt_to_buf(text);
459
460                         text->compiled = Py_CompileString(buf, fn_dummy, Py_file_input);
461
462                         MEM_freeN(buf);
463
464                         if (PyErr_Occurred()) {
465                                 if (do_jump) {
466                                         python_script_error_jump_text(text);
467                                 }
468                                 BPY_text_free_code(text);
469                         }
470                 }
471
472                 if (text->compiled) {
473                         py_dict = PyC_DefaultNameSpace(fn_dummy);
474                         py_result =  PyEval_EvalCode(text->compiled, py_dict, py_dict);
475                 }
476
477         }
478         else {
479                 FILE *fp = BLI_fopen(fn, "r");
480
481                 if (fp) {
482                         py_dict = PyC_DefaultNameSpace(fn);
483
484 #ifdef _WIN32
485                         /* Previously we used PyRun_File to run directly the code on a FILE
486                          * object, but as written in the Python/C API Ref Manual, chapter 2,
487                          * 'FILE structs for different C libraries can be different and
488                          * incompatible'.
489                          * So now we load the script file data to a buffer */
490                         {
491                                 char *pystring;
492
493                                 fclose(fp);
494
495                                 pystring = MEM_mallocN(strlen(fn) + 37, "pystring");
496                                 pystring[0] = '\0';
497                                 sprintf(pystring, "f=open(r'%s');exec(f.read());f.close()", fn);
498                                 py_result = PyRun_String(pystring, Py_file_input, py_dict, py_dict);
499                                 MEM_freeN(pystring);
500                         }
501 #else
502                         py_result = PyRun_File(fp, fn, Py_file_input, py_dict, py_dict);
503                         fclose(fp);
504 #endif
505                 }
506                 else {
507                         PyErr_Format(PyExc_IOError,
508                                      "Python file \"%s\" could not be opened: %s",
509                                      fn, strerror(errno));
510                         py_result = NULL;
511                 }
512         }
513
514         if (!py_result) {
515                 if (text) {
516                         if (do_jump) {
517                                 /* ensure text is valid before use, the script may have freed its self */
518                                 Main *bmain_new = CTX_data_main(C);
519                                 if ((bmain_old == bmain_new) && (BLI_findindex(&bmain_new->text, text) != -1)) {
520                                         python_script_error_jump_text(text);
521                                 }
522                         }
523                 }
524                 BPy_errors_to_report(reports);
525         }
526         else {
527                 Py_DECREF(py_result);
528         }
529
530         if (py_dict) {
531 #ifdef PYMODULE_CLEAR_WORKAROUND
532                 PyModuleObject *mmod = (PyModuleObject *)PyDict_GetItemString(PyThreadState_GET()->interp->modules, "__main__");
533                 PyObject *dict_back = mmod->md_dict;
534                 /* freeing the module will clear the namespace,
535                  * gives problems running classes defined in this namespace being used later. */
536                 mmod->md_dict = NULL;
537                 Py_DECREF(dict_back);
538 #endif
539
540 #undef PYMODULE_CLEAR_WORKAROUND
541         }
542
543         PyC_MainModule_Restore(main_mod);
544
545         bpy_context_clear(C, &gilstate);
546
547         return (py_result != NULL);
548 }
549
550 /* Can run a file or text block */
551 int BPY_filepath_exec(bContext *C, const char *filepath, struct ReportList *reports)
552 {
553         return python_script_exec(C, filepath, NULL, reports, false);
554 }
555
556
557 int BPY_text_exec(bContext *C, struct Text *text, struct ReportList *reports, const bool do_jump)
558 {
559         return python_script_exec(C, NULL, text, reports, do_jump);
560 }
561
562 void BPY_DECREF(void *pyob_ptr)
563 {
564         PyGILState_STATE gilstate = PyGILState_Ensure();
565         Py_DECREF((PyObject *)pyob_ptr);
566         PyGILState_Release(gilstate);
567 }
568
569 void BPY_DECREF_RNA_INVALIDATE(void *pyob_ptr)
570 {
571         PyGILState_STATE gilstate = PyGILState_Ensure();
572         const int do_invalidate = (Py_REFCNT((PyObject *)pyob_ptr) > 1);
573         Py_DECREF((PyObject *)pyob_ptr);
574         if (do_invalidate) {
575                 pyrna_invalidate(pyob_ptr);
576         }
577         PyGILState_Release(gilstate);
578 }
579
580
581 /* return -1 on error, else 0 */
582 int BPY_button_exec(bContext *C, const char *expr, double *value, const short verbose)
583 {
584         PyGILState_STATE gilstate;
585         PyObject *py_dict, *mod, *retval;
586         int error_ret = 0;
587         PyObject *main_mod = NULL;
588         
589         if (!value || !expr) return -1;
590
591         if (expr[0] == '\0') {
592                 *value = 0.0;
593                 return error_ret;
594         }
595
596         bpy_context_set(C, &gilstate);
597
598         PyC_MainModule_Backup(&main_mod);
599
600         py_dict = PyC_DefaultNameSpace("<blender button>");
601
602         mod = PyImport_ImportModule("math");
603         if (mod) {
604                 PyDict_Merge(py_dict, PyModule_GetDict(mod), 0); /* 0 - don't overwrite existing values */
605                 Py_DECREF(mod);
606         }
607         else { /* highly unlikely but possibly */
608                 PyErr_Print();
609                 PyErr_Clear();
610         }
611         
612         retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict);
613         
614         if (retval == NULL) {
615                 error_ret = -1;
616         }
617         else {
618                 double val;
619
620                 if (PyTuple_Check(retval)) {
621                         /* Users my have typed in 10km, 2m
622                          * add up all values */
623                         int i;
624                         val = 0.0;
625
626                         for (i = 0; i < PyTuple_GET_SIZE(retval); i++) {
627                                 const double val_item = PyFloat_AsDouble(PyTuple_GET_ITEM(retval, i));
628                                 if (val_item == -1 && PyErr_Occurred()) {
629                                         val = -1;
630                                         break;
631                                 }
632                                 val += val_item;
633                         }
634                 }
635                 else {
636                         val = PyFloat_AsDouble(retval);
637                 }
638                 Py_DECREF(retval);
639                 
640                 if (val == -1 && PyErr_Occurred()) {
641                         error_ret = -1;
642                 }
643                 else if (!finite(val)) {
644                         *value = 0.0;
645                 }
646                 else {
647                         *value = val;
648                 }
649         }
650         
651         if (error_ret) {
652                 if (verbose) {
653                         BPy_errors_to_report(CTX_wm_reports(C));
654                 }
655                 else {
656                         PyErr_Clear();
657                 }
658         }
659
660         PyC_MainModule_Restore(main_mod);
661         
662         bpy_context_clear(C, &gilstate);
663         
664         return error_ret;
665 }
666
667 int BPY_string_exec(bContext *C, const char *expr)
668 {
669         PyGILState_STATE gilstate;
670         PyObject *main_mod = NULL;
671         PyObject *py_dict, *retval;
672         int error_ret = 0;
673         Main *bmain_back; /* XXX, quick fix for release (Copy Settings crash), needs further investigation */
674
675         if (!expr) return -1;
676
677         if (expr[0] == '\0') {
678                 return error_ret;
679         }
680
681         bpy_context_set(C, &gilstate);
682
683         PyC_MainModule_Backup(&main_mod);
684
685         py_dict = PyC_DefaultNameSpace("<blender string>");
686
687         bmain_back = bpy_import_main_get();
688         bpy_import_main_set(CTX_data_main(C));
689
690         retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict);
691
692         bpy_import_main_set(bmain_back);
693
694         if (retval == NULL) {
695                 error_ret = -1;
696
697                 BPy_errors_to_report(CTX_wm_reports(C));
698         }
699         else {
700                 Py_DECREF(retval);
701         }
702
703         PyC_MainModule_Restore(main_mod);
704
705         bpy_context_clear(C, &gilstate);
706         
707         return error_ret;
708 }
709
710
711 void BPY_modules_load_user(bContext *C)
712 {
713         PyGILState_STATE gilstate;
714         Main *bmain = CTX_data_main(C);
715         Text *text;
716
717         /* can happen on file load */
718         if (bmain == NULL)
719                 return;
720
721         /* update pointers since this can run from a nested script
722          * on file load */
723         if (py_call_level) {
724                 BPY_context_update(C);
725         }
726
727         bpy_context_set(C, &gilstate);
728
729         for (text = bmain->text.first; text; text = text->id.next) {
730                 if (text->flags & TXT_ISSCRIPT && BLI_testextensie(text->id.name + 2, ".py")) {
731                         if (!(G.f & G_SCRIPT_AUTOEXEC)) {
732                                 if (!(G.f & G_SCRIPT_AUTOEXEC_FAIL_QUIET)) {
733                                         G.f |= G_SCRIPT_AUTOEXEC_FAIL;
734                                         BLI_snprintf(G.autoexec_fail, sizeof(G.autoexec_fail), "Register Text '%s'", text->id.name + 2);
735
736                                         printf("scripts disabled for \"%s\", skipping '%s'\n", bmain->name, text->id.name + 2);
737                                 }
738                         }
739                         else {
740                                 PyObject *module = bpy_text_import(text);
741
742                                 if (module == NULL) {
743                                         PyErr_Print();
744                                         PyErr_Clear();
745                                 }
746                                 else {
747                                         Py_DECREF(module);
748                                 }
749
750                                 /* check if the script loaded a new file */
751                                 if (bmain != CTX_data_main(C)) {
752                                         break;
753                                 }
754                         }
755                 }
756         }
757         bpy_context_clear(C, &gilstate);
758 }
759
760 int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *result)
761 {
762         PyGILState_STATE gilstate;
763         bool use_gil = !PYC_INTERPRETER_ACTIVE;
764
765         PyObject *pyctx;
766         PyObject *item;
767         PointerRNA *ptr = NULL;
768         bool done = false;
769
770         if (use_gil)
771                 gilstate = PyGILState_Ensure();
772
773         pyctx = (PyObject *)CTX_py_dict_get(C);
774         item = PyDict_GetItemString(pyctx, member);
775
776         if (item == NULL) {
777                 /* pass */
778         }
779         else if (item == Py_None) {
780                 done = true;
781         }
782         else if (BPy_StructRNA_Check(item)) {
783                 ptr = &(((BPy_StructRNA *)item)->ptr);
784
785                 //result->ptr = ((BPy_StructRNA *)item)->ptr;
786                 CTX_data_pointer_set(result, ptr->id.data, ptr->type, ptr->data);
787                 CTX_data_type_set(result, CTX_DATA_TYPE_POINTER);
788                 done = true;
789         }
790         else if (PySequence_Check(item)) {
791                 PyObject *seq_fast = PySequence_Fast(item, "bpy_context_get sequence conversion");
792                 if (seq_fast == NULL) {
793                         PyErr_Print();
794                         PyErr_Clear();
795                 }
796                 else {
797                         int len = PySequence_Fast_GET_SIZE(seq_fast);
798                         int i;
799                         for (i = 0; i < len; i++) {
800                                 PyObject *list_item = PySequence_Fast_GET_ITEM(seq_fast, i);
801
802                                 if (BPy_StructRNA_Check(list_item)) {
803 #if 0
804                                         CollectionPointerLink *link = MEM_callocN(sizeof(CollectionPointerLink), "bpy_context_get");
805                                         link->ptr = ((BPy_StructRNA *)item)->ptr;
806                                         BLI_addtail(&result->list, link);
807 #endif
808                                         ptr = &(((BPy_StructRNA *)list_item)->ptr);
809                                         CTX_data_list_add(result, ptr->id.data, ptr->type, ptr->data);
810                                 }
811                                 else {
812                                         printf("PyContext: '%s' list item not a valid type in sequece type '%s'\n",
813                                                member, Py_TYPE(item)->tp_name);
814                                 }
815
816                         }
817                         Py_DECREF(seq_fast);
818                         CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
819                         done = true;
820                 }
821         }
822
823         if (done == false) {
824                 if (item) printf("PyContext '%s' not a valid type\n", member);
825                 else      printf("PyContext '%s' not found\n", member);
826         }
827         else {
828                 if (G.debug & G_DEBUG_PYTHON) {
829                         printf("PyContext '%s' found\n", member);
830                 }
831         }
832
833         if (use_gil)
834                 PyGILState_Release(gilstate);
835
836         return done;
837 }
838
839 #ifdef WITH_PYTHON_MODULE
840 #include "BLI_fileops.h"
841 /* TODO, reloading the module isn't functional at the moment. */
842
843 static void bpy_module_free(void *mod);
844 extern int main_python_enter(int argc, const char **argv);
845 extern void main_python_exit(void);
846 static struct PyModuleDef bpy_proxy_def = {
847         PyModuleDef_HEAD_INIT,
848         "bpy",  /* m_name */
849         NULL,  /* m_doc */
850         0,  /* m_size */
851         NULL,  /* m_methods */
852         NULL,  /* m_reload */
853         NULL,  /* m_traverse */
854         NULL,  /* m_clear */
855         bpy_module_free,  /* m_free */
856 };
857
858 typedef struct {
859         PyObject_HEAD
860         /* Type-specific fields go here. */
861         PyObject *mod;
862 } dealloc_obj;
863
864 /* call once __file__ is set */
865 static void bpy_module_delay_init(PyObject *bpy_proxy)
866 {
867         const int argc = 1;
868         const char *argv[2];
869
870         /* updating the module dict below will loose the reference to __file__ */
871         PyObject *filename_obj = PyModule_GetFilenameObject(bpy_proxy);
872
873         const char *filename_rel = _PyUnicode_AsString(filename_obj); /* can be relative */
874         char filename_abs[1024];
875
876         BLI_strncpy(filename_abs, filename_rel, sizeof(filename_abs));
877         BLI_path_cwd(filename_abs);
878
879         argv[0] = filename_abs;
880         argv[1] = NULL;
881         
882         // printf("module found %s\n", argv[0]);
883
884         main_python_enter(argc, argv);
885
886         /* initialized in BPy_init_modules() */
887         PyDict_Update(PyModule_GetDict(bpy_proxy), PyModule_GetDict(bpy_package_py));
888 }
889
890 static void dealloc_obj_dealloc(PyObject *self);
891
892 static PyTypeObject dealloc_obj_Type = {{{0}}};
893
894 /* use our own dealloc so we can free a property if we use one */
895 static void dealloc_obj_dealloc(PyObject *self)
896 {
897         bpy_module_delay_init(((dealloc_obj *)self)->mod);
898
899         /* Note, for subclassed PyObjects we cant just call PyObject_DEL() directly or it will crash */
900         dealloc_obj_Type.tp_free(self);
901 }
902
903 PyMODINIT_FUNC
904 PyInit_bpy(void);
905
906 PyMODINIT_FUNC
907 PyInit_bpy(void)
908 {
909         PyObject *bpy_proxy = PyModule_Create(&bpy_proxy_def);
910         
911         /* Problem:
912          * 1) this init function is expected to have a private member defined - 'md_def'
913          *    but this is only set for C defined modules (not py packages)
914          *    so we cant return 'bpy_package_py' as is.
915          *
916          * 2) there is a 'bpy' C module for python to load which is basically all of blender,
917          *    and there is scripts/bpy/__init__.py, 
918          *    we may end up having to rename this module so there is no naming conflict here eg:
919          *    'from blender import bpy'
920          *
921          * 3) we don't know the filename at this point, workaround by assigning a dummy value
922          *    which calls back when its freed so the real loading can take place.
923          */
924
925         /* assign an object which is freed after __file__ is assigned */
926         dealloc_obj *dob;
927         
928         /* assign dummy type */
929         dealloc_obj_Type.tp_name = "dealloc_obj";
930         dealloc_obj_Type.tp_basicsize = sizeof(dealloc_obj);
931         dealloc_obj_Type.tp_dealloc = dealloc_obj_dealloc;
932         dealloc_obj_Type.tp_flags = Py_TPFLAGS_DEFAULT;
933         
934         if (PyType_Ready(&dealloc_obj_Type) < 0)
935                 return NULL;
936
937         dob = (dealloc_obj *) dealloc_obj_Type.tp_alloc(&dealloc_obj_Type, 0);
938         dob->mod = bpy_proxy; /* borrow */
939         PyModule_AddObject(bpy_proxy, "__file__", (PyObject *)dob); /* borrow */
940
941         return bpy_proxy;
942 }
943
944 static void bpy_module_free(void *UNUSED(mod))
945 {
946         main_python_exit();
947 }
948
949 #endif
950
951
952 /* EVIL, define text.c functions here... */
953 /* BKE_text.h */
954 int text_check_identifier_unicode(const unsigned int ch)
955 {
956         return (ch < 255 && text_check_identifier((char)ch)) || Py_UNICODE_ISALNUM(ch);
957 }
958
959 int text_check_identifier_nodigit_unicode(const unsigned int ch)
960 {
961         return (ch < 255 && text_check_identifier_nodigit((char)ch)) || Py_UNICODE_ISALPHA(ch);
962 }