Cleanup: blank lines over doxy headers
[blender.git] / source / blender / python / generic / py_capi_utils.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  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 /** \file blender/python/generic/py_capi_utils.c
22  *  \ingroup pygen
23  *
24  * Extend upon CPython's API, filling in some gaps, these functions use PyC_
25  * prefix to distinguish them apart from CPython.
26  *
27  * \note
28  * This module should only depend on CPython, however it currently uses
29  * BLI_string_utf8() for unicode conversion.
30  */
31
32 #include <Python.h>
33 #include <frameobject.h>
34
35 #include "BLI_utildefines.h"  /* for bool */
36
37 #include "py_capi_utils.h"
38
39 #include "python_utildefines.h"
40
41 #include "BLI_string.h"
42
43 #ifndef MATH_STANDALONE
44 /* only for BLI_strncpy_wchar_from_utf8, should replace with py funcs but too late in release now */
45 #include "BLI_string_utf8.h"
46 #endif
47
48 #ifdef _WIN32
49 #include "BLI_math_base.h"  /* isfinite() */
50 #endif
51
52 /* array utility function */
53 int PyC_AsArray_FAST(
54         void *array, PyObject *value_fast, const Py_ssize_t length,
55         const PyTypeObject *type, const bool is_double, const char *error_prefix)
56 {
57         const Py_ssize_t value_len = PySequence_Fast_GET_SIZE(value_fast);
58         PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
59         Py_ssize_t i;
60
61         BLI_assert(PyList_Check(value_fast) || PyTuple_Check(value_fast));
62
63         if (value_len != length) {
64                 PyErr_Format(PyExc_TypeError,
65                              "%.200s: invalid sequence length. expected %d, got %d",
66                              error_prefix, length, value_len);
67                 return -1;
68         }
69
70         /* for each type */
71         if (type == &PyFloat_Type) {
72                 if (is_double) {
73                         double *array_double = array;
74                         for (i = 0; i < length; i++) {
75                                 array_double[i] = PyFloat_AsDouble(value_fast_items[i]);
76                         }
77                 }
78                 else {
79                         float *array_float = array;
80                         for (i = 0; i < length; i++) {
81                                 array_float[i] = PyFloat_AsDouble(value_fast_items[i]);
82                         }
83                 }
84         }
85         else if (type == &PyLong_Type) {
86                 /* could use is_double for 'long int' but no use now */
87                 int *array_int = array;
88                 for (i = 0; i < length; i++) {
89                         array_int[i] = PyC_Long_AsI32(value_fast_items[i]);
90                 }
91         }
92         else if (type == &PyBool_Type) {
93                 bool *array_bool = array;
94                 for (i = 0; i < length; i++) {
95                         array_bool[i] = (PyLong_AsLong(value_fast_items[i]) != 0);
96                 }
97         }
98         else {
99                 PyErr_Format(PyExc_TypeError,
100                              "%s: internal error %s is invalid",
101                              error_prefix, type->tp_name);
102                 return -1;
103         }
104
105         if (PyErr_Occurred()) {
106                 PyErr_Format(PyExc_TypeError,
107                              "%s: one or more items could not be used as a %s",
108                              error_prefix, type->tp_name);
109                 return -1;
110         }
111
112         return 0;
113 }
114
115 int PyC_AsArray(
116         void *array, PyObject *value, const Py_ssize_t length,
117         const PyTypeObject *type, const bool is_double, const char *error_prefix)
118 {
119         PyObject *value_fast;
120         int ret;
121
122         if (!(value_fast = PySequence_Fast(value, error_prefix))) {
123                 return -1;
124         }
125
126         ret = PyC_AsArray_FAST(array, value_fast, length, type, is_double, error_prefix);
127         Py_DECREF(value_fast);
128         return ret;
129 }
130
131 /* -------------------------------------------------------------------- */
132 /** \name Typed Tuple Packing
133  *
134  * \note See #PyC_Tuple_Pack_* macros that take multiple arguments.
135  *
136  * \{ */
137
138 /* array utility function */
139 PyObject *PyC_Tuple_PackArray_F32(const float *array, uint len)
140 {
141         PyObject *tuple = PyTuple_New(len);
142         for (uint i = 0; i < len; i++) {
143                 PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(array[i]));
144         }
145         return tuple;
146 }
147
148 PyObject *PyC_Tuple_PackArray_F64(const double *array, uint len)
149 {
150         PyObject *tuple = PyTuple_New(len);
151         for (uint i = 0; i < len; i++) {
152                 PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(array[i]));
153         }
154         return tuple;
155 }
156
157 PyObject *PyC_Tuple_PackArray_I32(const int *array, uint len)
158 {
159         PyObject *tuple = PyTuple_New(len);
160         for (uint i = 0; i < len; i++) {
161                 PyTuple_SET_ITEM(tuple, i, PyLong_FromLong(array[i]));
162         }
163         return tuple;
164 }
165
166 PyObject *PyC_Tuple_PackArray_I32FromBool(const int *array, uint len)
167 {
168         PyObject *tuple = PyTuple_New(len);
169         for (uint i = 0; i < len; i++) {
170                 PyTuple_SET_ITEM(tuple, i, PyBool_FromLong(array[i]));
171         }
172         return tuple;
173 }
174
175 PyObject *PyC_Tuple_PackArray_Bool(const bool *array, uint len)
176 {
177         PyObject *tuple = PyTuple_New(len);
178         for (uint i = 0; i < len; i++) {
179                 PyTuple_SET_ITEM(tuple, i, PyBool_FromLong(array[i]));
180         }
181         return tuple;
182 }
183
184 /** \} */
185
186 /**
187  * Caller needs to ensure tuple is uninitialized.
188  * Handy for filling a tuple with None for eg.
189  */
190 void PyC_Tuple_Fill(PyObject *tuple, PyObject *value)
191 {
192         unsigned int tot = PyTuple_GET_SIZE(tuple);
193         unsigned int i;
194
195         for (i = 0; i < tot; i++) {
196                 PyTuple_SET_ITEM(tuple, i, value);
197                 Py_INCREF(value);
198         }
199 }
200
201 void PyC_List_Fill(PyObject *list, PyObject *value)
202 {
203         unsigned int tot = PyList_GET_SIZE(list);
204         unsigned int i;
205
206         for (i = 0; i < tot; i++) {
207                 PyList_SET_ITEM(list, i, value);
208                 Py_INCREF(value);
209         }
210 }
211
212 /**
213  * Use with PyArg_ParseTuple's "O&" formatting.
214  *
215  * \see #PyC_Long_AsBool for a similar function to use outside of argument parsing.
216  */
217 int PyC_ParseBool(PyObject *o, void *p)
218 {
219         bool *bool_p = p;
220         long value;
221         if (((value = PyLong_AsLong(o)) == -1) || !ELEM(value, 0, 1)) {
222                 PyErr_Format(PyExc_ValueError,
223                              "expected a bool or int (0/1), got %s",
224                              Py_TYPE(o)->tp_name);
225                 return 0;
226         }
227
228         *bool_p = value ? true : false;
229         return 1;
230 }
231
232 /* silly function, we dont use arg. just check its compatible with __deepcopy__ */
233 int PyC_CheckArgs_DeepCopy(PyObject *args)
234 {
235         PyObject *dummy_pydict;
236         return PyArg_ParseTuple(args, "|O!:__deepcopy__", &PyDict_Type, &dummy_pydict) != 0;
237 }
238
239 #ifndef MATH_STANDALONE
240
241 /* for debugging */
242 void PyC_ObSpit(const char *name, PyObject *var)
243 {
244         const char *null_str = "<null>";
245         fprintf(stderr, "<%s> : ", name);
246         if (var == NULL) {
247                 fprintf(stderr, "%s\n", null_str);
248         }
249         else {
250                 PyObject_Print(var, stderr, 0);
251                 const PyTypeObject *type = Py_TYPE(var);
252                 fprintf(stderr,
253                         " ref:%d, ptr:%p, type: %s\n",
254                         (int)var->ob_refcnt, (void *)var, type ? type->tp_name : null_str);
255         }
256 }
257
258 /**
259  * A version of #PyC_ObSpit that writes into a string (and doesn't take a name argument).
260  * Use for logging.
261  */
262 void PyC_ObSpitStr(char *result, size_t result_len, PyObject *var)
263 {
264         /* No name, creator of string can manage that. */
265         const char *null_str = "<null>";
266         if (var == NULL) {
267                 BLI_snprintf(result, result_len, "%s", null_str);
268         }
269         else {
270                 const PyTypeObject *type = Py_TYPE(var);
271                 PyObject *var_str = PyObject_Repr(var);
272                 if (var_str == NULL) {
273                         /* We could print error here, but this may be used for generating errors - so don't for now. */
274                         PyErr_Clear();
275                 }
276                 BLI_snprintf(
277                         result, result_len,
278                         " ref=%d, ptr=%p, type=%s, value=%.200s",
279                         (int)var->ob_refcnt,
280                         (void *)var,
281                         type ? type->tp_name : null_str,
282                         var_str ? _PyUnicode_AsString(var_str) : "<error>");
283                 if (var_str != NULL) {
284                         Py_DECREF(var_str);
285                 }
286         }
287 }
288
289 void PyC_LineSpit(void)
290 {
291
292         const char *filename;
293         int lineno;
294
295         /* Note, allow calling from outside python (RNA) */
296         if (!PyC_IsInterpreterActive()) {
297                 fprintf(stderr, "python line lookup failed, interpreter inactive\n");
298                 return;
299         }
300
301         PyErr_Clear();
302         PyC_FileAndNum(&filename, &lineno);
303
304         fprintf(stderr, "%s:%d\n", filename, lineno);
305 }
306
307 void PyC_StackSpit(void)
308 {
309         /* Note, allow calling from outside python (RNA) */
310         if (!PyC_IsInterpreterActive()) {
311                 fprintf(stderr, "python line lookup failed, interpreter inactive\n");
312                 return;
313         }
314         else {
315                 /* lame but handy */
316                 PyGILState_STATE gilstate = PyGILState_Ensure();
317                 PyRun_SimpleString("__import__('traceback').print_stack()");
318                 PyGILState_Release(gilstate);
319         }
320 }
321
322 void PyC_FileAndNum(const char **filename, int *lineno)
323 {
324         PyFrameObject *frame;
325
326         if (filename) *filename = NULL;
327         if (lineno)   *lineno = -1;
328
329         if (!(frame = PyThreadState_GET()->frame)) {
330                 return;
331         }
332
333         /* when executing a script */
334         if (filename) {
335                 *filename = _PyUnicode_AsString(frame->f_code->co_filename);
336         }
337
338         /* when executing a module */
339         if (filename && *filename == NULL) {
340                 /* try an alternative method to get the filename - module based
341                  * references below are all borrowed (double checked) */
342                 PyObject *mod_name = PyDict_GetItemString(PyEval_GetGlobals(), "__name__");
343                 if (mod_name) {
344                         PyObject *mod = PyDict_GetItem(PyImport_GetModuleDict(), mod_name);
345                         if (mod) {
346                                 PyObject *mod_file = PyModule_GetFilenameObject(mod);
347                                 if (mod_file) {
348                                         *filename = _PyUnicode_AsString(mod_name);
349                                         Py_DECREF(mod_file);
350                                 }
351                                 else {
352                                         PyErr_Clear();
353                                 }
354                         }
355
356                         /* unlikely, fallback */
357                         if (*filename == NULL) {
358                                 *filename = _PyUnicode_AsString(mod_name);
359                         }
360                 }
361         }
362
363         if (lineno) {
364                 *lineno = PyFrame_GetLineNumber(frame);
365         }
366 }
367
368 void PyC_FileAndNum_Safe(const char **filename, int *lineno)
369 {
370         if (!PyC_IsInterpreterActive()) {
371                 return;
372         }
373
374         PyC_FileAndNum(filename, lineno);
375 }
376
377 /* Would be nice if python had this built in */
378 PyObject *PyC_Object_GetAttrStringArgs(PyObject *o, Py_ssize_t n, ...)
379 {
380         Py_ssize_t i;
381         PyObject *item = o;
382         const char *attr;
383
384         va_list vargs;
385
386         va_start(vargs, n);
387         for (i = 0; i < n; i++) {
388                 attr = va_arg(vargs, char *);
389                 item = PyObject_GetAttrString(item, attr);
390
391                 if (item)
392                         Py_DECREF(item);
393                 else /* python will set the error value here */
394                         break;
395
396         }
397         va_end(vargs);
398
399         Py_XINCREF(item); /* final value has is increfed, to match PyObject_GetAttrString */
400         return item;
401 }
402
403 PyObject *PyC_FrozenSetFromStrings(const char **strings)
404 {
405         const char **str;
406         PyObject *ret;
407
408         ret = PyFrozenSet_New(NULL);
409
410         for (str = strings; *str; str++) {
411                 PyObject *py_str = PyUnicode_FromString(*str);
412                 PySet_Add(ret, py_str);
413                 Py_DECREF(py_str);
414         }
415
416         return ret;
417 }
418
419
420 /**
421  * Similar to #PyErr_Format(),
422  *
423  * Implementation - we cant actually prepend the existing exception,
424  * because it could have _any_ arguments given to it, so instead we get its
425  * ``__str__`` output and raise our own exception including it.
426  */
427 PyObject *PyC_Err_Format_Prefix(PyObject *exception_type_prefix, const char *format, ...)
428 {
429         PyObject *error_value_prefix;
430         va_list args;
431
432         va_start(args, format);
433         error_value_prefix = PyUnicode_FromFormatV(format, args); /* can fail and be NULL */
434         va_end(args);
435
436         if (PyErr_Occurred()) {
437                 PyObject *error_type, *error_value, *error_traceback;
438                 PyErr_Fetch(&error_type, &error_value, &error_traceback);
439
440                 if (PyUnicode_Check(error_value)) {
441                         PyErr_Format(exception_type_prefix,
442                                      "%S, %S",
443                                      error_value_prefix,
444                                      error_value);
445                 }
446                 else {
447                         PyErr_Format(exception_type_prefix,
448                                      "%S, %.200s(%S)",
449                                      error_value_prefix,
450                                      Py_TYPE(error_value)->tp_name,
451                                      error_value);
452                 }
453         }
454         else {
455                 PyErr_SetObject(exception_type_prefix,
456                                 error_value_prefix);
457         }
458
459         Py_XDECREF(error_value_prefix);
460
461         /* dumb to always return NULL but matches PyErr_Format */
462         return NULL;
463 }
464
465 PyObject *PyC_Err_SetString_Prefix(PyObject *exception_type_prefix, const char *str)
466 {
467         return PyC_Err_Format_Prefix(exception_type_prefix, "%s", str);
468 }
469
470 /**
471  * Use for Python callbacks run directly from C,
472  * when we can't use normal methods of raising exceptions.
473  */
474 void PyC_Err_PrintWithFunc(PyObject *py_func)
475 {
476         /* since we return to C code we can't leave the error */
477         PyCodeObject *f_code = (PyCodeObject *)PyFunction_GET_CODE(py_func);
478         PyErr_Print();
479         PyErr_Clear();
480
481         /* use py style error */
482         fprintf(stderr, "File \"%s\", line %d, in %s\n",
483                 _PyUnicode_AsString(f_code->co_filename),
484                 f_code->co_firstlineno,
485                 _PyUnicode_AsString(((PyFunctionObject *)py_func)->func_name)
486                 );
487 }
488
489
490 /* returns the exception string as a new PyUnicode object, depends on external traceback module */
491 #if 0
492
493 /* this version uses traceback module but somehow fails on UI errors */
494
495 PyObject *PyC_ExceptionBuffer(void)
496 {
497         PyObject *traceback_mod = NULL;
498         PyObject *format_tb_func = NULL;
499         PyObject *ret = NULL;
500
501         if (!(traceback_mod = PyImport_ImportModule("traceback"))) {
502                 goto error_cleanup;
503         }
504         else if (!(format_tb_func = PyObject_GetAttrString(traceback_mod, "format_exc"))) {
505                 goto error_cleanup;
506         }
507
508         ret = PyObject_CallObject(format_tb_func, NULL);
509
510         if (ret == Py_None) {
511                 Py_DECREF(ret);
512                 ret = NULL;
513         }
514
515 error_cleanup:
516         /* could not import the module so print the error and close */
517         Py_XDECREF(traceback_mod);
518         Py_XDECREF(format_tb_func);
519
520         return ret;
521 }
522 #else /* verbose, non-threadsafe version */
523 PyObject *PyC_ExceptionBuffer(void)
524 {
525         PyObject *stdout_backup = PySys_GetObject("stdout"); /* borrowed */
526         PyObject *stderr_backup = PySys_GetObject("stderr"); /* borrowed */
527         PyObject *string_io = NULL;
528         PyObject *string_io_buf = NULL;
529         PyObject *string_io_mod = NULL;
530         PyObject *string_io_getvalue = NULL;
531
532         PyObject *error_type, *error_value, *error_traceback;
533
534         if (!PyErr_Occurred())
535                 return NULL;
536
537         PyErr_Fetch(&error_type, &error_value, &error_traceback);
538
539         PyErr_Clear();
540
541         /* import io
542          * string_io = io.StringIO()
543          */
544
545         if (!(string_io_mod = PyImport_ImportModule("io"))) {
546                 goto error_cleanup;
547         }
548         else if (!(string_io = PyObject_CallMethod(string_io_mod, "StringIO", NULL))) {
549                 goto error_cleanup;
550         }
551         else if (!(string_io_getvalue = PyObject_GetAttrString(string_io, "getvalue"))) {
552                 goto error_cleanup;
553         }
554
555         Py_INCREF(stdout_backup); // since these were borrowed we don't want them freed when replaced.
556         Py_INCREF(stderr_backup);
557
558         PySys_SetObject("stdout", string_io); // both of these are freed when restoring
559         PySys_SetObject("stderr", string_io);
560
561         PyErr_Restore(error_type, error_value, error_traceback);
562         PyErr_Print(); /* print the error */
563         PyErr_Clear();
564
565         string_io_buf = PyObject_CallObject(string_io_getvalue, NULL);
566
567         PySys_SetObject("stdout", stdout_backup);
568         PySys_SetObject("stderr", stderr_backup);
569
570         Py_DECREF(stdout_backup); /* now sys owns the ref again */
571         Py_DECREF(stderr_backup);
572
573         Py_DECREF(string_io_mod);
574         Py_DECREF(string_io_getvalue);
575         Py_DECREF(string_io); /* free the original reference */
576
577         PyErr_Clear();
578         return string_io_buf;
579
580
581 error_cleanup:
582         /* could not import the module so print the error and close */
583         Py_XDECREF(string_io_mod);
584         Py_XDECREF(string_io);
585
586         PyErr_Restore(error_type, error_value, error_traceback);
587         PyErr_Print(); /* print the error */
588         PyErr_Clear();
589
590         return NULL;
591 }
592 #endif
593
594 PyObject *PyC_ExceptionBuffer_Simple(void)
595 {
596         PyObject *string_io_buf;
597
598         PyObject *error_type, *error_value, *error_traceback;
599
600         if (!PyErr_Occurred())
601                 return NULL;
602
603         PyErr_Fetch(&error_type, &error_value, &error_traceback);
604
605         if (error_value == NULL) {
606                 return NULL;
607         }
608
609         string_io_buf = PyObject_Str(error_value);
610         /* Python does this too */
611         if (UNLIKELY(string_io_buf == NULL)) {
612                 string_io_buf = PyUnicode_FromFormat(
613                         "<unprintable %s object>", Py_TYPE(error_value)->tp_name);
614         }
615
616         PyErr_Restore(error_type, error_value, error_traceback);
617
618         PyErr_Print();
619         PyErr_Clear();
620         return string_io_buf;
621 }
622
623 /* string conversion, escape non-unicode chars, coerce must be set to NULL */
624 const char *PyC_UnicodeAsByteAndSize(PyObject *py_str, Py_ssize_t *size, PyObject **coerce)
625 {
626         const char *result;
627
628         result = _PyUnicode_AsStringAndSize(py_str, size);
629
630         if (result) {
631                 /* 99% of the time this is enough but we better support non unicode
632                  * chars since blender doesn't limit this */
633                 return result;
634         }
635         else {
636                 PyErr_Clear();
637
638                 if (PyBytes_Check(py_str)) {
639                         *size = PyBytes_GET_SIZE(py_str);
640                         return PyBytes_AS_STRING(py_str);
641                 }
642                 else if ((*coerce = PyUnicode_EncodeFSDefault(py_str))) {
643                         *size = PyBytes_GET_SIZE(*coerce);
644                         return PyBytes_AS_STRING(*coerce);
645                 }
646                 else {
647                         /* leave error raised from EncodeFS */
648                         return NULL;
649                 }
650         }
651 }
652
653 const char *PyC_UnicodeAsByte(PyObject *py_str, PyObject **coerce)
654 {
655         const char *result;
656
657         result = _PyUnicode_AsString(py_str);
658
659         if (result) {
660                 /* 99% of the time this is enough but we better support non unicode
661                  * chars since blender doesnt limit this */
662                 return result;
663         }
664         else {
665                 PyErr_Clear();
666
667                 if (PyBytes_Check(py_str)) {
668                         return PyBytes_AS_STRING(py_str);
669                 }
670                 else if ((*coerce = PyUnicode_EncodeFSDefault(py_str))) {
671                         return PyBytes_AS_STRING(*coerce);
672                 }
673                 else {
674                         /* leave error raised from EncodeFS */
675                         return NULL;
676                 }
677         }
678 }
679
680 PyObject *PyC_UnicodeFromByteAndSize(const char *str, Py_ssize_t size)
681 {
682         PyObject *result = PyUnicode_FromStringAndSize(str, size);
683         if (result) {
684                 /* 99% of the time this is enough but we better support non unicode
685                  * chars since blender doesn't limit this */
686                 return result;
687         }
688         else {
689                 PyErr_Clear();
690                 /* this means paths will always be accessible once converted, on all OS's */
691                 result = PyUnicode_DecodeFSDefaultAndSize(str, size);
692                 return result;
693         }
694 }
695
696 PyObject *PyC_UnicodeFromByte(const char *str)
697 {
698         return PyC_UnicodeFromByteAndSize(str, strlen(str));
699 }
700
701 /*****************************************************************************
702  * Description: This function creates a new Python dictionary object.
703  * note: dict is owned by sys.modules["__main__"] module, reference is borrowed
704  * note: important we use the dict from __main__, this is what python expects
705  * for 'pickle' to work as well as strings like this...
706  * >> foo = 10
707  * >> print(__import__("__main__").foo)
708  *
709  * note: this overwrites __main__ which gives problems with nested calls.
710  * be sure to run PyC_MainModule_Backup & PyC_MainModule_Restore if there is
711  * any chance that python is in the call stack.
712  ****************************************************************************/
713 PyObject *PyC_DefaultNameSpace(const char *filename)
714 {
715         PyInterpreterState *interp = PyThreadState_GET()->interp;
716         PyObject *mod_main = PyModule_New("__main__");
717         PyDict_SetItemString(interp->modules, "__main__", mod_main);
718         Py_DECREF(mod_main); /* sys.modules owns now */
719         PyModule_AddStringConstant(mod_main, "__name__", "__main__");
720         if (filename) {
721                 /* __file__ mainly for nice UI'ness
722                  * note: this wont map to a real file when executing text-blocks and buttons. */
723                 PyModule_AddObject(mod_main, "__file__", PyC_UnicodeFromByte(filename));
724         }
725         PyModule_AddObject(mod_main, "__builtins__", interp->builtins);
726         Py_INCREF(interp->builtins); /* AddObject steals a reference */
727         return PyModule_GetDict(mod_main);
728 }
729
730 bool PyC_NameSpace_ImportArray(PyObject *py_dict, const char *imports[])
731 {
732         for (int i = 0; imports[i]; i++) {
733                 PyObject *name = PyUnicode_FromString(imports[i]);
734                 PyObject *mod = PyImport_ImportModuleLevelObject(name, NULL, NULL, 0, 0);
735                 bool ok = false;
736                 if (mod) {
737                         PyDict_SetItem(py_dict, name, mod);
738                         ok = true;
739                         Py_DECREF(mod);
740                 }
741                 Py_DECREF(name);
742
743                 if (!ok) {
744                         return false;
745                 }
746         }
747         return true;
748 }
749
750 /* restore MUST be called after this */
751 void PyC_MainModule_Backup(PyObject **main_mod)
752 {
753         PyInterpreterState *interp = PyThreadState_GET()->interp;
754         *main_mod = PyDict_GetItemString(interp->modules, "__main__");
755         Py_XINCREF(*main_mod); /* don't free */
756 }
757
758 void PyC_MainModule_Restore(PyObject *main_mod)
759 {
760         PyInterpreterState *interp = PyThreadState_GET()->interp;
761         PyDict_SetItemString(interp->modules, "__main__", main_mod);
762         Py_XDECREF(main_mod);
763 }
764
765 /* must be called before Py_Initialize, expects output of BKE_appdir_folder_id(BLENDER_PYTHON, NULL) */
766 void PyC_SetHomePath(const char *py_path_bundle)
767 {
768         if (py_path_bundle == NULL) {
769                 /* Common enough to have bundled *nix python but complain on OSX/Win */
770 #if defined(__APPLE__) || defined(_WIN32)
771                 fprintf(stderr, "Warning! bundled python not found and is expected on this platform. "
772                         "(if you built with CMake: 'install' target may have not been built)\n");
773 #endif
774                 return;
775         }
776         /* set the environment path */
777         printf("found bundled python: %s\n", py_path_bundle);
778
779 #ifdef __APPLE__
780         /* OSX allow file/directory names to contain : character (represented as / in the Finder)
781          * but current Python lib (release 3.1.1) doesn't handle these correctly */
782         if (strchr(py_path_bundle, ':'))
783                 printf("Warning : Blender application is located in a path containing : or / chars\
784                        \nThis may make python import function fail\n");
785 #endif
786
787
788 #if 0 /* disable for now [#31506] - campbell */
789 #ifdef _WIN32
790         /* cmake/MSVC debug build crashes without this, why only
791          * in this case is unknown.. */
792         {
793                 /*BLI_setenv("PYTHONPATH", py_path_bundle)*/;
794         }
795 #endif
796 #endif
797
798         {
799                 static wchar_t py_path_bundle_wchar[1024];
800
801                 /* cant use this, on linux gives bug: #23018, TODO: try LANG="en_US.UTF-8" /usr/bin/blender, suggested 22008 */
802                 /* mbstowcs(py_path_bundle_wchar, py_path_bundle, FILE_MAXDIR); */
803
804                 BLI_strncpy_wchar_from_utf8(py_path_bundle_wchar, py_path_bundle, ARRAY_SIZE(py_path_bundle_wchar));
805
806                 Py_SetPythonHome(py_path_bundle_wchar);
807                 // printf("found python (wchar_t) '%ls'\n", py_path_bundle_wchar);
808         }
809 }
810
811 bool PyC_IsInterpreterActive(void)
812 {
813         /* instead of PyThreadState_Get, which calls Py_FatalError */
814         return (PyThreadState_GetDict() != NULL);
815 }
816
817 /* Would be nice if python had this built in
818  * See: https://wiki.blender.org/wiki/Tools/Debugging/PyFromC
819  */
820 void PyC_RunQuicky(const char *filepath, int n, ...)
821 {
822         FILE *fp = fopen(filepath, "r");
823
824         if (fp) {
825                 PyGILState_STATE gilstate = PyGILState_Ensure();
826
827                 va_list vargs;
828
829                 int *sizes = PyMem_MALLOC(sizeof(int) * (n / 2));
830                 int i;
831
832                 PyObject *py_dict = PyC_DefaultNameSpace(filepath);
833                 PyObject *values = PyList_New(n / 2); /* namespace owns this, don't free */
834
835                 PyObject *py_result, *ret;
836
837                 PyObject *struct_mod = PyImport_ImportModule("struct");
838                 PyObject *calcsize = PyObject_GetAttrString(struct_mod, "calcsize"); /* struct.calcsize */
839                 PyObject *pack = PyObject_GetAttrString(struct_mod, "pack"); /* struct.pack */
840                 PyObject *unpack = PyObject_GetAttrString(struct_mod, "unpack"); /* struct.unpack */
841
842                 Py_DECREF(struct_mod);
843
844                 va_start(vargs, n);
845                 for (i = 0; i * 2 < n; i++) {
846                         const char *format = va_arg(vargs, char *);
847                         void *ptr = va_arg(vargs, void *);
848
849                         ret = PyObject_CallFunction(calcsize, "s", format);
850
851                         if (ret) {
852                                 sizes[i] = PyLong_AsLong(ret);
853                                 Py_DECREF(ret);
854                                 ret = PyObject_CallFunction(unpack, "sy#", format, (char *)ptr, sizes[i]);
855                         }
856
857                         if (ret == NULL) {
858                                 printf("%s error, line:%d\n", __func__, __LINE__);
859                                 PyErr_Print();
860                                 PyErr_Clear();
861
862                                 PyList_SET_ITEM(values, i, Py_INCREF_RET(Py_None)); /* hold user */
863
864                                 sizes[i] = 0;
865                         }
866                         else {
867                                 if (PyTuple_GET_SIZE(ret) == 1) {
868                                         /* convenience, convert single tuples into single values */
869                                         PyObject *tmp = PyTuple_GET_ITEM(ret, 0);
870                                         Py_INCREF(tmp);
871                                         Py_DECREF(ret);
872                                         ret = tmp;
873                                 }
874
875                                 PyList_SET_ITEM(values, i, ret); /* hold user */
876                         }
877                 }
878                 va_end(vargs);
879
880                 /* set the value so we can access it */
881                 PyDict_SetItemString(py_dict, "values", values);
882                 Py_DECREF(values);
883
884                 py_result = PyRun_File(fp, filepath, Py_file_input, py_dict, py_dict);
885
886                 fclose(fp);
887
888                 if (py_result) {
889
890                         /* we could skip this but then only slice assignment would work
891                          * better not be so strict */
892                         values = PyDict_GetItemString(py_dict, "values");
893
894                         if (values && PyList_Check(values)) {
895
896                                 /* don't use the result */
897                                 Py_DECREF(py_result);
898                                 py_result = NULL;
899
900                                 /* now get the values back */
901                                 va_start(vargs, n);
902                                 for (i = 0; i * 2 < n; i++) {
903                                         const char *format = va_arg(vargs, char *);
904                                         void *ptr = va_arg(vargs, void *);
905
906                                         PyObject *item;
907                                         PyObject *item_new;
908                                         /* prepend the string formatting and remake the tuple */
909                                         item = PyList_GET_ITEM(values, i);
910                                         if (PyTuple_CheckExact(item)) {
911                                                 int ofs = PyTuple_GET_SIZE(item);
912                                                 item_new = PyTuple_New(ofs + 1);
913                                                 while (ofs--) {
914                                                         PyObject *member = PyTuple_GET_ITEM(item, ofs);
915                                                         PyTuple_SET_ITEM(item_new, ofs + 1, member);
916                                                         Py_INCREF(member);
917                                                 }
918
919                                                 PyTuple_SET_ITEM(item_new, 0, PyUnicode_FromString(format));
920                                         }
921                                         else {
922                                                 item_new = Py_BuildValue("sO", format, item);
923                                         }
924
925                                         ret = PyObject_Call(pack, item_new, NULL);
926
927                                         if (ret) {
928                                                 /* copy the bytes back into memory */
929                                                 memcpy(ptr, PyBytes_AS_STRING(ret), sizes[i]);
930                                                 Py_DECREF(ret);
931                                         }
932                                         else {
933                                                 printf("%s error on arg '%d', line:%d\n", __func__, i, __LINE__);
934                                                 PyC_ObSpit("failed converting:", item_new);
935                                                 PyErr_Print();
936                                                 PyErr_Clear();
937                                         }
938
939                                         Py_DECREF(item_new);
940                                 }
941                                 va_end(vargs);
942                         }
943                         else {
944                                 printf("%s error, 'values' not a list, line:%d\n", __func__, __LINE__);
945                         }
946                 }
947                 else {
948                         printf("%s error line:%d\n", __func__, __LINE__);
949                         PyErr_Print();
950                         PyErr_Clear();
951                 }
952
953                 Py_DECREF(calcsize);
954                 Py_DECREF(pack);
955                 Py_DECREF(unpack);
956
957                 PyMem_FREE(sizes);
958
959                 PyGILState_Release(gilstate);
960         }
961         else {
962                 fprintf(stderr, "%s: '%s' missing\n", __func__, filepath);
963         }
964 }
965
966 /* generic function to avoid depending on RNA */
967 void *PyC_RNA_AsPointer(PyObject *value, const char *type_name)
968 {
969         PyObject *as_pointer;
970         PyObject *pointer;
971
972         if (STREQ(Py_TYPE(value)->tp_name, type_name) &&
973             (as_pointer = PyObject_GetAttrString(value, "as_pointer")) != NULL &&
974             PyCallable_Check(as_pointer))
975         {
976                 void *result = NULL;
977
978                 /* must be a 'type_name' object */
979                 pointer = PyObject_CallObject(as_pointer, NULL);
980                 Py_DECREF(as_pointer);
981
982                 if (!pointer) {
983                         PyErr_SetString(PyExc_SystemError, "value.as_pointer() failed");
984                         return NULL;
985                 }
986                 result = PyLong_AsVoidPtr(pointer);
987                 Py_DECREF(pointer);
988                 if (!result) {
989                         PyErr_SetString(PyExc_SystemError, "value.as_pointer() failed");
990                 }
991
992                 return result;
993         }
994         else {
995                 PyErr_Format(PyExc_TypeError,
996                              "expected '%.200s' type found '%.200s' instead",
997                              type_name, Py_TYPE(value)->tp_name);
998                 return NULL;
999         }
1000 }
1001
1002
1003 /* PyC_FlagSet_* functions - so flags/sets can be interchanged in a generic way */
1004 #include "BLI_dynstr.h"
1005 #include "MEM_guardedalloc.h"
1006
1007 char *PyC_FlagSet_AsString(PyC_FlagSet *item)
1008 {
1009         DynStr *dynstr = BLI_dynstr_new();
1010         PyC_FlagSet *e;
1011         char *cstring;
1012
1013         for (e = item; item->identifier; item++) {
1014                 BLI_dynstr_appendf(dynstr, (e == item) ? "'%s'" : ", '%s'", item->identifier);
1015         }
1016
1017         cstring = BLI_dynstr_get_cstring(dynstr);
1018         BLI_dynstr_free(dynstr);
1019         return cstring;
1020 }
1021
1022 int PyC_FlagSet_ValueFromID_int(PyC_FlagSet *item, const char *identifier, int *r_value)
1023 {
1024         for ( ; item->identifier; item++) {
1025                 if (STREQ(item->identifier, identifier)) {
1026                         *r_value = item->value;
1027                         return 1;
1028                 }
1029         }
1030
1031         return 0;
1032 }
1033
1034 int PyC_FlagSet_ValueFromID(PyC_FlagSet *item, const char *identifier, int *r_value, const char *error_prefix)
1035 {
1036         if (PyC_FlagSet_ValueFromID_int(item, identifier, r_value) == 0) {
1037                 const char *enum_str = PyC_FlagSet_AsString(item);
1038                 PyErr_Format(PyExc_ValueError,
1039                              "%s: '%.200s' not found in (%s)",
1040                              error_prefix, identifier, enum_str);
1041                 MEM_freeN((void *)enum_str);
1042                 return -1;
1043         }
1044
1045         return 0;
1046 }
1047
1048 int PyC_FlagSet_ToBitfield(PyC_FlagSet *items, PyObject *value, int *r_value, const char *error_prefix)
1049 {
1050         /* set of enum items, concatenate all values with OR */
1051         int ret, flag = 0;
1052
1053         /* set looping */
1054         Py_ssize_t pos = 0;
1055         Py_ssize_t hash = 0;
1056         PyObject *key;
1057
1058         if (!PySet_Check(value)) {
1059                 PyErr_Format(PyExc_TypeError,
1060                              "%.200s expected a set, not %.200s",
1061                              error_prefix, Py_TYPE(value)->tp_name);
1062                 return -1;
1063         }
1064
1065         *r_value = 0;
1066
1067         while (_PySet_NextEntry(value, &pos, &key, &hash)) {
1068                 const char *param = _PyUnicode_AsString(key);
1069
1070                 if (param == NULL) {
1071                         PyErr_Format(PyExc_TypeError,
1072                                      "%.200s set must contain strings, not %.200s",
1073                                      error_prefix, Py_TYPE(key)->tp_name);
1074                         return -1;
1075                 }
1076
1077                 if (PyC_FlagSet_ValueFromID(items, param, &ret, error_prefix) < 0) {
1078                         return -1;
1079                 }
1080
1081                 flag |= ret;
1082         }
1083
1084         *r_value = flag;
1085         return 0;
1086 }
1087
1088 PyObject *PyC_FlagSet_FromBitfield(PyC_FlagSet *items, int flag)
1089 {
1090         PyObject *ret = PySet_New(NULL);
1091         PyObject *pystr;
1092
1093         for ( ; items->identifier; items++) {
1094                 if (items->value & flag) {
1095                         pystr = PyUnicode_FromString(items->identifier);
1096                         PySet_Add(ret, pystr);
1097                         Py_DECREF(pystr);
1098                 }
1099         }
1100
1101         return ret;
1102 }
1103
1104
1105 /**
1106  * \return success
1107  *
1108  * \note it is caller's responsibility to acquire & release GIL!
1109  */
1110 bool PyC_RunString_AsNumber(const char *imports[], const char *expr, const char *filename, double *r_value)
1111 {
1112         PyObject *py_dict, *mod, *retval;
1113         bool ok = true;
1114         PyObject *main_mod = NULL;
1115
1116         PyC_MainModule_Backup(&main_mod);
1117
1118         py_dict = PyC_DefaultNameSpace(filename);
1119
1120         mod = PyImport_ImportModule("math");
1121         if (mod) {
1122                 PyDict_Merge(py_dict, PyModule_GetDict(mod), 0); /* 0 - don't overwrite existing values */
1123                 Py_DECREF(mod);
1124         }
1125         else { /* highly unlikely but possibly */
1126                 PyErr_Print();
1127                 PyErr_Clear();
1128         }
1129
1130         if (imports && (!PyC_NameSpace_ImportArray(py_dict, imports))) {
1131                 ok = false;
1132         }
1133         else if ((retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict)) == NULL) {
1134                 ok = false;
1135         }
1136         else {
1137                 double val;
1138
1139                 if (PyTuple_Check(retval)) {
1140                         /* Users my have typed in 10km, 2m
1141                          * add up all values */
1142                         int i;
1143                         val = 0.0;
1144
1145                         for (i = 0; i < PyTuple_GET_SIZE(retval); i++) {
1146                                 const double val_item = PyFloat_AsDouble(PyTuple_GET_ITEM(retval, i));
1147                                 if (val_item == -1 && PyErr_Occurred()) {
1148                                         val = -1;
1149                                         break;
1150                                 }
1151                                 val += val_item;
1152                         }
1153                 }
1154                 else {
1155                         val = PyFloat_AsDouble(retval);
1156                 }
1157                 Py_DECREF(retval);
1158
1159                 if (val == -1 && PyErr_Occurred()) {
1160                         ok = false;
1161                 }
1162                 else if (!isfinite(val)) {
1163                         *r_value = 0.0;
1164                 }
1165                 else {
1166                         *r_value = val;
1167                 }
1168         }
1169
1170         PyC_MainModule_Restore(main_mod);
1171
1172         return ok;
1173 }
1174
1175 bool PyC_RunString_AsIntPtr(const char *imports[], const char *expr, const char *filename, intptr_t *r_value)
1176 {
1177         PyObject *py_dict, *retval;
1178         bool ok = true;
1179         PyObject *main_mod = NULL;
1180
1181         PyC_MainModule_Backup(&main_mod);
1182
1183         py_dict = PyC_DefaultNameSpace(filename);
1184
1185         if (imports && (!PyC_NameSpace_ImportArray(py_dict, imports))) {
1186                 ok = false;
1187         }
1188         else if ((retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict)) == NULL) {
1189                 ok = false;
1190         }
1191         else {
1192                 intptr_t val;
1193
1194                 val = (intptr_t)PyLong_AsVoidPtr(retval);
1195                 if (val == 0 && PyErr_Occurred()) {
1196                         ok = false;
1197                 }
1198                 else {
1199                         *r_value = val;
1200                 }
1201
1202                 Py_DECREF(retval);
1203         }
1204
1205         PyC_MainModule_Restore(main_mod);
1206
1207         return ok;
1208 }
1209
1210 bool PyC_RunString_AsString(const char *imports[], const char *expr, const char *filename, char **r_value)
1211 {
1212         PyObject *py_dict, *retval;
1213         bool ok = true;
1214         PyObject *main_mod = NULL;
1215
1216         PyC_MainModule_Backup(&main_mod);
1217
1218         py_dict = PyC_DefaultNameSpace(filename);
1219
1220         if (imports && (!PyC_NameSpace_ImportArray(py_dict, imports))) {
1221                 ok = false;
1222         }
1223         else if ((retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict)) == NULL) {
1224                 ok = false;
1225         }
1226         else {
1227                 const char *val;
1228                 Py_ssize_t val_len;
1229
1230                 val = _PyUnicode_AsStringAndSize(retval, &val_len);
1231                 if (val == NULL && PyErr_Occurred()) {
1232                         ok = false;
1233                 }
1234                 else {
1235                         char *val_alloc = MEM_mallocN(val_len + 1, __func__);
1236                         memcpy(val_alloc, val, val_len + 1);
1237                         *r_value = val_alloc;
1238                 }
1239
1240                 Py_DECREF(retval);
1241         }
1242
1243         PyC_MainModule_Restore(main_mod);
1244
1245         return ok;
1246 }
1247
1248 #endif  /* #ifndef MATH_STANDALONE */
1249
1250 /* -------------------------------------------------------------------- */
1251 /** \name Int Conversion
1252  *
1253  * \note Python doesn't provide overflow checks for specific bit-widths.
1254  *
1255  * \{ */
1256
1257 /* Compiler optimizes out redundant checks. */
1258 #ifdef __GNUC__
1259 #  pragma warning(push)
1260 #  pragma GCC diagnostic ignored "-Wtype-limits"
1261 #endif
1262
1263 /**
1264  * Don't use `bool` return type, so -1 can be used as an error value.
1265  */
1266 int PyC_Long_AsBool(PyObject *value)
1267 {
1268         int test = _PyLong_AsInt(value);
1269         if (UNLIKELY((uint)test > 1)) {
1270                 PyErr_SetString(PyExc_TypeError,
1271                                 "Python number not a bool (0/1)");
1272                 return -1;
1273         }
1274         return test;
1275 }
1276
1277 int8_t PyC_Long_AsI8(PyObject *value)
1278 {
1279         int test = _PyLong_AsInt(value);
1280         if (UNLIKELY(test < INT8_MIN || test > INT8_MAX)) {
1281                 PyErr_SetString(PyExc_OverflowError,
1282                                 "Python int too large to convert to C int8");
1283                 return -1;
1284         }
1285         return (int8_t)test;
1286 }
1287
1288 int16_t PyC_Long_AsI16(PyObject *value)
1289 {
1290         int test = _PyLong_AsInt(value);
1291         if (UNLIKELY(test < INT16_MIN || test > INT16_MAX)) {
1292                 PyErr_SetString(PyExc_OverflowError,
1293                                 "Python int too large to convert to C int16");
1294                 return -1;
1295         }
1296         return (int16_t)test;
1297 }
1298
1299 /* Inlined in header:
1300  * PyC_Long_AsI32
1301  * PyC_Long_AsI64
1302  */
1303
1304 uint8_t PyC_Long_AsU8(PyObject *value)
1305 {
1306         ulong test = PyLong_AsUnsignedLong(value);
1307         if (UNLIKELY(test > UINT8_MAX)) {
1308                 PyErr_SetString(PyExc_OverflowError,
1309                                 "Python int too large to convert to C uint8");
1310                 return (uint8_t)-1;
1311         }
1312         return (uint8_t)test;
1313 }
1314
1315 uint16_t PyC_Long_AsU16(PyObject *value)
1316 {
1317         ulong test = PyLong_AsUnsignedLong(value);
1318         if (UNLIKELY(test > UINT16_MAX)) {
1319                 PyErr_SetString(PyExc_OverflowError,
1320                                 "Python int too large to convert to C uint16");
1321                 return (uint16_t)-1;
1322         }
1323         return (uint16_t)test;
1324 }
1325
1326 uint32_t PyC_Long_AsU32(PyObject *value)
1327 {
1328         ulong test = PyLong_AsUnsignedLong(value);
1329         if (UNLIKELY(test > UINT32_MAX)) {
1330                 PyErr_SetString(PyExc_OverflowError,
1331                                 "Python int too large to convert to C uint32");
1332                 return (uint32_t)-1;
1333         }
1334         return (uint32_t)test;
1335 }
1336
1337 /* Inlined in header:
1338  * PyC_Long_AsU64
1339  */
1340
1341 /* -------------------------------------------------------------------- */
1342 /** \name Py_buffer Utils
1343  *
1344  * \{ */
1345
1346 char PyC_StructFmt_type_from_str(const char *typestr)
1347 {
1348         switch (typestr[0]) {
1349                 case '!':
1350                 case '<':
1351                 case '=':
1352                 case '>':
1353                 case '@':
1354                         return typestr[1];
1355                 default:
1356                         return typestr[0];
1357         }
1358 }
1359
1360 bool PyC_StructFmt_type_is_float_any(char format)
1361 {
1362         switch (format) {
1363                 case 'f':
1364                 case 'd':
1365                 case 'e':
1366                         return true;
1367                 default:
1368                         return false;
1369         }
1370 }
1371
1372 bool PyC_StructFmt_type_is_int_any(char format)
1373 {
1374         switch (format) {
1375                 case 'i':
1376                 case 'I':
1377                 case 'l':
1378                 case 'L':
1379                 case 'h':
1380                 case 'H':
1381                 case 'b':
1382                 case 'B':
1383                 case 'q':
1384                 case 'Q':
1385                 case 'n':
1386                 case 'N':
1387                 case 'P':
1388                         return true;
1389                 default:
1390                         return false;
1391         }
1392 }
1393
1394 bool PyC_StructFmt_type_is_byte(char format)
1395 {
1396         switch (format) {
1397                 case 'c':
1398                 case 's':
1399                 case 'p':
1400                         return true;
1401                 default:
1402                         return false;
1403         }
1404 }
1405
1406 bool PyC_StructFmt_type_is_bool(char format)
1407 {
1408         switch (format) {
1409                 case '?':
1410                         return true;
1411                 default:
1412                         return false;
1413         }
1414 }
1415
1416 /** \} */
1417
1418 #ifdef __GNUC__
1419 #  pragma warning(pop)
1420 #endif
1421
1422 /** \} */