13#define PY_SSIZE_T_CLEAN
16#include <frameobject.h>
26#ifndef MATH_STANDALONE
43 const size_t array_item_size,
46 const PyTypeObject *type,
47 const char *error_prefix)
49 const Py_ssize_t value_len = PySequence_Fast_GET_SIZE(value_fast);
50 PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
53 BLI_assert(PyList_Check(value_fast) || PyTuple_Check(value_fast));
56 PyErr_Format(PyExc_TypeError,
57 "%.200s: invalid sequence length. expected %d, got %d",
65 if (type == &PyFloat_Type) {
66 switch (array_item_size) {
67 case sizeof(double): {
68 double *array_double =
static_cast<double *
>(
array);
69 for (i = 0; i <
length; i++) {
70 array_double[i] = PyFloat_AsDouble(value_fast_items[i]);
75 float *array_float =
static_cast<float *
>(
array);
76 for (i = 0; i <
length; i++) {
77 array_float[i] = PyFloat_AsDouble(value_fast_items[i]);
87 else if (type == &PyLong_Type) {
88 switch (array_item_size) {
91 for (i = 0; i <
length; i++) {
92 array_int[i] = PyC_Long_AsI64(value_fast_items[i]);
98 for (i = 0; i <
length; i++) {
99 array_int[i] = PyC_Long_AsI32(value_fast_items[i]);
105 for (i = 0; i <
length; i++) {
112 for (i = 0; i <
length; i++) {
123 else if (type == &PyBool_Type) {
124 switch (array_item_size) {
127 for (i = 0; i <
length; i++) {
128 array_bool[i] = (PyLong_AsLong(value_fast_items[i]) != 0);
134 for (i = 0; i <
length; i++) {
135 array_bool[i] = (PyLong_AsLong(value_fast_items[i]) != 0);
141 for (i = 0; i <
length; i++) {
142 array_bool[i] = (PyLong_AsLong(value_fast_items[i]) != 0);
148 for (i = 0; i <
length; i++) {
149 array_bool[i] = (PyLong_AsLong(value_fast_items[i]) != 0);
160 PyErr_Format(PyExc_TypeError,
"%s: internal error %s is invalid", error_prefix, type->tp_name);
164 if (PyErr_Occurred()) {
165 PyErr_Format(PyExc_TypeError,
166 "%s: one or more items could not be used as a %s",
176 const size_t array_item_size,
179 const PyTypeObject *type,
180 const char *error_prefix)
182 PyObject *value_fast;
185 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
190 Py_DECREF(value_fast);
195 const size_t array_item_size,
199 const PyTypeObject *type,
200 const char *error_prefix);
203 const size_t array_item_size,
204 PyObject *value_fast,
207 const PyTypeObject *type,
208 const char *error_prefix)
210 const Py_ssize_t value_len = PySequence_Fast_GET_SIZE(value_fast);
211 const int length = dims[0];
221 if (value_len !=
length) {
222 PyErr_Format(PyExc_TypeError,
223 "%.200s: invalid sequence length. expected %d, got %d",
230 PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
231 const int *dims_next = dims + 1;
232 const int dims_next_len = dims_len - 1;
234 for (
int i = 0; i <
length; i++) {
251 const size_t array_item_size,
255 const PyTypeObject *type,
256 const char *error_prefix)
258 PyObject *value_fast;
261 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
266 array_p, array_item_size, value_fast, dims, dims_len, type, error_prefix);
267 Py_DECREF(value_fast);
272 const size_t array_item_size,
273 PyObject *value_fast,
276 const PyTypeObject *type,
277 const char *error_prefix)
280 &
array, array_item_size, value_fast, dims, dims_len, type, error_prefix);
284 const size_t array_item_size,
288 const PyTypeObject *type,
289 const char *error_prefix)
292 &
array, array_item_size, value, dims, dims_len, type, error_prefix);
305 PyObject *tuple = PyTuple_New(
len);
306 for (
uint i = 0; i <
len; i++) {
307 PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(
array[i]));
314 PyObject *tuple = PyTuple_New(
len);
315 for (
uint i = 0; i <
len; i++) {
316 PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(
array[i]));
323 PyObject *tuple = PyTuple_New(
len);
324 for (
uint i = 0; i <
len; i++) {
325 PyTuple_SET_ITEM(tuple, i, PyLong_FromLong(
array[i]));
332 PyObject *tuple = PyTuple_New(
len);
333 for (
uint i = 0; i <
len; i++) {
334 PyTuple_SET_ITEM(tuple, i, PyBool_FromLong(
array[i]));
341 PyObject *tuple = PyTuple_New(
len);
342 for (
uint i = 0; i <
len; i++) {
343 PyTuple_SET_ITEM(tuple, i, PyBool_FromLong(
array[i]));
351 PyObject *tuple = PyTuple_New(
len);
352 for (
uint i = 0; i <
len; i++) {
353 if (PyObject *value = PyUnicode_FromString(
array[i])) {
354 PyTuple_SET_ITEM(tuple, i, value);
375 const int len = dims[0];
378 *array_p = (*array_p) +
len;
381 PyObject *tuple = PyTuple_New(dims[0]);
382 const int *dims_next = dims + 1;
383 const int dims_next_len = dims_len - 1;
384 for (
uint i = 0; i <
len; i++) {
399 const int len = dims[0];
402 *array_p = (*array_p) +
len;
405 PyObject *tuple = PyTuple_New(dims[0]);
406 const int *dims_next = dims + 1;
407 const int dims_next_len = dims_len - 1;
408 for (
uint i = 0; i <
len; i++) {
423 const int len = dims[0];
426 *array_p = (*array_p) +
len;
429 PyObject *tuple = PyTuple_New(dims[0]);
430 const int *dims_next = dims + 1;
431 const int dims_next_len = dims_len - 1;
432 for (
uint i = 0; i <
len; i++) {
447 const int len = dims[0];
450 *array_p = (*array_p) +
len;
453 PyObject *tuple = PyTuple_New(dims[0]);
454 const int *dims_next = dims + 1;
455 const int dims_next_len = dims_len - 1;
456 for (
uint i = 0; i <
len; i++) {
475 const uint tot = PyTuple_GET_SIZE(tuple);
478 for (i = 0; i < tot; i++) {
479 PyTuple_SET_ITEM(tuple, i, value);
486 const uint tot = PyList_GET_SIZE(
list);
489 for (i = 0; i < tot; i++) {
490 PyList_SET_ITEM(
list, i, value);
503 bool *bool_p =
static_cast<bool *
>(p);
505 if (((value = PyLong_AsLong(o)) == -1) || !
ELEM(value, 0, 1)) {
506 PyErr_Format(PyExc_ValueError,
"expected a bool or int (0/1), got %s", Py_TYPE(o)->tp_name);
510 *bool_p = value ?
true :
false;
518 *
data->value_p =
nullptr;
521 if (!PyObject_TypeCheck(o,
data->type)) {
522 PyErr_Format(PyExc_TypeError,
523 "expected %.200s or None, not %.200s",
525 Py_TYPE(o)->tp_name);
534 std::optional<int> *value_p =
static_cast<std::optional<int> *
>(p);
539 const int value = PyC_Long_AsI32(o);
540 if (value == -1 && PyErr_Occurred()) {
549 std::optional<double> *value_p =
static_cast<std::optional<double> *
>(p);
554 const double value = PyFloat_AsDouble(o);
555 if (value == -1.0 && PyErr_Occurred()) {
564 std::optional<float> *value_p =
static_cast<std::optional<float> *
>(p);
569 const double value = PyFloat_AsDouble(o);
570 if (value == -1.0 && PyErr_Occurred()) {
573 *value_p =
float(value);
579 std::optional<uint> *value_p =
static_cast<std::optional<uint> *
>(p);
585 if (value ==
uint(-1) && PyErr_Occurred()) {
594 std::optional<bool> *value_p =
static_cast<std::optional<bool> *
>(p);
600 if (((value = PyLong_AsLong(o)) == -1) || !
ELEM(value, 0, 1)) {
602 PyExc_ValueError,
"expected a bool, int (0/1), or None, got %s", Py_TYPE(o)->tp_name);
605 *value_p = value ?
true :
false;
611 rcti *rect =
static_cast<rcti *
>(p);
612 if (!PyArg_ParseTuple(o,
628 std::optional<rcti> *value_p =
static_cast<std::optional<rcti> *
>(p);
644 const char *value = PyUnicode_AsUTF8(o);
645 if (value ==
nullptr) {
646 PyErr_Format(PyExc_ValueError,
"expected a string, got %s", Py_TYPE(o)->tp_name);
650 for (i = 0;
e->items[i].id; i++) {
651 if (
STREQ(
e->items[i].id, value)) {
652 e->value_found =
e->items[i].value;
660 PyObject *enum_items = PyTuple_New(i);
661 for (i = 0;
e->items[i].id; i++) {
662 PyTuple_SET_ITEM(enum_items, i, PyUnicode_FromString(
e->items[i].id));
664 PyErr_Format(PyExc_ValueError,
"expected a string in %S, got '%s'", enum_items, value);
665 Py_DECREF(enum_items);
671 for (
int i = 0; items[i].
id; i++) {
672 if (items[i].value == value) {
681 PyObject *dummy_pydict;
682 return PyArg_ParseTuple(args,
692#ifndef MATH_STANDALONE
702 const char *null_str =
"<null>";
703 fprintf(stderr,
"<%s> : ", name);
704 if (var ==
nullptr) {
705 fprintf(stderr,
"%s\n", null_str);
708 PyObject_Print(var, stderr, 0);
709 const PyTypeObject *type = Py_TYPE(var);
711 " ref:%d, ptr:%p, type: %s\n",
713 static_cast<void *
>(var),
714 type ? type->tp_name : null_str);
721 const char *null_str =
"<null>";
722 if (var ==
nullptr) {
726 const PyTypeObject *type = Py_TYPE(var);
727 PyObject *var_str = PyObject_Repr(var);
728 if (var_str ==
nullptr) {
735 " ref=%d, ptr=%p, type=%s, value=%.200s",
737 static_cast<void *
>(var),
738 type ? type->tp_name : null_str,
739 var_str ? PyUnicode_AsUTF8(var_str) :
"<error>");
740 if (var_str !=
nullptr) {
754 fprintf(stderr,
"Python line lookup failed, interpreter inactive\n");
761 fprintf(stderr,
"%s:%d\n",
filename, lineno);
768 fprintf(stderr,
"Python line lookup failed, interpreter inactive\n");
773 const PyGILState_STATE gilstate = PyGILState_Ensure();
774 PyRun_SimpleString(
"__import__('traceback').print_stack()");
775 PyGILState_Release(gilstate);
786 PyFrameObject *frame;
790 *r_filename =
nullptr;
796 if (!(frame = PyEval_GetFrame())) {
799 if (!(code = PyFrame_GetCode(frame))) {
805 *r_filename = PyUnicode_AsUTF8(code->co_filename);
809 if (r_filename && *r_filename ==
nullptr) {
812 PyObject *mod_name = PyDict_GetItemString(PyEval_GetGlobals(),
"__name__");
814 PyObject *
mod = PyDict_GetItem(PyImport_GetModuleDict(), mod_name);
816 PyObject *mod_file = PyModule_GetFilenameObject(
mod);
818 *r_filename = PyUnicode_AsUTF8(mod_name);
827 if (*r_filename ==
nullptr) {
828 *r_filename = PyUnicode_AsUTF8(mod_name);
834 *r_lineno = PyFrame_GetLineNumber(frame);
860 ret = PyFrozenSet_New(
nullptr);
863 PyObject *py_str = PyUnicode_FromString(*
str);
864 PySet_Add(
ret, py_str);
879 PyObject *error_value_as_unicode =
nullptr;
881 if (PyErr_Occurred()) {
882 PyObject *error_type, *error_value, *error_traceback;
883 PyErr_Fetch(&error_type, &error_value, &error_traceback);
885 if (PyUnicode_Check(error_value)) {
886 error_value_as_unicode = error_value;
887 Py_INCREF(error_value_as_unicode);
890 error_value_as_unicode = PyUnicode_FromFormat(
891 "%.200s(%S)", Py_TYPE(error_value)->tp_name, error_value);
893 PyErr_Restore(error_type, error_value, error_traceback);
898 va_start(args, format);
899 PyObject *error_value_format = PyUnicode_FromFormatV(format, args);
902 if (error_value_as_unicode) {
903 if (error_value_format) {
904 PyObject *error_value_format_prev = error_value_format;
905 error_value_format = PyUnicode_FromFormat(
906 "%S, %S", error_value_format, error_value_as_unicode);
907 Py_DECREF(error_value_format_prev);
911 error_value_format = PyUnicode_FromFormat(
"(internal error), %S", error_value_as_unicode);
913 Py_DECREF(error_value_as_unicode);
916 PyErr_SetObject(exception_type_prefix, error_value_format);
917 Py_XDECREF(error_value_format);
931 PyCodeObject *f_code =
reinterpret_cast<PyCodeObject *
>(PyFunction_GET_CODE(py_func));
936 "File \"%s\", line %d, in %s\n",
937 PyUnicode_AsUTF8(f_code->co_filename),
938 f_code->co_firstlineno,
939 PyUnicode_AsUTF8((
reinterpret_cast<PyFunctionObject *
>(py_func))->func_name));
959 if (!PyErr_ExceptionMatches(PyExc_SystemExit)) {
964 PyObject *exc_obj = PyErr_GetRaisedException();
965 PyObject *code_obj = ((PySystemExitObject *)exc_obj)->code;
967 if (code_obj && code_obj != Py_None) {
970 PyErr_SetRaisedException(exc_obj);
997 if (_Py_GetConfig()->inspect) {
1025 PyObject *
result =
nullptr;
1027 PyObject *error_type, *error_value, *error_traceback;
1028 PyErr_Fetch(&error_type, &error_value, &error_traceback);
1032 PyErr_NormalizeException(&error_type, &error_value, &error_traceback);
1035 PyObject *string_io =
nullptr;
1036 PyObject *string_io_mod =
nullptr;
1037 PyObject *string_io_getvalue =
nullptr;
1038 if ((string_io_mod = PyImport_ImportModule(
"io")) &&
1039 (string_io = PyObject_CallMethod(string_io_mod,
"StringIO",
nullptr)) &&
1040 (string_io_getvalue = PyObject_GetAttrString(string_io,
"getvalue")))
1042 PyObject *stderr_backup = PySys_GetObject(
"stderr");
1044 Py_INCREF(stderr_backup);
1045 PySys_SetObject(
"stderr", string_io);
1047 PyErr_Display(error_type, error_value, error_traceback);
1049 result = PyObject_CallObject(string_io_getvalue,
nullptr);
1050 PySys_SetObject(
"stderr", stderr_backup);
1051 Py_DECREF(stderr_backup);
1054 PySys_WriteStderr(
"Internal error creating: io.StringIO()!\n");
1055 if (PyErr_Occurred()) [[unlikely]] {
1058 PyErr_Display(error_type, error_value, error_traceback);
1061 Py_XDECREF(string_io_mod);
1062 Py_XDECREF(string_io_getvalue);
1063 Py_XDECREF(string_io);
1066 result = PyObject_Str(error_value);
1068 if (
result ==
nullptr) [[unlikely]] {
1069 result = PyUnicode_FromFormat(
"<unprintable %s object>", Py_TYPE(error_value)->tp_name);
1073 PyErr_Restore(error_type, error_value, error_traceback);
1085 PyObject *
result =
nullptr;
1087 PyObject *error_type, *error_value, *error_traceback;
1089 PyErr_Fetch(&error_type, &error_value, &error_traceback);
1091 if (PyErr_GivenExceptionMatches(error_type, PyExc_SyntaxError)) {
1095 if (PyTuple_CheckExact(error_value) && PyTuple_GET_SIZE(error_value) >= 1) {
1096 result = PyObject_Str(PyTuple_GET_ITEM(error_value, 0));
1101 result = PyObject_Str(error_value);
1103 if (
result ==
nullptr) [[unlikely]] {
1104 result = PyUnicode_FromFormat(
"<unprintable %s object>", Py_TYPE(error_value)->tp_name);
1108 PyErr_Restore(error_type, error_value, error_traceback);
1125 result = PyUnicode_AsUTF8AndSize(py_str, r_size);
1135 if (PyBytes_Check(py_str)) {
1136 *r_size = PyBytes_GET_SIZE(py_str);
1137 return PyBytes_AS_STRING(py_str);
1139 if ((*r_coerce = PyUnicode_EncodeFSDefault(py_str))) {
1140 *r_size = PyBytes_GET_SIZE(*r_coerce);
1141 return PyBytes_AS_STRING(*r_coerce);
1152 result = PyUnicode_AsUTF8(py_str);
1162 if (PyBytes_Check(py_str)) {
1163 return PyBytes_AS_STRING(py_str);
1165 if ((*r_coerce = PyUnicode_EncodeFSDefault(py_str))) {
1166 return PyBytes_AS_STRING(*r_coerce);
1175 PyObject *
result = PyUnicode_FromStringAndSize(
str, size);
1184 result = PyUnicode_DecodeFSDefaultAndSize(
str, size);
1201 if (o ==
nullptr) [[unlikely]] {
1203 Py_CLEAR(
data->value_coerce);
1209 if (
data->value ==
nullptr) {
1214 return data->value_coerce ? Py_CLEANUP_SUPPORTED : 1;
1236 PyObject *modules = PyImport_GetModuleDict();
1237 PyObject *builtins = PyEval_GetBuiltins();
1238 PyObject *mod_main = PyModule_New(
"__main__");
1239 PyDict_SetItemString(modules,
"__main__", mod_main);
1240 Py_DECREF(mod_main);
1241 PyModule_AddStringConstant(mod_main,
"__name__",
"__main__");
1247 PyModule_AddObjectRef(mod_main,
"__builtins__", builtins);
1249 return PyModule_GetDict(mod_main);
1254 for (
int i = 0; imports[i]; i++) {
1255 PyObject *name = PyUnicode_FromString(imports[i]);
1256 PyObject *
mod = PyImport_ImportModuleLevelObject(name,
nullptr,
nullptr,
nullptr, 0);
1259 PyDict_SetItem(py_dict, name,
mod);
1274 PyObject *modules = PyImport_GetModuleDict();
1275 PyObject *main_mod = PyDict_GetItemString(modules,
"__main__");
1279 Py_INCREF(main_mod);
1286 PyObject *modules = PyImport_GetModuleDict();
1288 PyDict_SetItemString(modules,
"__main__", main_mod);
1289 Py_DECREF(main_mod);
1292 PyDict_DelItemString(modules,
"__main__");
1300 BLI_assert(sys_modules == PyImport_GetModuleDict());
1301 PyObject *name = PyModule_GetNameObject(module);
1302 if (name ==
nullptr) {
1305 int result = PyDict_SetItem(sys_modules, name, module);
1313 return (PyThreadState_GetDict() !=
nullptr);
1327 FILE *fp = fopen(filepath,
"r");
1330 const PyGILState_STATE gilstate = PyGILState_Ensure();
1334 Py_ssize_t *sizes =
static_cast<Py_ssize_t *
>(PyMem_MALLOC(
sizeof(*sizes) * (n / 2)));
1338 PyObject *values = PyList_New(n / 2);
1340 PyObject *py_result, *
ret;
1342 PyObject *struct_mod = PyImport_ImportModule(
"struct");
1343 PyObject *calcsize = PyObject_GetAttrString(struct_mod,
"calcsize");
1344 PyObject *pack = PyObject_GetAttrString(struct_mod,
"pack");
1345 PyObject *unpack = PyObject_GetAttrString(struct_mod,
"unpack");
1347 Py_DECREF(struct_mod);
1350 for (i = 0; i * 2 < n; i++) {
1351 const char *format = va_arg(vargs,
char *);
1352 void *ptr = va_arg(vargs,
void *);
1354 ret = PyObject_CallFunction(calcsize,
"s", format);
1357 sizes[i] = PyLong_AsLong(
ret);
1359 ret = PyObject_CallFunction(unpack,
"sy#", format,
static_cast<char *
>(ptr), sizes[i]);
1362 if (
ret ==
nullptr) {
1363 printf(
"%s error, line:%d\n", __func__, __LINE__);
1366 PyList_SET_ITEM(values, i, Py_NewRef(Py_None));
1371 if (PyTuple_GET_SIZE(
ret) == 1) {
1373 PyObject *tmp = PyTuple_GET_ITEM(
ret, 0);
1379 PyList_SET_ITEM(values, i,
ret);
1385 PyDict_SetItemString(py_dict,
"values", values);
1388 py_result = PyRun_File(fp, filepath, Py_file_input, py_dict, py_dict);
1394 Py_DECREF(py_result);
1395 py_result =
nullptr;
1399 values = PyDict_GetItemString(py_dict,
"values");
1401 if (values && PyList_Check(values)) {
1405 for (i = 0; i * 2 < n; i++) {
1406 const char *format = va_arg(vargs,
char *);
1407 void *ptr = va_arg(vargs,
void *);
1412 item = PyList_GET_ITEM(values, i);
1413 if (PyTuple_CheckExact(item)) {
1414 int ofs = PyTuple_GET_SIZE(item);
1415 item_new = PyTuple_New(ofs + 1);
1417 PyObject *member = PyTuple_GET_ITEM(item, ofs);
1418 PyTuple_SET_ITEM(item_new, ofs + 1, member);
1422 PyTuple_SET_ITEM(item_new, 0, PyUnicode_FromString(format));
1425 item_new = Py_BuildValue(
"sO", format, item);
1428 ret = PyObject_Call(pack, item_new,
nullptr);
1432 memcpy(ptr, PyBytes_AS_STRING(
ret), sizes[i]);
1436 printf(
"%s error on arg '%d', line:%d\n", __func__, i, __LINE__);
1441 Py_DECREF(item_new);
1446 printf(
"%s error, 'values' not a list, line:%d\n", __func__, __LINE__);
1450 printf(
"%s error line:%d\n", __func__, __LINE__);
1454 Py_DECREF(calcsize);
1460 PyGILState_Release(gilstate);
1463 fprintf(stderr,
"%s: '%s' missing\n", __func__, filepath);
1469 if (!
STREQ(Py_TYPE(value)->tp_name, type_name)) {
1470 PyErr_Format(PyExc_TypeError,
1471 "expected '%.200s' type found '%.200s' instead",
1473 Py_TYPE(value)->tp_name);
1477 PyObject *as_pointer = PyObject_GetAttrString(value,
"as_pointer");
1478 if ((as_pointer ==
nullptr) || !PyCallable_Check(as_pointer)) {
1479 Py_XDECREF(as_pointer);
1480 PyErr_Format(PyExc_TypeError,
"Invalid %.200s pointer", type_name);
1485 PyObject *pointer = PyObject_CallObject(as_pointer,
nullptr);
1486 Py_DECREF(as_pointer);
1488 if (pointer ==
nullptr) {
1489 PyErr_SetString(PyExc_SystemError,
"value.as_pointer() failed");
1492 void *
result = PyLong_AsVoidPtr(pointer);
1495 PyErr_SetString(PyExc_SystemError,
"value.as_pointer() failed");
1511 PyObject *py_items = PyList_New(0);
1513 PyList_APPEND(py_items, PyUnicode_FromString(item->
identifier));
1515 PyObject *py_string = PyObject_Repr(py_items);
1516 Py_DECREF(py_items);
1524 *r_value = item->
value;
1533 const char *identifier,
1535 const char *error_prefix)
1540 PyExc_ValueError,
"%s: '%.200s' not found in (%U)", error_prefix, identifier, enum_str);
1541 Py_DECREF(enum_str);
1551 const char *error_prefix)
1556 if (!PySet_Check(value)) {
1557 PyErr_Format(PyExc_TypeError,
1558 "%.200s expected a set, not %.200s",
1560 Py_TYPE(value)->tp_name);
1566 if (PySet_GET_SIZE(value) > 0) {
1567 PyObject *it = PyObject_GetIter(value);
1569 while ((key = PyIter_Next(it))) {
1573 const char *param = PyUnicode_AsUTF8(key);
1574 if (param ==
nullptr) {
1575 PyErr_Format(PyExc_TypeError,
1576 "%.200s set must contain strings, not %.200s",
1578 Py_TYPE(key)->tp_name);
1589 if (key !=
nullptr) {
1600 PyObject *
ret = PySet_New(
nullptr);
1604 if (items->
value & flag) {
1605 pystr = PyUnicode_FromString(items->
identifier);
1606 PySet_Add(
ret, pystr);
1621 const char *imports_star[],
1626 const char *imports_star[],
1635 for (
int i = 0; imports_star[i]; i++) {
1636 PyObject *
mod = PyImport_ImportModule(imports_star[i]);
1639 PyDict_Merge(py_dict, PyModule_GetDict(
mod), 0);
1653 retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict);
1667 const char *imports_star[] = {
"math",
nullptr};
1671 if (PyTuple_Check(retval)) {
1674 for (
int i = 0; i < PyTuple_GET_SIZE(retval); i++) {
1675 const double val_item = PyFloat_AsDouble(PyTuple_GET_ITEM(retval, i));
1676 if (val_item == -1 && PyErr_Occurred()) {
1684 val = PyFloat_AsDouble(retval);
1688 if (val == -1 && PyErr_Occurred()) {
1691 else if (!isfinite(val)) {
1715 if (val == 0 && PyErr_Occurred()) {
1736 size_t *r_value_size)
1741 const char *val = PyUnicode_AsUTF8AndSize(retval, &val_len);
1742 if (val ==
nullptr && PyErr_Occurred()) {
1747 memcpy(val_alloc, val, (
size_t(val_len) + 1) *
sizeof(*val_alloc));
1748 *r_value = val_alloc;
1749 *r_value_size = val_len;
1774 size_t *r_value_size)
1778 if (retval == Py_None) {
1785 const char *val = PyUnicode_AsUTF8AndSize(retval, &val_len);
1786 if (val ==
nullptr && PyErr_Occurred()) {
1791 memcpy(val_alloc, val, (
size_t(val_len) + 1) *
sizeof(*val_alloc));
1792 *r_value = val_alloc;
1793 *r_value_size = val_len;
1838 PyObject *py_flush = PyUnicode_FromString(
"flush");
1840 for (
const char *name : {
"stdout",
"stderr"}) {
1841 PyObject *py_file = PySys_GetObject(name);
1846 PyObject *py_flush_retval = PyObject_CallMethodNoArgs(py_file, py_flush);
1847 if (py_flush_retval) {
1848 Py_DECREF(py_flush_retval);
1854 Py_DECREF(py_flush);
1867#if defined(__GNUC__) && !defined(__clang__)
1868# pragma GCC diagnostic push
1869# pragma GCC diagnostic ignored "-Wtype-limits"
1879 if (value ==
nullptr) {
1881 return PyLong_AsUnsignedLong(value);
1884 if (PyLong_Check(value)) {
1885 return PyLong_AsUnsignedLong(value);
1889 PyObject *value_converted = PyNumber_Index(value);
1890 if (value_converted ==
nullptr) {
1894 ulong to_return = PyLong_AsUnsignedLong(value_converted);
1895 Py_DECREF(value_converted);
1901 const int test = PyLong_AsInt(value);
1902 if (test == -1 && PyErr_Occurred()) [[unlikely]] {
1905 if (
uint(test) > 1) [[unlikely]] {
1906 PyErr_SetString(PyExc_TypeError,
"Python number not a bool (0/1)");
1914 const int test = PyLong_AsInt(value);
1915 if (test == -1 && PyErr_Occurred()) [[unlikely]] {
1918 if (test < INT8_MIN || test >
INT8_MAX) [[unlikely]] {
1919 PyErr_SetString(PyExc_OverflowError,
"Python int too large to convert to C int8");
1927 const int test = PyLong_AsInt(value);
1928 if (test == -1 && PyErr_Occurred()) [[unlikely]] {
1931 if (test < INT16_MIN || test >
INT16_MAX) [[unlikely]] {
1932 PyErr_SetString(PyExc_OverflowError,
"Python int too large to convert to C int16");
1946 if (test ==
ulong(-1) && PyErr_Occurred()) [[unlikely]] {
1950 PyErr_SetString(PyExc_OverflowError,
"Python int too large to convert to C uint8");
1959 if (test ==
ulong(-1) && PyErr_Occurred()) [[unlikely]] {
1963 PyErr_SetString(PyExc_OverflowError,
"Python int too large to convert to C uint16");
1972 if (test ==
ulong(-1) && PyErr_Occurred()) [[unlikely]] {
1976 PyErr_SetString(PyExc_OverflowError,
"Python int too large to convert to C uint32");
1984 if (value ==
nullptr) {
1986 return uint64_t(PyLong_AsUnsignedLongLong(value));
1989 if (PyLong_Check(value)) {
1990 return uint64_t(PyLong_AsUnsignedLongLong(value));
1994 PyObject *value_converted = PyNumber_Index(value);
1995 if (value_converted ==
nullptr) {
2001 Py_DECREF(value_converted);
2005#if defined(__GNUC__) && !defined(__clang__)
2006# pragma GCC diagnostic pop
2017 switch (typestr[0]) {
2095 while (PyDict_Next(dict, &pos, &key,
nullptr)) {
2096 if (!PyUnicode_Check(key)) {
2117#ifndef MATH_STANDALONE
2141 Py_TYPE(self)->tp_free(self);
2146 if (self->
info.readonly && (flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) {
2147 PyErr_SetString(PyExc_BufferError,
"BPyMemoryViewOwned: object is not writable");
2151 view->obj = Py_NewRef(
reinterpret_cast<PyObject *
>(self));
2153 if ((flags & PyBUF_FORMAT) != PyBUF_FORMAT) {
2154 view->format =
nullptr;
2156 if ((flags & PyBUF_ND) != PyBUF_ND) {
2157 view->shape =
nullptr;
2159 if ((flags & PyBUF_STRIDES) != PyBUF_STRIDES) {
2160 view->strides =
nullptr;
2171 PyVarObject_HEAD_INIT(
nullptr, 0)
2172 "BPyMemoryViewOwned",
2213 if (wrapper ==
nullptr) [[unlikely]] {
2217 wrapper->
info = *info;
2218 wrapper->
info.obj =
nullptr;
2221 wrapper->
info.suboffsets =
nullptr;
2222 wrapper->
info.internal =
nullptr;
2223 const size_t dim_size = size_t(info->ndim) *
sizeof(Py_ssize_t);
2228 PyObject *
mv = PyMemoryView_FromObject(
reinterpret_cast<PyObject *
>(wrapper));
#define ATTR_NONNULL(...)
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define POINTER_OFFSET(v, ofs)
VecBase< float, D > constexpr mod(VecOp< float, D >, VecOp< float, D >) RET
float length(VecOp< float, D >) RET
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
std::string filename(const std::string_view &str, size_t pos)
PyObject * PyC_MainModule_Backup()
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
PyObject * PyC_Tuple_PackArray_String(const char **array, uint len)
int PyC_FlagSet_ToBitfield(const PyC_FlagSet *items, PyObject *value, int *r_value, const char *error_prefix)
size_t size_t size_t BLI_snprintf_utf8(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
int PyC_AsArray_FAST(void *array, const size_t array_item_size, PyObject *value_fast, const Py_ssize_t length, const PyTypeObject *type, const char *error_prefix)
unsigned __int64 uint64_t
bool PyC_IsInterpreterActive()
int PyC_ParseOptionalDouble(PyObject *o, void *p)
static PyBufferProcs bpy_memoryview_buffer_as_buffer
bool PyC_RunString_AsNumber(const char *imports[], const char *expr, const char *filename, double *r_value)
PyObject * PyC_FrozenSetFromStrings(const char **strings)
PyObject * PyC_Err_SetString_Prefix(PyObject *exception_type_prefix, const char *str)
int PyC_ParseOptionalUInt(PyObject *o, void *p)
static void pyc_exception_buffer_handle_system_exit()
int PyC_ParseBool(PyObject *o, void *p)
PyObject * PyC_MemoryView_FromBufferOwned(const Py_buffer *info)
int PyC_CheckArgs_DeepCopy(PyObject *args)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
static PyObject * PyC_Tuple_PackArray_Multi_Bool_impl(const bool **array_p, const int dims[], const int dims_len)
char PyC_StructFmt_type_from_str(const char *typestr)
PyObject * PyC_Tuple_PackArray_Multi_F64(const double *array, const int dims[], const int dims_len)
char * BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
int PyC_AsArray(void *array, const size_t array_item_size, PyObject *value, const Py_ssize_t length, const PyTypeObject *type, const char *error_prefix)
PyObject * PyC_FlagSet_FromBitfield(PyC_FlagSet *items, int flag)
static int bpy_memoryview_buffer_getbuffer(BPyMemoryViewOwned *self, Py_buffer *view, int flags)
int PyC_FlagSet_ValueFromID(const PyC_FlagSet *item, const char *identifier, int *r_value, const char *error_prefix)
static PyTypeObject BPyMemoryViewOwned_Type
int PyC_ParseRectI(PyObject *o, void *p)
static int PyC_AsArray_Multi_impl(void **array_p, const size_t array_item_size, PyObject *value, const int *dims, const int dims_len, const PyTypeObject *type, const char *error_prefix)
void PyC_FileAndNum_Safe(const char **r_filename, int *r_lineno)
void MEM_delete_void(void *vmemh)
PyObject * PyC_UnicodeFromBytes(const char *str)
int PyC_FlagSet_ValueFromID_int(const PyC_FlagSet *item, const char *identifier, int *r_value)
static int PyC_AsArray_Multi_FAST_impl(void **array_p, const size_t array_item_size, PyObject *value_fast, const int *dims, const int dims_len, const PyTypeObject *type, const char *error_prefix)
PyObject * PyC_Tuple_PackArray_Multi_Bool(const bool *array, const int dims[], const int dims_len)
bool PyC_Dict_CheckKeysAreStrings(PyObject *dict)
PyObject * PyC_DefaultNameSpace(const char *filename)
PyObject * PyC_Tuple_PackArray_I32FromBool(const int *array, uint len)
static void bpy_memoryview_buffer_dealloc(BPyMemoryViewOwned *self)
BMesh const char void * data
bool PyC_RunString_AsStringAndSizeOrNone(const char *imports[], const char *expr, const char *filename, char **r_value, size_t *r_value_size)
static ulong pyc_Long_AsUnsignedLong(PyObject *value)
void PyC_ObSpit(const char *name, PyObject *var)
int16_t PyC_Long_AsI16(PyObject *value)
std::optional< int > PyC_ExceptionSystemExitCode()
PyObject * PyC_Tuple_PackArray_Multi_F32(const float *array, const int dims[], const int dims_len)
static PyObject * PyC_Tuple_PackArray_Multi_I32_impl(const int **array_p, const int dims[], const int dims_len)
int PyC_ParseOptionalInt(PyObject *o, void *p)
PyObject * PyC_ExceptionBuffer_Simple()
int PyC_ParseUnicodeAsBytesAndSize(PyObject *o, void *p)
void PyC_List_Fill(PyObject *list, PyObject *value)
PyObject * PyC_Tuple_PackArray_I32(const int *array, uint len)
uint64_t PyC_Long_AsU64(PyObject *value)
PyObject * PyC_FlagSet_AsString(const PyC_FlagSet *item)
void PyC_RunQuicky(const char *filepath, int n,...)
const char * PyC_StringEnum_FindIDFromValue(const PyC_StringEnumItems *items, const int value)
bool PyC_RunString_AsStringAndSize(const char *imports[], const char *expr, const char *filename, char **r_value, size_t *r_value_size)
uint8_t PyC_Long_AsU8(PyObject *value)
bool PyC_RunString_AsIntPtr(const char *imports[], const char *expr, const char *filename, intptr_t *r_value)
PyObject * PyC_Err_Format_Prefix(PyObject *exception_type_prefix, const char *format,...)
const char * PyC_UnicodeAsBytes(PyObject *py_str, PyObject **r_coerce)
void PyC_Err_PrintWithFunc(PyObject *py_func)
bool PyC_RunString_AsStringOrNone(const char *imports[], const char *expr, const char *filename, char **r_value)
static PyObject * PyC_Tuple_PackArray_Multi_F32_impl(const float **array_p, const int dims[], const int dims_len)
static std::optional< int > g_system_exit_code
int PyC_Long_AsBool(PyObject *value)
int PyC_AsArray_Multi_FAST(void *array, const size_t array_item_size, PyObject *value_fast, const int *dims, const int dims_len, const PyTypeObject *type, const char *error_prefix)
uint32_t PyC_Long_AsU32(PyObject *value)
void * PyC_RNA_AsPointer(PyObject *value, const char *type_name)
void PyC_Tuple_Fill(PyObject *tuple, PyObject *value)
PyObject * PyC_Tuple_PackArray_Multi_I32(const int *array, const int dims[], const int dims_len)
uint16_t PyC_Long_AsU16(PyObject *value)
bool PyC_StructFmt_type_is_bool(char format)
bool PyC_StructFmt_type_is_float_any(char format)
PyObject * PyC_Tuple_PackArray_F64(const double *array, uint len)
void PyC_FileAndNum(const char **r_filename, int *r_lineno)
PyObject * PyC_Tuple_PackArray_F32(const float *array, uint len)
int PyC_ParseOptionalRectI(PyObject *o, void *p)
int PyC_Module_AddToSysModules(PyObject *sys_modules, PyObject *module)
void PyC_MainModule_Restore(PyObject *main_mod)
static PyObject * PyC_Tuple_PackArray_Multi_F64_impl(const double **array_p, const int dims[], const int dims_len)
PyObject * PyC_UnicodeFromStdStr(const std::string &str)
PyObject * PyC_ExceptionBuffer()
bool PyC_RunString_AsString(const char *imports[], const char *expr, const char *filename, char **r_value)
int PyC_ParseStringEnum(PyObject *o, void *p)
bool PyC_NameSpace_ImportArray(PyObject *py_dict, const char *imports[])
PyObject * PyC_UnicodeFromBytesAndSize(const char *str, Py_ssize_t size)
bool PyC_StructFmt_type_is_int_any(char format)
void PyC_ObSpitStr(char *result, size_t result_maxncpy, PyObject *var)
bool PyC_Err_CaptureSystemExitCode()
int8_t PyC_Long_AsI8(PyObject *value)
int PyC_ParseUnicodeAsBytesAndSize_OrNone(PyObject *o, void *p)
static PyObject * pyc_run_string_as_py_object(const char *imports[], const char *imports_star[], const char *expr, const char *filename) ATTR_NONNULL(3
int PyC_ParseTypeOrNone(PyObject *o, void *p)
PyObject * PyC_Tuple_PackArray_Bool(const bool *array, uint len)
int PyC_AsArray_Multi(void *array, const size_t array_item_size, PyObject *value, const int *dims, const int dims_len, const PyTypeObject *type, const char *error_prefix)
int PyC_ParseOptionalBool(PyObject *o, void *p)
int PyC_ParseOptionalFloat(PyObject *o, void *p)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
bool PyC_StructFmt_type_is_byte(char format)
const char * PyC_UnicodeAsBytesAndSize(PyObject *py_str, Py_ssize_t *r_size, PyObject **r_coerce)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
Py_ssize_t shape_and_stride[]