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