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