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