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