123c938b921c8425e77aa7d4d19fbc2a28dca864
[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 "../generic/imbuf_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", GPU_initPython},
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_GetItemString(PyImport_GetModuleDict(), "__main__");
541                 PyObject *dict_back = mmod->md_dict;
542                 /* freeing the module will clear the namespace,
543                  * gives problems running classes defined in this namespace being used later. */
544                 mmod->md_dict = NULL;
545                 Py_DECREF(dict_back);
546 #endif
547
548 #undef PYMODULE_CLEAR_WORKAROUND
549         }
550
551         PyC_MainModule_Restore(main_mod);
552
553         bpy_context_clear(C, &gilstate);
554
555         return (py_result != NULL);
556 }
557
558 /* Can run a file or text block */
559 bool BPY_execute_filepath(bContext *C, const char *filepath, struct ReportList *reports)
560 {
561         return python_script_exec(C, filepath, NULL, reports, false);
562 }
563
564
565 bool BPY_execute_text(bContext *C, struct Text *text, struct ReportList *reports, const bool do_jump)
566 {
567         return python_script_exec(C, NULL, text, reports, do_jump);
568 }
569
570 void BPY_DECREF(void *pyob_ptr)
571 {
572         PyGILState_STATE gilstate = PyGILState_Ensure();
573         Py_DECREF((PyObject *)pyob_ptr);
574         PyGILState_Release(gilstate);
575 }
576
577 void BPY_DECREF_RNA_INVALIDATE(void *pyob_ptr)
578 {
579         PyGILState_STATE gilstate = PyGILState_Ensure();
580         const int do_invalidate = (Py_REFCNT((PyObject *)pyob_ptr) > 1);
581         Py_DECREF((PyObject *)pyob_ptr);
582         if (do_invalidate) {
583                 pyrna_invalidate(pyob_ptr);
584         }
585         PyGILState_Release(gilstate);
586 }
587
588 /**
589  * \return success
590  */
591 bool BPY_execute_string_as_number(
592         bContext *C, const char *imports[],
593         const char *expr, const bool verbose, double *r_value)
594 {
595         PyGILState_STATE gilstate;
596         bool ok = true;
597
598         if (!r_value || !expr) {
599                 return -1;
600         }
601
602         if (expr[0] == '\0') {
603                 *r_value = 0.0;
604                 return ok;
605         }
606
607         bpy_context_set(C, &gilstate);
608
609         ok = PyC_RunString_AsNumber(imports, expr, "<expr as number>", r_value);
610
611         if (ok == false) {
612                 if (verbose) {
613                         BPy_errors_to_report_ex(CTX_wm_reports(C), false, false);
614                 }
615                 else {
616                         PyErr_Clear();
617                 }
618         }
619
620         bpy_context_clear(C, &gilstate);
621
622         return ok;
623 }
624
625 /**
626  * \return success
627  */
628 bool BPY_execute_string_as_string(
629         bContext *C, const char *imports[],
630         const char *expr, const bool verbose, char **r_value)
631 {
632         BLI_assert(r_value && expr);
633         PyGILState_STATE gilstate;
634         bool ok = true;
635
636         if (expr[0] == '\0') {
637                 *r_value = NULL;
638                 return ok;
639         }
640
641         bpy_context_set(C, &gilstate);
642
643         ok = PyC_RunString_AsString(imports, expr, "<expr as str>", r_value);
644
645         if (ok == false) {
646                 if (verbose) {
647                         BPy_errors_to_report_ex(CTX_wm_reports(C), false, false);
648                 }
649                 else {
650                         PyErr_Clear();
651                 }
652         }
653
654         bpy_context_clear(C, &gilstate);
655
656         return ok;
657 }
658
659 /**
660  * Support both int and pointers.
661  *
662  * \return success
663  */
664 bool BPY_execute_string_as_intptr(
665         bContext *C, const char *imports[],
666         const char *expr, const bool verbose, intptr_t *r_value)
667 {
668         BLI_assert(r_value && expr);
669         PyGILState_STATE gilstate;
670         bool ok = true;
671
672         if (expr[0] == '\0') {
673                 *r_value = 0;
674                 return ok;
675         }
676
677         bpy_context_set(C, &gilstate);
678
679         ok = PyC_RunString_AsIntPtr(imports, expr, "<expr as intptr>", r_value);
680
681         if (ok == false) {
682                 if (verbose) {
683                         BPy_errors_to_report_ex(CTX_wm_reports(C), false, false);
684                 }
685                 else {
686                         PyErr_Clear();
687                 }
688         }
689
690         bpy_context_clear(C, &gilstate);
691
692         return ok;
693 }
694
695 bool BPY_execute_string_ex(bContext *C, const char *expr, bool use_eval)
696 {
697         BLI_assert(expr);
698         PyGILState_STATE gilstate;
699         PyObject *main_mod = NULL;
700         PyObject *py_dict, *retval;
701         bool ok = true;
702         Main *bmain_back; /* XXX, quick fix for release (Copy Settings crash), needs further investigation */
703
704         if (expr[0] == '\0') {
705                 return ok;
706         }
707
708         bpy_context_set(C, &gilstate);
709
710         PyC_MainModule_Backup(&main_mod);
711
712         py_dict = PyC_DefaultNameSpace("<blender string>");
713
714         bmain_back = bpy_import_main_get();
715         bpy_import_main_set(CTX_data_main(C));
716
717         retval = PyRun_String(expr, use_eval ? Py_eval_input : Py_file_input, py_dict, py_dict);
718
719         bpy_import_main_set(bmain_back);
720
721         if (retval == NULL) {
722                 ok = false;
723
724                 BPy_errors_to_report(CTX_wm_reports(C));
725         }
726         else {
727                 Py_DECREF(retval);
728         }
729
730         PyC_MainModule_Restore(main_mod);
731
732         bpy_context_clear(C, &gilstate);
733
734         return ok;
735 }
736
737 bool BPY_execute_string(bContext *C, const char *expr)
738 {
739         return BPY_execute_string_ex(C, expr, true);
740 }
741
742 void BPY_modules_load_user(bContext *C)
743 {
744         PyGILState_STATE gilstate;
745         Main *bmain = CTX_data_main(C);
746         Text *text;
747
748         /* can happen on file load */
749         if (bmain == NULL)
750                 return;
751
752         /* update pointers since this can run from a nested script
753          * on file load */
754         if (py_call_level) {
755                 BPY_context_update(C);
756         }
757
758         bpy_context_set(C, &gilstate);
759
760         for (text = bmain->text.first; text; text = text->id.next) {
761                 if (text->flags & TXT_ISSCRIPT && BLI_path_extension_check(text->id.name + 2, ".py")) {
762                         if (!(G.f & G_SCRIPT_AUTOEXEC)) {
763                                 if (!(G.f & G_SCRIPT_AUTOEXEC_FAIL_QUIET)) {
764                                         G.f |= G_SCRIPT_AUTOEXEC_FAIL;
765                                         BLI_snprintf(G.autoexec_fail, sizeof(G.autoexec_fail), "Text '%s'", text->id.name + 2);
766
767                                         printf("scripts disabled for \"%s\", skipping '%s'\n", BKE_main_blendfile_path(bmain), text->id.name + 2);
768                                 }
769                         }
770                         else {
771                                 PyObject *module = bpy_text_import(text);
772
773                                 if (module == NULL) {
774                                         PyErr_Print();
775                                         PyErr_Clear();
776                                 }
777                                 else {
778                                         Py_DECREF(module);
779                                 }
780
781                                 /* check if the script loaded a new file */
782                                 if (bmain != CTX_data_main(C)) {
783                                         break;
784                                 }
785                         }
786                 }
787         }
788         bpy_context_clear(C, &gilstate);
789 }
790
791 int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *result)
792 {
793         PyGILState_STATE gilstate;
794         bool use_gil = !PyC_IsInterpreterActive();
795
796         PyObject *pyctx;
797         PyObject *item;
798         PointerRNA *ptr = NULL;
799         bool done = false;
800
801         if (use_gil)
802                 gilstate = PyGILState_Ensure();
803
804         pyctx = (PyObject *)CTX_py_dict_get(C);
805         item = PyDict_GetItemString(pyctx, member);
806
807         if (item == NULL) {
808                 /* pass */
809         }
810         else if (item == Py_None) {
811                 done = true;
812         }
813         else if (BPy_StructRNA_Check(item)) {
814                 ptr = &(((BPy_StructRNA *)item)->ptr);
815
816                 //result->ptr = ((BPy_StructRNA *)item)->ptr;
817                 CTX_data_pointer_set(result, ptr->id.data, ptr->type, ptr->data);
818                 CTX_data_type_set(result, CTX_DATA_TYPE_POINTER);
819                 done = true;
820         }
821         else if (PySequence_Check(item)) {
822                 PyObject *seq_fast = PySequence_Fast(item, "bpy_context_get sequence conversion");
823                 if (seq_fast == NULL) {
824                         PyErr_Print();
825                         PyErr_Clear();
826                 }
827                 else {
828                         int len = PySequence_Fast_GET_SIZE(seq_fast);
829                         PyObject **seq_fast_items = PySequence_Fast_ITEMS(seq_fast);
830                         int i;
831
832                         for (i = 0; i < len; i++) {
833                                 PyObject *list_item = seq_fast_items[i];
834
835                                 if (BPy_StructRNA_Check(list_item)) {
836 #if 0
837                                         CollectionPointerLink *link = MEM_callocN(sizeof(CollectionPointerLink), "bpy_context_get");
838                                         link->ptr = ((BPy_StructRNA *)item)->ptr;
839                                         BLI_addtail(&result->list, link);
840 #endif
841                                         ptr = &(((BPy_StructRNA *)list_item)->ptr);
842                                         CTX_data_list_add(result, ptr->id.data, ptr->type, ptr->data);
843                                 }
844                                 else {
845                                         CLOG_INFO(BPY_LOG_CONTEXT, 1,
846                                                   "'%s' list item not a valid type in sequence type '%s'",
847                                                   member, Py_TYPE(item)->tp_name);
848                                 }
849
850                         }
851                         Py_DECREF(seq_fast);
852                         CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
853                         done = true;
854                 }
855         }
856
857         if (done == false) {
858                 if (item) {
859                         CLOG_INFO(BPY_LOG_CONTEXT, 1, "'%s' not a valid type", member);
860                 }
861                 else {
862                         CLOG_INFO(BPY_LOG_CONTEXT, 1, "'%s' not found\n", member);
863                 }
864         }
865         else {
866                 CLOG_INFO(BPY_LOG_CONTEXT, 2, "'%s' found", member);
867         }
868
869         if (use_gil)
870                 PyGILState_Release(gilstate);
871
872         return done;
873 }
874
875 #ifdef WITH_PYTHON_MODULE
876 /* TODO, reloading the module isn't functional at the moment. */
877
878 static void bpy_module_free(void *mod);
879 extern int main_python_enter(int argc, const char **argv);
880 extern void main_python_exit(void);
881 static struct PyModuleDef bpy_proxy_def = {
882         PyModuleDef_HEAD_INIT,
883         "bpy",  /* m_name */
884         NULL,  /* m_doc */
885         0,  /* m_size */
886         NULL,  /* m_methods */
887         NULL,  /* m_reload */
888         NULL,  /* m_traverse */
889         NULL,  /* m_clear */
890         bpy_module_free,  /* m_free */
891 };
892
893 typedef struct {
894         PyObject_HEAD
895         /* Type-specific fields go here. */
896         PyObject *mod;
897 } dealloc_obj;
898
899 /* call once __file__ is set */
900 static void bpy_module_delay_init(PyObject *bpy_proxy)
901 {
902         const int argc = 1;
903         const char *argv[2];
904
905         /* updating the module dict below will loose the reference to __file__ */
906         PyObject *filename_obj = PyModule_GetFilenameObject(bpy_proxy);
907
908         const char *filename_rel = _PyUnicode_AsString(filename_obj); /* can be relative */
909         char filename_abs[1024];
910
911         BLI_strncpy(filename_abs, filename_rel, sizeof(filename_abs));
912         BLI_path_cwd(filename_abs, sizeof(filename_abs));
913         Py_DECREF(filename_obj);
914
915         argv[0] = filename_abs;
916         argv[1] = NULL;
917
918         // printf("module found %s\n", argv[0]);
919
920         main_python_enter(argc, argv);
921
922         /* initialized in BPy_init_modules() */
923         PyDict_Update(PyModule_GetDict(bpy_proxy), PyModule_GetDict(bpy_package_py));
924 }
925
926 static void dealloc_obj_dealloc(PyObject *self);
927
928 static PyTypeObject dealloc_obj_Type;
929
930 /* use our own dealloc so we can free a property if we use one */
931 static void dealloc_obj_dealloc(PyObject *self)
932 {
933         bpy_module_delay_init(((dealloc_obj *)self)->mod);
934
935         /* Note, for subclassed PyObjects we cant just call PyObject_DEL() directly or it will crash */
936         dealloc_obj_Type.tp_free(self);
937 }
938
939 PyMODINIT_FUNC
940 PyInit_bpy(void);
941
942 PyMODINIT_FUNC
943 PyInit_bpy(void)
944 {
945         PyObject *bpy_proxy = PyModule_Create(&bpy_proxy_def);
946
947         /* Problem:
948          * 1) this init function is expected to have a private member defined - 'md_def'
949          *    but this is only set for C defined modules (not py packages)
950          *    so we cant return 'bpy_package_py' as is.
951          *
952          * 2) there is a 'bpy' C module for python to load which is basically all of blender,
953          *    and there is scripts/bpy/__init__.py,
954          *    we may end up having to rename this module so there is no naming conflict here eg:
955          *    'from blender import bpy'
956          *
957          * 3) we don't know the filename at this point, workaround by assigning a dummy value
958          *    which calls back when its freed so the real loading can take place.
959          */
960
961         /* assign an object which is freed after __file__ is assigned */
962         dealloc_obj *dob;
963
964         /* assign dummy type */
965         dealloc_obj_Type.tp_name = "dealloc_obj";
966         dealloc_obj_Type.tp_basicsize = sizeof(dealloc_obj);
967         dealloc_obj_Type.tp_dealloc = dealloc_obj_dealloc;
968         dealloc_obj_Type.tp_flags = Py_TPFLAGS_DEFAULT;
969
970         if (PyType_Ready(&dealloc_obj_Type) < 0)
971                 return NULL;
972
973         dob = (dealloc_obj *) dealloc_obj_Type.tp_alloc(&dealloc_obj_Type, 0);
974         dob->mod = bpy_proxy; /* borrow */
975         PyModule_AddObject(bpy_proxy, "__file__", (PyObject *)dob); /* borrow */
976
977         return bpy_proxy;
978 }
979
980 static void bpy_module_free(void *UNUSED(mod))
981 {
982         main_python_exit();
983 }
984
985 #endif
986
987 /**
988  * Avoids duplicating keyword list.
989  */
990 bool BPY_string_is_keyword(const char *str)
991 {
992         /* list is from...
993          * ", ".join(['"%s"' % kw for kw in  __import__("keyword").kwlist])
994          */
995         const char *kwlist[] = {
996             "False", "None", "True",
997             "and", "as", "assert", "break",
998             "class", "continue", "def", "del", "elif", "else", "except",
999             "finally", "for", "from", "global", "if", "import", "in",
1000             "is", "lambda", "nonlocal", "not", "or", "pass", "raise",
1001             "return", "try", "while", "with", "yield", NULL,
1002         };
1003
1004         for (int i = 0; kwlist[i]; i++) {
1005                 if (STREQ(str, kwlist[i])) {
1006                         return true;
1007                 }
1008         }
1009
1010         return false;
1011 }
1012
1013
1014 /* EVIL, define text.c functions here... */
1015 /* BKE_text.h */
1016 int text_check_identifier_unicode(const unsigned int ch)
1017 {
1018         return (ch < 255 && text_check_identifier((char)ch)) || Py_UNICODE_ISALNUM(ch);
1019 }
1020
1021 int text_check_identifier_nodigit_unicode(const unsigned int ch)
1022 {
1023         return (ch < 255 && text_check_identifier_nodigit((char)ch)) || Py_UNICODE_ISALPHA(ch);
1024 }