PyAPI: update keyword list
[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(
696         bContext *C, const char *imports[],
697         const char *expr, bool use_eval)
698 {
699         BLI_assert(expr);
700         PyGILState_STATE gilstate;
701         PyObject *main_mod = NULL;
702         PyObject *py_dict, *retval;
703         bool ok = true;
704         Main *bmain_back; /* XXX, quick fix for release (Copy Settings crash), needs further investigation */
705
706         if (expr[0] == '\0') {
707                 return ok;
708         }
709
710         bpy_context_set(C, &gilstate);
711
712         PyC_MainModule_Backup(&main_mod);
713
714         py_dict = PyC_DefaultNameSpace("<blender string>");
715
716         bmain_back = bpy_import_main_get();
717         bpy_import_main_set(CTX_data_main(C));
718
719         if (imports && (!PyC_NameSpace_ImportArray(py_dict, imports))) {
720                 Py_DECREF(py_dict);
721                 retval = NULL;
722         }
723         else {
724                 retval = PyRun_String(expr, use_eval ? Py_eval_input : Py_file_input, py_dict, py_dict);
725         }
726
727         bpy_import_main_set(bmain_back);
728
729         if (retval == NULL) {
730                 ok = false;
731                 BPy_errors_to_report(CTX_wm_reports(C));
732         }
733         else {
734                 Py_DECREF(retval);
735         }
736
737         PyC_MainModule_Restore(main_mod);
738
739         bpy_context_clear(C, &gilstate);
740
741         return ok;
742 }
743
744 bool BPY_execute_string(
745         bContext *C, const char *imports[],
746         const char *expr)
747 {
748         return BPY_execute_string_ex(C, imports, expr, true);
749 }
750
751 void BPY_modules_load_user(bContext *C)
752 {
753         PyGILState_STATE gilstate;
754         Main *bmain = CTX_data_main(C);
755         Text *text;
756
757         /* can happen on file load */
758         if (bmain == NULL)
759                 return;
760
761         /* update pointers since this can run from a nested script
762          * on file load */
763         if (py_call_level) {
764                 BPY_context_update(C);
765         }
766
767         bpy_context_set(C, &gilstate);
768
769         for (text = bmain->text.first; text; text = text->id.next) {
770                 if (text->flags & TXT_ISSCRIPT && BLI_path_extension_check(text->id.name + 2, ".py")) {
771                         if (!(G.f & G_SCRIPT_AUTOEXEC)) {
772                                 if (!(G.f & G_SCRIPT_AUTOEXEC_FAIL_QUIET)) {
773                                         G.f |= G_SCRIPT_AUTOEXEC_FAIL;
774                                         BLI_snprintf(G.autoexec_fail, sizeof(G.autoexec_fail), "Text '%s'", text->id.name + 2);
775
776                                         printf("scripts disabled for \"%s\", skipping '%s'\n", BKE_main_blendfile_path(bmain), text->id.name + 2);
777                                 }
778                         }
779                         else {
780                                 PyObject *module = bpy_text_import(text);
781
782                                 if (module == NULL) {
783                                         PyErr_Print();
784                                         PyErr_Clear();
785                                 }
786                                 else {
787                                         Py_DECREF(module);
788                                 }
789
790                                 /* check if the script loaded a new file */
791                                 if (bmain != CTX_data_main(C)) {
792                                         break;
793                                 }
794                         }
795                 }
796         }
797         bpy_context_clear(C, &gilstate);
798 }
799
800 int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *result)
801 {
802         PyGILState_STATE gilstate;
803         bool use_gil = !PyC_IsInterpreterActive();
804
805         PyObject *pyctx;
806         PyObject *item;
807         PointerRNA *ptr = NULL;
808         bool done = false;
809
810         if (use_gil)
811                 gilstate = PyGILState_Ensure();
812
813         pyctx = (PyObject *)CTX_py_dict_get(C);
814         item = PyDict_GetItemString(pyctx, member);
815
816         if (item == NULL) {
817                 /* pass */
818         }
819         else if (item == Py_None) {
820                 done = true;
821         }
822         else if (BPy_StructRNA_Check(item)) {
823                 ptr = &(((BPy_StructRNA *)item)->ptr);
824
825                 //result->ptr = ((BPy_StructRNA *)item)->ptr;
826                 CTX_data_pointer_set(result, ptr->id.data, ptr->type, ptr->data);
827                 CTX_data_type_set(result, CTX_DATA_TYPE_POINTER);
828                 done = true;
829         }
830         else if (PySequence_Check(item)) {
831                 PyObject *seq_fast = PySequence_Fast(item, "bpy_context_get sequence conversion");
832                 if (seq_fast == NULL) {
833                         PyErr_Print();
834                         PyErr_Clear();
835                 }
836                 else {
837                         int len = PySequence_Fast_GET_SIZE(seq_fast);
838                         PyObject **seq_fast_items = PySequence_Fast_ITEMS(seq_fast);
839                         int i;
840
841                         for (i = 0; i < len; i++) {
842                                 PyObject *list_item = seq_fast_items[i];
843
844                                 if (BPy_StructRNA_Check(list_item)) {
845 #if 0
846                                         CollectionPointerLink *link = MEM_callocN(sizeof(CollectionPointerLink), "bpy_context_get");
847                                         link->ptr = ((BPy_StructRNA *)item)->ptr;
848                                         BLI_addtail(&result->list, link);
849 #endif
850                                         ptr = &(((BPy_StructRNA *)list_item)->ptr);
851                                         CTX_data_list_add(result, ptr->id.data, ptr->type, ptr->data);
852                                 }
853                                 else {
854                                         CLOG_INFO(BPY_LOG_CONTEXT, 1,
855                                                   "'%s' list item not a valid type in sequence type '%s'",
856                                                   member, Py_TYPE(item)->tp_name);
857                                 }
858
859                         }
860                         Py_DECREF(seq_fast);
861                         CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
862                         done = true;
863                 }
864         }
865
866         if (done == false) {
867                 if (item) {
868                         CLOG_INFO(BPY_LOG_CONTEXT, 1, "'%s' not a valid type", member);
869                 }
870                 else {
871                         CLOG_INFO(BPY_LOG_CONTEXT, 1, "'%s' not found\n", member);
872                 }
873         }
874         else {
875                 CLOG_INFO(BPY_LOG_CONTEXT, 2, "'%s' found", member);
876         }
877
878         if (use_gil)
879                 PyGILState_Release(gilstate);
880
881         return done;
882 }
883
884 #ifdef WITH_PYTHON_MODULE
885 /* TODO, reloading the module isn't functional at the moment. */
886
887 static void bpy_module_free(void *mod);
888 extern int main_python_enter(int argc, const char **argv);
889 extern void main_python_exit(void);
890 static struct PyModuleDef bpy_proxy_def = {
891         PyModuleDef_HEAD_INIT,
892         "bpy",  /* m_name */
893         NULL,  /* m_doc */
894         0,  /* m_size */
895         NULL,  /* m_methods */
896         NULL,  /* m_reload */
897         NULL,  /* m_traverse */
898         NULL,  /* m_clear */
899         bpy_module_free,  /* m_free */
900 };
901
902 typedef struct {
903         PyObject_HEAD
904         /* Type-specific fields go here. */
905         PyObject *mod;
906 } dealloc_obj;
907
908 /* call once __file__ is set */
909 static void bpy_module_delay_init(PyObject *bpy_proxy)
910 {
911         const int argc = 1;
912         const char *argv[2];
913
914         /* updating the module dict below will loose the reference to __file__ */
915         PyObject *filename_obj = PyModule_GetFilenameObject(bpy_proxy);
916
917         const char *filename_rel = _PyUnicode_AsString(filename_obj); /* can be relative */
918         char filename_abs[1024];
919
920         BLI_strncpy(filename_abs, filename_rel, sizeof(filename_abs));
921         BLI_path_cwd(filename_abs, sizeof(filename_abs));
922         Py_DECREF(filename_obj);
923
924         argv[0] = filename_abs;
925         argv[1] = NULL;
926
927         // printf("module found %s\n", argv[0]);
928
929         main_python_enter(argc, argv);
930
931         /* initialized in BPy_init_modules() */
932         PyDict_Update(PyModule_GetDict(bpy_proxy), PyModule_GetDict(bpy_package_py));
933 }
934
935 static void dealloc_obj_dealloc(PyObject *self);
936
937 static PyTypeObject dealloc_obj_Type;
938
939 /* use our own dealloc so we can free a property if we use one */
940 static void dealloc_obj_dealloc(PyObject *self)
941 {
942         bpy_module_delay_init(((dealloc_obj *)self)->mod);
943
944         /* Note, for subclassed PyObjects we cant just call PyObject_DEL() directly or it will crash */
945         dealloc_obj_Type.tp_free(self);
946 }
947
948 PyMODINIT_FUNC
949 PyInit_bpy(void);
950
951 PyMODINIT_FUNC
952 PyInit_bpy(void)
953 {
954         PyObject *bpy_proxy = PyModule_Create(&bpy_proxy_def);
955
956         /* Problem:
957          * 1) this init function is expected to have a private member defined - 'md_def'
958          *    but this is only set for C defined modules (not py packages)
959          *    so we cant return 'bpy_package_py' as is.
960          *
961          * 2) there is a 'bpy' C module for python to load which is basically all of blender,
962          *    and there is scripts/bpy/__init__.py,
963          *    we may end up having to rename this module so there is no naming conflict here eg:
964          *    'from blender import bpy'
965          *
966          * 3) we don't know the filename at this point, workaround by assigning a dummy value
967          *    which calls back when its freed so the real loading can take place.
968          */
969
970         /* assign an object which is freed after __file__ is assigned */
971         dealloc_obj *dob;
972
973         /* assign dummy type */
974         dealloc_obj_Type.tp_name = "dealloc_obj";
975         dealloc_obj_Type.tp_basicsize = sizeof(dealloc_obj);
976         dealloc_obj_Type.tp_dealloc = dealloc_obj_dealloc;
977         dealloc_obj_Type.tp_flags = Py_TPFLAGS_DEFAULT;
978
979         if (PyType_Ready(&dealloc_obj_Type) < 0)
980                 return NULL;
981
982         dob = (dealloc_obj *) dealloc_obj_Type.tp_alloc(&dealloc_obj_Type, 0);
983         dob->mod = bpy_proxy; /* borrow */
984         PyModule_AddObject(bpy_proxy, "__file__", (PyObject *)dob); /* borrow */
985
986         return bpy_proxy;
987 }
988
989 static void bpy_module_free(void *UNUSED(mod))
990 {
991         main_python_exit();
992 }
993
994 #endif
995
996 /**
997  * Avoids duplicating keyword list.
998  */
999 bool BPY_string_is_keyword(const char *str)
1000 {
1001         /* list is from...
1002          * ", ".join(['"%s"' % kw for kw in  __import__("keyword").kwlist])
1003          */
1004         const char *kwlist[] = {
1005             "False", "None", "True",
1006             "and", "as", "assert", "async", "await", "break",
1007             "class", "continue", "def", "del", "elif", "else", "except",
1008             "finally", "for", "from", "global", "if", "import", "in",
1009             "is", "lambda", "nonlocal", "not", "or", "pass", "raise",
1010             "return", "try", "while", "with", "yield", NULL,
1011         };
1012
1013         for (int i = 0; kwlist[i]; i++) {
1014                 if (STREQ(str, kwlist[i])) {
1015                         return true;
1016                 }
1017         }
1018
1019         return false;
1020 }
1021
1022
1023 /* EVIL, define text.c functions here... */
1024 /* BKE_text.h */
1025 int text_check_identifier_unicode(const unsigned int ch)
1026 {
1027         return (ch < 255 && text_check_identifier((char)ch)) || Py_UNICODE_ISALNUM(ch);
1028 }
1029
1030 int text_check_identifier_nodigit_unicode(const unsigned int ch)
1031 {
1032         return (ch < 255 && text_check_identifier_nodigit((char)ch)) || Py_UNICODE_ISALPHA(ch);
1033 }