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