15 #define PY_SSIZE_T_CLEAN
18 #include <frameobject.h>
26 #ifndef MATH_STANDALONE
46 const size_t array_item_size,
49 const PyTypeObject *
type,
50 const char *error_prefix)
52 const Py_ssize_t value_len = PySequence_Fast_GET_SIZE(value_fast);
53 PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
56 BLI_assert(PyList_Check(value_fast) || PyTuple_Check(value_fast));
59 PyErr_Format(PyExc_TypeError,
60 "%.200s: invalid sequence length. expected %d, got %d",
68 if (
type == &PyFloat_Type) {
69 switch (array_item_size) {
71 double *array_double =
array;
72 for (i = 0; i <
length; i++) {
73 array_double[i] = PyFloat_AsDouble(value_fast_items[i]);
78 float *array_float =
array;
79 for (i = 0; i <
length; i++) {
80 array_float[i] = PyFloat_AsDouble(value_fast_items[i]);
90 else if (
type == &PyLong_Type) {
91 switch (array_item_size) {
94 for (i = 0; i <
length; i++) {
95 array_int[i] = PyC_Long_AsI64(value_fast_items[i]);
101 for (i = 0; i <
length; i++) {
102 array_int[i] = PyC_Long_AsI32(value_fast_items[i]);
108 for (i = 0; i <
length; i++) {
115 for (i = 0; i <
length; i++) {
126 else if (
type == &PyBool_Type) {
127 switch (array_item_size) {
130 for (i = 0; i <
length; i++) {
131 array_bool[i] = (PyLong_AsLong(value_fast_items[i]) != 0);
137 for (i = 0; i <
length; i++) {
138 array_bool[i] = (PyLong_AsLong(value_fast_items[i]) != 0);
144 for (i = 0; i <
length; i++) {
145 array_bool[i] = (PyLong_AsLong(value_fast_items[i]) != 0);
151 for (i = 0; i <
length; i++) {
152 array_bool[i] = (PyLong_AsLong(value_fast_items[i]) != 0);
163 PyErr_Format(PyExc_TypeError,
"%s: internal error %s is invalid", error_prefix,
type->tp_name);
167 if (PyErr_Occurred()) {
168 PyErr_Format(PyExc_TypeError,
169 "%s: one or more items could not be used as a %s",
179 const size_t array_item_size,
182 const PyTypeObject *
type,
183 const char *error_prefix)
185 PyObject *value_fast;
188 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
193 Py_DECREF(value_fast);
198 const size_t array_item_size,
202 const PyTypeObject *
type,
203 const char *error_prefix);
206 const size_t array_item_size,
207 PyObject *value_fast,
210 const PyTypeObject *
type,
211 const char *error_prefix)
213 const Py_ssize_t value_len = PySequence_Fast_GET_SIZE(value_fast);
214 const int length = dims[0];
224 if (value_len !=
length) {
225 PyErr_Format(PyExc_TypeError,
226 "%.200s: invalid sequence length. expected %d, got %d",
233 PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
234 const int *dims_next = dims + 1;
235 const int dims_next_len = dims_len - 1;
237 for (
int i = 0; i <
length; i++) {
244 error_prefix) == -1) {
253 const size_t array_item_size,
257 const PyTypeObject *
type,
258 const char *error_prefix)
260 PyObject *value_fast;
263 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
268 array_p, array_item_size, value_fast, dims, dims_len,
type, error_prefix);
269 Py_DECREF(value_fast);
274 const size_t array_item_size,
275 PyObject *value_fast,
278 const PyTypeObject *
type,
279 const char *error_prefix)
282 &
array, array_item_size, value_fast, dims, dims_len,
type, error_prefix);
286 const size_t array_item_size,
290 const PyTypeObject *
type,
291 const char *error_prefix)
294 &
array, array_item_size, value, dims, dims_len,
type, error_prefix);
308 PyObject *tuple = PyTuple_New(
len);
309 for (
uint i = 0; i <
len; i++) {
310 PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(
array[i]));
317 PyObject *tuple = PyTuple_New(
len);
318 for (
uint i = 0; i <
len; i++) {
319 PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(
array[i]));
326 PyObject *tuple = PyTuple_New(
len);
327 for (
uint i = 0; i <
len; i++) {
328 PyTuple_SET_ITEM(tuple, i, PyLong_FromLong(
array[i]));
335 PyObject *tuple = PyTuple_New(
len);
336 for (
uint i = 0; i <
len; i++) {
337 PyTuple_SET_ITEM(tuple, i, PyBool_FromLong(
array[i]));
344 PyObject *tuple = PyTuple_New(
len);
345 for (
uint i = 0; i <
len; i++) {
346 PyTuple_SET_ITEM(tuple, i, PyBool_FromLong(
array[i]));
361 const int len = dims[0];
364 *array_p = (*array_p) +
len;
367 PyObject *tuple = PyTuple_New(dims[0]);
368 const int *dims_next = dims + 1;
369 const int dims_next_len = dims_len - 1;
370 for (
uint i = 0; i <
len; i++) {
385 const int len = dims[0];
388 *array_p = (*array_p) +
len;
391 PyObject *tuple = PyTuple_New(dims[0]);
392 const int *dims_next = dims + 1;
393 const int dims_next_len = dims_len - 1;
394 for (
uint i = 0; i <
len; i++) {
409 const int len = dims[0];
412 *array_p = (*array_p) +
len;
415 PyObject *tuple = PyTuple_New(dims[0]);
416 const int *dims_next = dims + 1;
417 const int dims_next_len = dims_len - 1;
418 for (
uint i = 0; i <
len; i++) {
433 const int len = dims[0];
436 *array_p = (*array_p) +
len;
439 PyObject *tuple = PyTuple_New(dims[0]);
440 const int *dims_next = dims + 1;
441 const int dims_next_len = dims_len - 1;
442 for (
uint i = 0; i <
len; i++) {
461 const uint tot = PyTuple_GET_SIZE(tuple);
464 for (i = 0; i < tot; i++) {
465 PyTuple_SET_ITEM(tuple, i, value);
472 const uint tot = PyList_GET_SIZE(list);
475 for (i = 0; i < tot; i++) {
476 PyList_SET_ITEM(list, i, value);
491 if (((value = PyLong_AsLong(o)) == -1) || !
ELEM(value, 0, 1)) {
492 PyErr_Format(PyExc_ValueError,
"expected a bool or int (0/1), got %s", Py_TYPE(o)->tp_name);
496 *bool_p = value ? true :
false;
503 const char *value = PyUnicode_AsUTF8(o);
505 PyErr_Format(PyExc_ValueError,
"expected a string, got %s", Py_TYPE(o)->tp_name);
509 for (i = 0;
e->items[i].id; i++) {
510 if (
STREQ(
e->items[i].id, value)) {
511 e->value_found =
e->items[i].value;
519 PyObject *enum_items = PyTuple_New(i);
520 for (i = 0;
e->items[i].id; i++) {
521 PyTuple_SET_ITEM(enum_items, i, PyUnicode_FromString(
e->items[i].id));
523 PyErr_Format(PyExc_ValueError,
"expected a string in %S, got '%s'", enum_items, value);
524 Py_DECREF(enum_items);
531 for (
int i = 0;
items[i].
id; i++) {
532 if (
items[i].value == value) {
542 PyObject *dummy_pydict;
543 return PyArg_ParseTuple(args,
"|O!:__deepcopy__", &PyDict_Type, &dummy_pydict) != 0;
548 #ifndef MATH_STANDALONE
559 const char *null_str =
"<null>";
560 fprintf(stderr,
"<%s> : ", name);
562 fprintf(stderr,
"%s\n", null_str);
565 PyObject_Print(var, stderr, 0);
566 const PyTypeObject *
type = Py_TYPE(var);
568 " ref:%d, ptr:%p, type: %s\n",
578 const char *null_str =
"<null>";
583 const PyTypeObject *
type = Py_TYPE(var);
584 PyObject *var_str = PyObject_Repr(var);
585 if (var_str ==
NULL) {
592 " ref=%d, ptr=%p, type=%s, value=%.200s",
596 var_str ? PyUnicode_AsUTF8(var_str) :
"<error>");
597 if (var_str !=
NULL) {
606 const char *filename;
611 fprintf(stderr,
"python line lookup failed, interpreter inactive\n");
618 fprintf(stderr,
"%s:%d\n", filename, lineno);
625 fprintf(stderr,
"python line lookup failed, interpreter inactive\n");
630 const PyGILState_STATE gilstate = PyGILState_Ensure();
631 PyRun_SimpleString(
"__import__('traceback').print_stack()");
632 PyGILState_Release(gilstate);
643 PyFrameObject *frame;
653 if (!(frame = PyEval_GetFrame())) {
656 if (!(code = PyFrame_GetCode(frame))) {
662 *r_filename = PyUnicode_AsUTF8(code->co_filename);
666 if (r_filename && *r_filename ==
NULL) {
669 PyObject *mod_name = PyDict_GetItemString(PyEval_GetGlobals(),
"__name__");
671 PyObject *
mod = PyDict_GetItem(PyImport_GetModuleDict(), mod_name);
673 PyObject *mod_file = PyModule_GetFilenameObject(
mod);
675 *r_filename = PyUnicode_AsUTF8(mod_name);
684 if (*r_filename ==
NULL) {
685 *r_filename = PyUnicode_AsUTF8(mod_name);
691 *r_lineno = PyFrame_GetLineNumber(frame);
720 for (i = 0; i < n; i++) {
721 attr = va_arg(vargs,
char *);
722 item = PyObject_GetAttrString(item, attr);
752 PyObject *py_str = PyUnicode_FromString(*
str);
753 PySet_Add(
ret, py_str);
768 PyObject *error_value_prefix;
772 error_value_prefix = PyUnicode_FromFormatV(
format, args);
775 if (PyErr_Occurred()) {
776 PyObject *error_type, *error_value, *error_traceback;
777 PyErr_Fetch(&error_type, &error_value, &error_traceback);
779 if (PyUnicode_Check(error_value)) {
780 PyErr_Format(exception_type_prefix,
"%S, %S", error_value_prefix, error_value);
783 PyErr_Format(exception_type_prefix,
786 Py_TYPE(error_value)->tp_name,
791 PyErr_SetObject(exception_type_prefix, error_value_prefix);
794 Py_XDECREF(error_value_prefix);
808 PyCodeObject *f_code = (PyCodeObject *)PyFunction_GET_CODE(py_func);
814 "File \"%s\", line %d, in %s\n",
815 PyUnicode_AsUTF8(f_code->co_filename),
816 f_code->co_firstlineno,
817 PyUnicode_AsUTF8(((PyFunctionObject *)py_func)->func_name));
827 PyObject *error_value,
828 PyObject *error_traceback)
830 if (!PyErr_GivenExceptionMatches(error_type, PyExc_SystemExit)) {
834 if (_Py_GetConfig()->inspect) {
852 PyErr_Restore(error_type, error_value, error_traceback);
863 PyObject *traceback_mod =
NULL;
864 PyObject *format_tb_func =
NULL;
867 if (!(traceback_mod = PyImport_ImportModule(
"traceback"))) {
870 else if (!(format_tb_func = PyObject_GetAttrString(traceback_mod,
"format_exc"))) {
874 ret = PyObject_CallObject(format_tb_func,
NULL);
876 if (
ret == Py_None) {
883 Py_XDECREF(traceback_mod);
884 Py_XDECREF(format_tb_func);
891 PyObject *stdout_backup = PySys_GetObject(
"stdout");
892 PyObject *stderr_backup = PySys_GetObject(
"stderr");
893 PyObject *string_io =
NULL;
894 PyObject *string_io_buf =
NULL;
895 PyObject *string_io_mod =
NULL;
896 PyObject *string_io_getvalue =
NULL;
898 PyObject *error_type, *error_value, *error_traceback;
900 if (!PyErr_Occurred()) {
904 PyErr_Fetch(&error_type, &error_value, &error_traceback);
912 if (!(string_io_mod = PyImport_ImportModule(
"io"))) {
915 else if (!(string_io = PyObject_CallMethod(string_io_mod,
"StringIO",
NULL))) {
918 else if (!(string_io_getvalue = PyObject_GetAttrString(string_io,
"getvalue"))) {
923 Py_INCREF(stdout_backup);
924 Py_INCREF(stderr_backup);
927 PySys_SetObject(
"stdout", string_io);
928 PySys_SetObject(
"stderr", string_io);
930 PyErr_Restore(error_type, error_value, error_traceback);
932 Py_XINCREF(error_type);
933 Py_XINCREF(error_value);
934 Py_XINCREF(error_traceback);
938 string_io_buf = PyObject_CallObject(string_io_getvalue,
NULL);
940 PySys_SetObject(
"stdout", stdout_backup);
941 PySys_SetObject(
"stderr", stderr_backup);
943 Py_DECREF(stdout_backup);
944 Py_DECREF(stderr_backup);
946 Py_DECREF(string_io_mod);
947 Py_DECREF(string_io_getvalue);
948 Py_DECREF(string_io);
950 PyErr_Restore(error_type, error_value, error_traceback);
952 return string_io_buf;
956 Py_XDECREF(string_io_mod);
957 Py_XDECREF(string_io);
959 PyErr_Restore(error_type, error_value, error_traceback);
961 PyErr_Restore(error_type, error_value, error_traceback);
969 if (!PyErr_Occurred()) {
973 PyObject *string_io_buf =
NULL;
975 PyObject *error_type, *error_value, *error_traceback;
977 PyErr_Fetch(&error_type, &error_value, &error_traceback);
984 if (PyErr_GivenExceptionMatches(error_type, PyExc_SyntaxError)) {
988 if (PyTuple_CheckExact(error_value) && PyTuple_GET_SIZE(error_value) >= 1) {
989 string_io_buf = PyObject_Str(PyTuple_GET_ITEM(error_value, 0));
993 if (string_io_buf ==
NULL) {
994 string_io_buf = PyObject_Str(error_value);
999 string_io_buf = PyUnicode_FromFormat(
"<unprintable %s object>", Py_TYPE(error_value)->tp_name);
1002 PyErr_Restore(error_type, error_value, error_traceback);
1004 return string_io_buf;
1019 result = PyUnicode_AsUTF8AndSize(py_str,
size);
1029 if (PyBytes_Check(py_str)) {
1030 *
size = PyBytes_GET_SIZE(py_str);
1031 return PyBytes_AS_STRING(py_str);
1033 if ((*coerce = PyUnicode_EncodeFSDefault(py_str))) {
1034 *
size = PyBytes_GET_SIZE(*coerce);
1035 return PyBytes_AS_STRING(*coerce);
1046 result = PyUnicode_AsUTF8(py_str);
1056 if (PyBytes_Check(py_str)) {
1057 return PyBytes_AS_STRING(py_str);
1059 if ((*coerce = PyUnicode_EncodeFSDefault(py_str))) {
1060 return PyBytes_AS_STRING(*coerce);
1095 PyObject *modules = PyImport_GetModuleDict();
1096 PyObject *builtins = PyEval_GetBuiltins();
1097 PyObject *mod_main = PyModule_New(
"__main__");
1098 PyDict_SetItemString(modules,
"__main__", mod_main);
1099 Py_DECREF(mod_main);
1100 PyModule_AddStringConstant(mod_main,
"__name__",
"__main__");
1106 PyModule_AddObject(mod_main,
"__builtins__", builtins);
1107 Py_INCREF(builtins);
1108 return PyModule_GetDict(mod_main);
1113 for (
int i = 0; imports[i]; i++) {
1114 PyObject *name = PyUnicode_FromString(imports[i]);
1115 PyObject *
mod = PyImport_ImportModuleLevelObject(name,
NULL,
NULL, 0, 0);
1118 PyDict_SetItem(py_dict, name,
mod);
1133 PyObject *modules = PyImport_GetModuleDict();
1134 *r_main_mod = PyDict_GetItemString(modules,
"__main__");
1135 Py_XINCREF(*r_main_mod);
1140 PyObject *modules = PyImport_GetModuleDict();
1141 PyDict_SetItemString(modules,
"__main__", main_mod);
1142 Py_XDECREF(main_mod);
1148 return (PyThreadState_GetDict() !=
NULL);
1162 FILE *fp = fopen(filepath,
"r");
1165 const PyGILState_STATE gilstate = PyGILState_Ensure();
1169 Py_ssize_t *sizes = PyMem_MALLOC(
sizeof(*sizes) * (n / 2));
1173 PyObject *values = PyList_New(n / 2);
1175 PyObject *py_result, *
ret;
1177 PyObject *struct_mod = PyImport_ImportModule(
"struct");
1178 PyObject *calcsize = PyObject_GetAttrString(struct_mod,
"calcsize");
1179 PyObject *pack = PyObject_GetAttrString(struct_mod,
"pack");
1180 PyObject *unpack = PyObject_GetAttrString(struct_mod,
"unpack");
1182 Py_DECREF(struct_mod);
1185 for (i = 0; i * 2 < n; i++) {
1186 const char *
format = va_arg(vargs,
char *);
1187 void *
ptr = va_arg(vargs,
void *);
1189 ret = PyObject_CallFunction(calcsize,
"s",
format);
1192 sizes[i] = PyLong_AsLong(
ret);
1194 ret = PyObject_CallFunction(unpack,
"sy#",
format, (
char *)
ptr, sizes[i]);
1198 printf(
"%s error, line:%d\n", __func__, __LINE__);
1202 PyList_SET_ITEM(values, i, Py_INCREF_RET(Py_None));
1207 if (PyTuple_GET_SIZE(
ret) == 1) {
1209 PyObject *tmp = PyTuple_GET_ITEM(
ret, 0);
1215 PyList_SET_ITEM(values, i,
ret);
1221 PyDict_SetItemString(py_dict,
"values", values);
1224 py_result = PyRun_File(fp, filepath, Py_file_input, py_dict, py_dict);
1232 values = PyDict_GetItemString(py_dict,
"values");
1234 if (values && PyList_Check(values)) {
1237 Py_DECREF(py_result);
1242 for (i = 0; i * 2 < n; i++) {
1243 const char *
format = va_arg(vargs,
char *);
1244 void *
ptr = va_arg(vargs,
void *);
1249 item = PyList_GET_ITEM(values, i);
1250 if (PyTuple_CheckExact(item)) {
1251 int ofs = PyTuple_GET_SIZE(item);
1252 item_new = PyTuple_New(ofs + 1);
1254 PyObject *member = PyTuple_GET_ITEM(item, ofs);
1255 PyTuple_SET_ITEM(item_new, ofs + 1, member);
1259 PyTuple_SET_ITEM(item_new, 0, PyUnicode_FromString(
format));
1262 item_new = Py_BuildValue(
"sO",
format, item);
1265 ret = PyObject_Call(pack, item_new,
NULL);
1269 memcpy(
ptr, PyBytes_AS_STRING(
ret), sizes[i]);
1273 printf(
"%s error on arg '%d', line:%d\n", __func__, i, __LINE__);
1279 Py_DECREF(item_new);
1284 printf(
"%s error, 'values' not a list, line:%d\n", __func__, __LINE__);
1288 printf(
"%s error line:%d\n", __func__, __LINE__);
1293 Py_DECREF(calcsize);
1299 PyGILState_Release(gilstate);
1302 fprintf(stderr,
"%s: '%s' missing\n", __func__, filepath);
1309 PyObject *as_pointer;
1312 if (
STREQ(Py_TYPE(value)->tp_name, type_name) &&
1313 (as_pointer = PyObject_GetAttrString(value,
"as_pointer")) !=
NULL &&
1314 PyCallable_Check(as_pointer)) {
1318 pointer = PyObject_CallObject(as_pointer,
NULL);
1319 Py_DECREF(as_pointer);
1322 PyErr_SetString(PyExc_SystemError,
"value.as_pointer() failed");
1325 result = PyLong_AsVoidPtr(pointer);
1328 PyErr_SetString(PyExc_SystemError,
"value.as_pointer() failed");
1334 PyErr_Format(PyExc_TypeError,
1335 "expected '%.200s' type found '%.200s' instead",
1337 Py_TYPE(value)->tp_name);
1351 PyObject *py_items = PyList_New(0);
1353 PyList_APPEND(py_items, PyUnicode_FromString(item->
identifier));
1355 PyObject *py_string = PyObject_Repr(py_items);
1356 Py_DECREF(py_items);
1364 *r_value = item->
value;
1373 const char *identifier,
1375 const char *error_prefix)
1380 PyExc_ValueError,
"%s: '%.200s' not found in (%U)", error_prefix, identifier, enum_str);
1381 Py_DECREF(enum_str);
1391 const char *error_prefix)
1398 Py_ssize_t
hash = 0;
1401 if (!PySet_Check(value)) {
1402 PyErr_Format(PyExc_TypeError,
1403 "%.200s expected a set, not %.200s",
1405 Py_TYPE(value)->tp_name);
1411 while (_PySet_NextEntry(value, &
pos, &key, &
hash)) {
1412 const char *param = PyUnicode_AsUTF8(key);
1414 if (param ==
NULL) {
1415 PyErr_Format(PyExc_TypeError,
1416 "%.200s set must contain strings, not %.200s",
1418 Py_TYPE(key)->tp_name);
1435 PyObject *
ret = PySet_New(
NULL);
1440 pystr = PyUnicode_FromString(
items->identifier);
1441 PySet_Add(
ret, pystr);
1457 const char *filename,
1460 PyObject *py_dict, *
mod, *retval;
1462 PyObject *main_mod =
NULL;
1468 mod = PyImport_ImportModule(
"math");
1470 PyDict_Merge(py_dict, PyModule_GetDict(
mod), 0);
1481 else if ((retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict)) ==
NULL) {
1487 if (PyTuple_Check(retval)) {
1493 for (i = 0; i < PyTuple_GET_SIZE(retval); i++) {
1494 const double val_item = PyFloat_AsDouble(PyTuple_GET_ITEM(retval, i));
1495 if (val_item == -1 && PyErr_Occurred()) {
1503 val = PyFloat_AsDouble(retval);
1507 if (val == -1 && PyErr_Occurred()) {
1525 const char *filename,
1528 PyObject *py_dict, *retval;
1530 PyObject *main_mod =
NULL;
1539 else if ((retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict)) ==
NULL) {
1545 val = (
intptr_t)PyLong_AsVoidPtr(retval);
1546 if (val == 0 && PyErr_Occurred()) {
1563 const char *filename,
1565 size_t *r_value_size)
1567 PyObject *py_dict, *retval;
1569 PyObject *main_mod =
NULL;
1578 else if ((retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict)) ==
NULL) {
1585 val = PyUnicode_AsUTF8AndSize(retval, &val_len);
1586 if (val ==
NULL && PyErr_Occurred()) {
1590 char *val_alloc =
MEM_mallocN(val_len + 1, __func__);
1591 memcpy(val_alloc, val, val_len + 1);
1592 *r_value = val_alloc;
1593 *r_value_size = val_len;
1606 const char *filename,
1626 # pragma warning(push)
1627 # pragma GCC diagnostic ignored "-Wtype-limits"
1632 const int test = _PyLong_AsInt(value);
1633 if (
UNLIKELY(test == -1 && PyErr_Occurred())) {
1637 PyErr_SetString(PyExc_TypeError,
"Python number not a bool (0/1)");
1645 const int test = _PyLong_AsInt(value);
1646 if (
UNLIKELY(test == -1 && PyErr_Occurred())) {
1650 PyErr_SetString(PyExc_OverflowError,
"Python int too large to convert to C int8");
1658 const int test = _PyLong_AsInt(value);
1659 if (
UNLIKELY(test == -1 && PyErr_Occurred())) {
1663 PyErr_SetString(PyExc_OverflowError,
"Python int too large to convert to C int16");
1676 const ulong test = PyLong_AsUnsignedLong(value);
1681 PyErr_SetString(PyExc_OverflowError,
"Python int too large to convert to C uint8");
1689 const ulong test = PyLong_AsUnsignedLong(value);
1694 PyErr_SetString(PyExc_OverflowError,
"Python int too large to convert to C uint16");
1702 const ulong test = PyLong_AsUnsignedLong(value);
1707 PyErr_SetString(PyExc_OverflowError,
"Python int too large to convert to C uint32");
1718 # pragma warning(pop)
1729 switch (typestr[0]) {
typedef float(TangentPoint)[2]
#define BLI_assert_unreachable()
size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
#define POINTER_OFFSET(v, ofs)
typedef double(DMatrix)[4][4]
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
Read Guarded memory(de)allocation.
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
void *(* MEM_mallocN)(size_t len, const char *str)
T length(const vec_base< T, Size > &a)
int16_t PyC_Long_AsI16(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)
static PyObject * PyC_Tuple_PackArray_Multi_F32_impl(const float **array_p, const int dims[], const int dims_len)
char PyC_StructFmt_type_from_str(const char *typestr)
PyObject * PyC_DefaultNameSpace(const char *filename)
const char * PyC_UnicodeAsByte(PyObject *py_str, PyObject **coerce)
PyObject * PyC_FlagSet_FromBitfield(PyC_FlagSet *items, int flag)
PyObject * PyC_FlagSet_AsString(const PyC_FlagSet *item)
static PyObject * PyC_Tuple_PackArray_Multi_Bool_impl(const bool **array_p, const int dims[], const int dims_len)
PyObject * PyC_Tuple_PackArray_Multi_Bool(const bool *array, const int dims[], const int dims_len)
bool PyC_StructFmt_type_is_bool(char format)
uint8_t PyC_Long_AsU8(PyObject *value)
void PyC_ObSpit(const char *name, PyObject *var)
int8_t PyC_Long_AsI8(PyObject *value)
void PyC_RunQuicky(const char *filepath, int n,...)
bool PyC_RunString_AsString(const char *imports[], const char *expr, const char *filename, char **r_value)
PyObject * PyC_Tuple_PackArray_Bool(const bool *array, uint len)
PyObject * PyC_Tuple_PackArray_Multi_I32(const int *array, const int dims[], const int dims_len)
static void pyc_exception_buffer_handle_system_exit(PyObject *error_type, PyObject *error_value, PyObject *error_traceback)
static PyObject * PyC_Tuple_PackArray_Multi_F64_impl(const double **array_p, const int dims[], const int dims_len)
int PyC_CheckArgs_DeepCopy(PyObject *args)
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)
int PyC_FlagSet_ValueFromID(const PyC_FlagSet *item, const char *identifier, int *r_value, const char *error_prefix)
PyObject * PyC_Tuple_PackArray_I32FromBool(const int *array, uint len)
int PyC_ParseStringEnum(PyObject *o, void *p)
PyObject * PyC_UnicodeFromByteAndSize(const char *str, Py_ssize_t size)
PyObject * PyC_Tuple_PackArray_Multi_F64(const double *array, const int dims[], const int dims_len)
PyObject * PyC_Err_SetString_Prefix(PyObject *exception_type_prefix, const char *str)
bool PyC_StructFmt_type_is_int_any(char format)
void * PyC_RNA_AsPointer(PyObject *value, const char *type_name)
PyObject * PyC_Tuple_PackArray_Multi_F32(const float *array, const int dims[], const int dims_len)
PyObject * PyC_ExceptionBuffer(void)
int PyC_Long_AsBool(PyObject *value)
static PyObject * PyC_Tuple_PackArray_Multi_I32_impl(const int **array_p, const int dims[], const int dims_len)
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_Err_Format_Prefix(PyObject *exception_type_prefix, const char *format,...)
int PyC_FlagSet_ValueFromID_int(const PyC_FlagSet *item, const char *identifier, int *r_value)
PyObject * PyC_Tuple_PackArray_F32(const float *array, uint len)
const char * PyC_StringEnum_FindIDFromValue(const struct PyC_StringEnumItems *items, const int value)
bool PyC_RunString_AsNumber(const char *imports[], const char *expr, const char *filename, double *r_value)
bool PyC_StructFmt_type_is_byte(char format)
int PyC_FlagSet_ToBitfield(const PyC_FlagSet *items, PyObject *value, int *r_value, const char *error_prefix)
PyObject * PyC_ExceptionBuffer_Simple(void)
PyObject * PyC_Tuple_PackArray_I32(const int *array, uint len)
PyObject * PyC_Object_GetAttrStringArgs(PyObject *o, Py_ssize_t n,...)
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)
void PyC_MainModule_Backup(PyObject **r_main_mod)
bool PyC_RunString_AsStringAndSize(const char *imports[], const char *expr, const char *filename, char **r_value, size_t *r_value_size)
const char * PyC_UnicodeAsByteAndSize(PyObject *py_str, Py_ssize_t *size, PyObject **coerce)
void PyC_FileAndNum_Safe(const char **r_filename, int *r_lineno)
bool PyC_IsInterpreterActive(void)
uint32_t PyC_Long_AsU32(PyObject *value)
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)
bool PyC_NameSpace_ImportArray(PyObject *py_dict, const char *imports[])
void PyC_FileAndNum(const char **r_filename, int *r_lineno)
void PyC_List_Fill(PyObject *list, PyObject *value)
uint16_t PyC_Long_AsU16(PyObject *value)
void PyC_Err_PrintWithFunc(PyObject *py_func)
void PyC_MainModule_Restore(PyObject *main_mod)
PyObject * PyC_FrozenSetFromStrings(const char **strings)
PyObject * PyC_Tuple_PackArray_F64(const double *array, uint len)
PyObject * PyC_UnicodeFromByte(const char *str)
int PyC_ParseBool(PyObject *o, void *p)
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)
void PyC_ObSpitStr(char *result, size_t result_len, PyObject *var)
void PyC_Tuple_Fill(PyObject *tuple, PyObject *value)
bool PyC_StructFmt_type_is_float_any(char format)
bool PyC_RunString_AsIntPtr(const char *imports[], const char *expr, const char *filename, intptr_t *r_value)
const struct PyC_StringEnumItems * items
ccl_device_inline int mod(int x, int m)