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