From 25ec4b437fe927205a810470cdc23efd7282c85b Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Sat, 30 Mar 2019 06:12:48 +1100 Subject: Cleanup: style, use braces for the Python API --- source/blender/python/bmesh/bmesh_py_ops.c | 6 +- source/blender/python/bmesh/bmesh_py_types.c | 99 +++-- .../python/bmesh/bmesh_py_types_customdata.c | 34 +- .../blender/python/bmesh/bmesh_py_types_meshdata.c | 6 +- .../blender/python/bmesh/bmesh_py_types_select.c | 19 +- source/blender/python/generic/bgl.c | 77 +++- source/blender/python/generic/blf_py_api.c | 42 +- .../blender/python/generic/bpy_internal_import.c | 24 +- source/blender/python/generic/idprop_py_api.c | 68 +++- source/blender/python/generic/py_capi_utils.c | 24 +- source/blender/python/gpu/gpu_py_offscreen.c | 3 +- source/blender/python/gpu/gpu_py_types.c | 18 +- source/blender/python/intern/bpy.c | 26 +- source/blender/python/intern/bpy_app.c | 16 +- source/blender/python/intern/bpy_app_handlers.c | 3 +- .../blender/python/intern/bpy_app_translations.c | 15 +- source/blender/python/intern/bpy_capi_utils.c | 6 +- source/blender/python/intern/bpy_driver.c | 34 +- source/blender/python/intern/bpy_interface.c | 36 +- source/blender/python/intern/bpy_library_load.c | 3 +- source/blender/python/intern/bpy_operator.c | 6 +- source/blender/python/intern/bpy_operator_wrap.c | 3 +- source/blender/python/intern/bpy_props.c | 181 ++++++--- source/blender/python/intern/bpy_rna.c | 442 ++++++++++++++------- source/blender/python/intern/bpy_rna_anim.c | 21 +- source/blender/python/intern/bpy_rna_array.c | 32 +- source/blender/python/intern/bpy_rna_callback.c | 36 +- source/blender/python/intern/bpy_traceback.c | 24 +- source/blender/python/mathutils/mathutils.c | 31 +- source/blender/python/mathutils/mathutils_Color.c | 136 +++++-- source/blender/python/mathutils/mathutils_Euler.c | 116 ++++-- source/blender/python/mathutils/mathutils_Matrix.c | 317 ++++++++++----- .../python/mathutils/mathutils_Quaternion.c | 209 ++++++---- source/blender/python/mathutils/mathutils_Vector.c | 250 ++++++++---- .../blender/python/mathutils/mathutils_bvhtree.c | 6 +- .../blender/python/mathutils/mathutils_geometry.c | 24 +- .../python/mathutils/mathutils_interpolate.c | 12 +- source/blender/python/mathutils/mathutils_kdtree.c | 12 +- source/blender/python/mathutils/mathutils_noise.c | 72 ++-- 39 files changed, 1689 insertions(+), 800 deletions(-) (limited to 'source/blender/python') diff --git a/source/blender/python/bmesh/bmesh_py_ops.c b/source/blender/python/bmesh/bmesh_py_ops.c index fbd79f28ec7..f35bfb730ad 100644 --- a/source/blender/python/bmesh/bmesh_py_ops.c +++ b/source/blender/python/bmesh/bmesh_py_ops.c @@ -351,11 +351,13 @@ PyObject *BPyInit_bmesh_ops(void) { PyObject *submodule; - if (PyType_Ready(&bmesh_ops_fakemod_Type) < 0) + if (PyType_Ready(&bmesh_ops_fakemod_Type) < 0) { return NULL; + } - if (PyType_Ready(&bmesh_op_Type) < 0) + if (PyType_Ready(&bmesh_op_Type) < 0) { return NULL; + } submodule = PyObject_New(PyObject, &bmesh_ops_fakemod_Type); diff --git a/source/blender/python/bmesh/bmesh_py_types.c b/source/blender/python/bmesh/bmesh_py_types.c index 1addd9b84f7..366f0b4b3f7 100644 --- a/source/blender/python/bmesh/bmesh_py_types.c +++ b/source/blender/python/bmesh/bmesh_py_types.c @@ -1445,8 +1445,9 @@ static PyObject *bpy_bmvert_calc_edge_angle(BPy_BMVert *self, PyObject *args) BPY_BM_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "|O:calc_edge_angle", &fallback)) + if (!PyArg_ParseTuple(args, "|O:calc_edge_angle", &fallback)) { return NULL; + } angle = BM_vert_calc_edge_angle_ex(self->v, angle_invalid); @@ -1530,8 +1531,9 @@ static PyObject *bpy_bmedge_calc_face_angle(BPy_BMEdge *self, PyObject *args) BPY_BM_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "|O:calc_face_angle", &fallback)) + if (!PyArg_ParseTuple(args, "|O:calc_face_angle", &fallback)) { return NULL; + } angle = BM_edge_calc_face_angle_ex(self->e, angle_invalid); @@ -1569,8 +1571,9 @@ static PyObject *bpy_bmedge_calc_face_angle_signed(BPy_BMEdge *self, PyObject *a BPY_BM_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "|O:calc_face_angle_signed", &fallback)) + if (!PyArg_ParseTuple(args, "|O:calc_face_angle_signed", &fallback)) { return NULL; + } angle = BM_edge_calc_face_angle_signed_ex(self->e, angle_invalid); @@ -2161,7 +2164,9 @@ static PyObject *bpy_bmedgeseq_new(BPy_BMElemSeq *self, PyObject *args) ret = BPy_BMEdge_CreatePyObject(bm, e); cleanup: - if (vert_array) PyMem_FREE(vert_array); + if (vert_array) { + PyMem_FREE(vert_array); + } return ret; } } @@ -2239,7 +2244,9 @@ static PyObject *bpy_bmfaceseq_new(BPy_BMElemSeq *self, PyObject *args) /* pass through */ cleanup: - if (vert_array) PyMem_FREE(vert_array); + if (vert_array) { + PyMem_FREE(vert_array); + } return ret; } } @@ -2535,9 +2542,15 @@ static int bpy_bmelemseq_sort_cmp_by_keys_ascending(const void *index1_v, const const int *index1 = (int *)index1_v; const int *index2 = (int *)index2_v; - if (keys[*index1] < keys[*index2]) return -1; - else if (keys[*index1] > keys[*index2]) return 1; - else return 0; + if (keys[*index1] < keys[*index2]) { + return -1; + } + else if (keys[*index1] > keys[*index2]) { + return 1; + } + else { + return 0; + } } static int bpy_bmelemseq_sort_cmp_by_keys_descending(const void *index1_v, const void *index2_v, void *keys_v) @@ -2646,10 +2659,12 @@ static PyObject *bpy_bmelemseq_sort(BPy_BMElemSeq *self, PyObject *args, PyObjec range_vn_i(elem_idx, n_elem, 0); /* Sort the index array according to the order of the 'keys' array */ - if (do_reverse) + if (do_reverse) { elem_idx_compare_by_keys = bpy_bmelemseq_sort_cmp_by_keys_descending; - else + } + else { elem_idx_compare_by_keys = bpy_bmelemseq_sort_cmp_by_keys_ascending; + } BLI_qsort_r(elem_idx, n_elem, sizeof(*elem_idx), elem_idx_compare_by_keys, keys); @@ -2920,7 +2935,10 @@ static PyObject *bpy_bmelemseq_subscript_int(BPy_BMElemSeq *self, int keynum) { BPY_BM_CHECK_OBJ(self); - if (keynum < 0) keynum += bpy_bmelemseq_length(self); /* only get length on negative value, may loop entire seq */ + if (keynum < 0) { + /* only get length on negative value, may loop entire seq */ + keynum += bpy_bmelemseq_length(self); + } if (keynum >= 0) { if (self->itype <= BM_FACES_OF_MESH) { if ((self->bm->elem_table_dirty & bm_iter_itype_htype_map[self->itype]) == 0) { @@ -3014,8 +3032,9 @@ static PyObject *bpy_bmelemseq_subscript(BPy_BMElemSeq *self, PyObject *key) /* don't need error check here */ if (PyIndex_Check(key)) { Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; + } return bpy_bmelemseq_subscript_int(self, i); } else if (PySlice_Check(key)) { @@ -3037,14 +3056,22 @@ static PyObject *bpy_bmelemseq_subscript(BPy_BMElemSeq *self, PyObject *key) Py_ssize_t start = 0, stop = PY_SSIZE_T_MAX; /* avoid PySlice_GetIndicesEx because it needs to know the length ahead of time. */ - if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) return NULL; - if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) return NULL; + if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) { + return NULL; + } + if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) { + return NULL; + } if (start < 0 || stop < 0) { /* only get the length for negative values */ Py_ssize_t len = bpy_bmelemseq_length(self); - if (start < 0) start += len; - if (stop < 0) stop += len; + if (start < 0) { + start += len; + } + if (stop < 0) { + stop += len; + } } if (stop - start <= 0) { @@ -3162,10 +3189,18 @@ static void bpy_bmesh_dealloc(BPy_BMesh *self) if (bm) { bm_dealloc_editmode_warn(self); - if (CustomData_has_layer(&bm->vdata, CD_BM_ELEM_PYPTR)) BM_data_layer_free(bm, &bm->vdata, CD_BM_ELEM_PYPTR); - if (CustomData_has_layer(&bm->edata, CD_BM_ELEM_PYPTR)) BM_data_layer_free(bm, &bm->edata, CD_BM_ELEM_PYPTR); - if (CustomData_has_layer(&bm->pdata, CD_BM_ELEM_PYPTR)) BM_data_layer_free(bm, &bm->pdata, CD_BM_ELEM_PYPTR); - if (CustomData_has_layer(&bm->ldata, CD_BM_ELEM_PYPTR)) BM_data_layer_free(bm, &bm->ldata, CD_BM_ELEM_PYPTR); + if (CustomData_has_layer(&bm->vdata, CD_BM_ELEM_PYPTR)) { + BM_data_layer_free(bm, &bm->vdata, CD_BM_ELEM_PYPTR); + } + if (CustomData_has_layer(&bm->edata, CD_BM_ELEM_PYPTR)) { + BM_data_layer_free(bm, &bm->edata, CD_BM_ELEM_PYPTR); + } + if (CustomData_has_layer(&bm->pdata, CD_BM_ELEM_PYPTR)) { + BM_data_layer_free(bm, &bm->pdata, CD_BM_ELEM_PYPTR); + } + if (CustomData_has_layer(&bm->ldata, CD_BM_ELEM_PYPTR)) { + BM_data_layer_free(bm, &bm->ldata, CD_BM_ELEM_PYPTR); + } bm->py_handle = NULL; @@ -3182,8 +3217,9 @@ static void bpy_bmvert_dealloc(BPy_BMElem *self) BMesh *bm = self->bm; if (bm) { void **ptr = CustomData_bmesh_get(&bm->vdata, self->ele->head.data, CD_BM_ELEM_PYPTR); - if (ptr) + if (ptr) { *ptr = NULL; + } } PyObject_DEL(self); } @@ -3193,8 +3229,9 @@ static void bpy_bmedge_dealloc(BPy_BMElem *self) BMesh *bm = self->bm; if (bm) { void **ptr = CustomData_bmesh_get(&bm->edata, self->ele->head.data, CD_BM_ELEM_PYPTR); - if (ptr) + if (ptr) { *ptr = NULL; + } } PyObject_DEL(self); } @@ -3204,8 +3241,9 @@ static void bpy_bmface_dealloc(BPy_BMElem *self) BMesh *bm = self->bm; if (bm) { void **ptr = CustomData_bmesh_get(&bm->pdata, self->ele->head.data, CD_BM_ELEM_PYPTR); - if (ptr) + if (ptr) { *ptr = NULL; + } } PyObject_DEL(self); } @@ -3215,8 +3253,9 @@ static void bpy_bmloop_dealloc(BPy_BMElem *self) BMesh *bm = self->bm; if (bm) { void **ptr = CustomData_bmesh_get(&bm->ldata, self->ele->head.data, CD_BM_ELEM_PYPTR); - if (ptr) + if (ptr) { *ptr = NULL; + } } PyObject_DEL(self); } @@ -3938,7 +3977,9 @@ void *BPy_BMElem_PySeq_As_Array_FAST( } *r_size = seq_len; - if (r_bm) *r_bm = bm; + if (r_bm) { + *r_bm = bm; + } return alloc; err_cleanup: @@ -4042,10 +4083,10 @@ char *BPy_BMElem_StringFromHType_ex(const char htype, char ret[32]) { /* zero to ensure string is always NULL terminated */ char *ret_ptr = ret; - if (htype & BM_VERT) ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMVert_Type.tp_name); - if (htype & BM_EDGE) ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMEdge_Type.tp_name); - if (htype & BM_FACE) ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMFace_Type.tp_name); - if (htype & BM_LOOP) ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMLoop_Type.tp_name); + if (htype & BM_VERT) { ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMVert_Type.tp_name); } + if (htype & BM_EDGE) { ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMEdge_Type.tp_name); } + if (htype & BM_FACE) { ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMFace_Type.tp_name); } + if (htype & BM_LOOP) { ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMLoop_Type.tp_name); } ret[0] = '('; *ret_ptr++ = ')'; *ret_ptr = '\0'; diff --git a/source/blender/python/bmesh/bmesh_py_types_customdata.c b/source/blender/python/bmesh/bmesh_py_types_customdata.c index c161b974eff..abe146f2581 100644 --- a/source/blender/python/bmesh/bmesh_py_types_customdata.c +++ b/source/blender/python/bmesh/bmesh_py_types_customdata.c @@ -615,7 +615,9 @@ static PyObject *bpy_bmlayercollection_subscript_int(BPy_BMLayerCollection *self len = bpy_bmlayercollection_length(self); - if (keynum < 0) keynum += len; + if (keynum < 0) { + keynum += len; + } if (keynum >= 0) { if (keynum < len) { return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, keynum); @@ -636,8 +638,12 @@ static PyObject *bpy_bmlayercollection_subscript_slice(BPy_BMLayerCollection *se BPY_BM_CHECK_OBJ(self); - if (start >= len) start = len - 1; - if (stop >= len) stop = len - 1; + if (start >= len) { + start = len - 1; + } + if (stop >= len) { + stop = len - 1; + } tuple = PyTuple_New(stop - start); @@ -656,8 +662,9 @@ static PyObject *bpy_bmlayercollection_subscript(BPy_BMLayerCollection *self, Py } else if (PyIndex_Check(key)) { Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; + } return bpy_bmlayercollection_subscript_int(self, i); } else if (PySlice_Check(key)) { @@ -679,14 +686,22 @@ static PyObject *bpy_bmlayercollection_subscript(BPy_BMLayerCollection *self, Py Py_ssize_t start = 0, stop = PY_SSIZE_T_MAX; /* avoid PySlice_GetIndicesEx because it needs to know the length ahead of time. */ - if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) return NULL; - if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) return NULL; + if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) { + return NULL; + } + if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) { + return NULL; + } if (start < 0 || stop < 0) { /* only get the length for negative values */ Py_ssize_t len = bpy_bmlayercollection_length(self); - if (start < 0) start += len; - if (stop < 0) stop += len; + if (start < 0) { + start += len; + } + if (stop < 0) { + stop += len; + } } if (stop - start <= 0) { @@ -1085,8 +1100,9 @@ int BPy_BMLayerItem_SetItem(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer, PyObj ret = -1; } else { - if (tmp_val_len > sizeof(mstring->s)) + if (tmp_val_len > sizeof(mstring->s)) { tmp_val_len = sizeof(mstring->s); + } memcpy(mstring->s, tmp_val, tmp_val_len); mstring->s_len = tmp_val_len; } diff --git a/source/blender/python/bmesh/bmesh_py_types_meshdata.c b/source/blender/python/bmesh/bmesh_py_types_meshdata.c index aba54c6c43a..604b55de6e6 100644 --- a/source/blender/python/bmesh/bmesh_py_types_meshdata.c +++ b/source/blender/python/bmesh/bmesh_py_types_meshdata.c @@ -306,8 +306,9 @@ static int mathutils_bmloopcol_set(BaseMathObject *bmo, int UNUSED(subtype)) static int mathutils_bmloopcol_get_index(BaseMathObject *bmo, int subtype, int UNUSED(index)) { /* lazy, avoid repeteing the case statement */ - if (mathutils_bmloopcol_get(bmo, subtype) == -1) + if (mathutils_bmloopcol_get(bmo, subtype) == -1) { return -1; + } return 0; } @@ -316,8 +317,9 @@ static int mathutils_bmloopcol_set_index(BaseMathObject *bmo, int subtype, int i const float f = bmo->data[index]; /* lazy, avoid repeteing the case statement */ - if (mathutils_bmloopcol_get(bmo, subtype) == -1) + if (mathutils_bmloopcol_get(bmo, subtype) == -1) { return -1; + } bmo->data[index] = f; return mathutils_bmloopcol_set(bmo, subtype); diff --git a/source/blender/python/bmesh/bmesh_py_types_select.c b/source/blender/python/bmesh/bmesh_py_types_select.c index ed631f7105b..e257c1bff4b 100644 --- a/source/blender/python/bmesh/bmesh_py_types_select.c +++ b/source/blender/python/bmesh/bmesh_py_types_select.c @@ -255,8 +255,9 @@ static PyObject *bpy_bmeditselseq_subscript(BPy_BMEditSelSeq *self, PyObject *ke /* don't need error check here */ if (PyIndex_Check(key)) { Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; + } return bpy_bmeditselseq_subscript_int(self, i); } else if (PySlice_Check(key)) { @@ -278,14 +279,22 @@ static PyObject *bpy_bmeditselseq_subscript(BPy_BMEditSelSeq *self, PyObject *ke Py_ssize_t start = 0, stop = PY_SSIZE_T_MAX; /* avoid PySlice_GetIndicesEx because it needs to know the length ahead of time. */ - if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) return NULL; - if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) return NULL; + if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) { + return NULL; + } + if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) { + return NULL; + } if (start < 0 || stop < 0) { /* only get the length for negative values */ Py_ssize_t len = bpy_bmeditselseq_length(self); - if (start < 0) start += len; - if (stop < 0) stop += len; + if (start < 0) { + start += len; + } + if (stop < 0) { + stop += len; + } } if (stop - start <= 0) { diff --git a/source/blender/python/generic/bgl.c b/source/blender/python/generic/bgl.c index 13342b7dac8..b52326ed7a4 100644 --- a/source/blender/python/generic/bgl.c +++ b/source/blender/python/generic/bgl.c @@ -476,15 +476,25 @@ static int gl_buffer_type_from_py_buffer(Py_buffer *pybuffer) Py_ssize_t itemsize = pybuffer->itemsize; if (PyC_StructFmt_type_is_float_any(format)) { - if (itemsize == 4) return GL_FLOAT; - if (itemsize == 8) return GL_DOUBLE; + if (itemsize == 4) { + return GL_FLOAT; + } + if (itemsize == 8) { + return GL_DOUBLE; + } } if (PyC_StructFmt_type_is_byte(format) || PyC_StructFmt_type_is_int_any(format)) { - if (itemsize == 1) return GL_BYTE; - if (itemsize == 2) return GL_SHORT; - if (itemsize == 4) return GL_INT; + if (itemsize == 1) { + return GL_BYTE; + } + if (itemsize == 2) { + return GL_SHORT; + } + if (itemsize == 4) { + return GL_INT; + } } return -1; /* UNKNOWN */ @@ -769,10 +779,12 @@ static PyObject *Buffer_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject for (i = 0; i < ndimensions; i++) { PyObject *ob = PySequence_GetItem(length_ob, i); - if (!PyLong_Check(ob)) + if (!PyLong_Check(ob)) { dimensions[i] = 1; - else + } + else { dimensions[i] = PyLong_AsLong(ob); + } Py_DECREF(ob); if (dimensions[i] < 1) { @@ -868,9 +880,15 @@ static PyObject *Buffer_slice(Buffer *self, int begin, int end) PyObject *list; int count; - if (begin < 0) begin = 0; - if (end > self->dimensions[0]) end = self->dimensions[0]; - if (begin > end) begin = end; + if (begin < 0) { + begin = 0; + } + if (end > self->dimensions[0]) { + end = self->dimensions[0]; + } + if (begin > end) { + begin = end; + } list = PyList_New(end - begin); @@ -916,9 +934,15 @@ static int Buffer_ass_slice(Buffer *self, int begin, int end, PyObject *seq) PyObject *item; int count, err = 0; - if (begin < 0) begin = 0; - if (end > self->dimensions[0]) end = self->dimensions[0]; - if (begin > end) begin = end; + if (begin < 0) { + begin = 0; + } + if (end > self->dimensions[0]) { + end = self->dimensions[0]; + } + if (begin > end) { + begin = end; + } if (!PySequence_Check(seq)) { PyErr_Format(PyExc_TypeError, @@ -957,17 +981,20 @@ static PyObject *Buffer_subscript(Buffer *self, PyObject *item) if (PyIndex_Check(item)) { Py_ssize_t i; i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; - if (i < 0) + } + if (i < 0) { i += self->dimensions[0]; + } return Buffer_item(self, i); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0) { return NULL; + } if (slicelength <= 0) { return PyTuple_New(0); @@ -993,20 +1020,24 @@ static int Buffer_ass_subscript(Buffer *self, PyObject *item, PyObject *value) { if (PyIndex_Check(item)) { Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return -1; - if (i < 0) + } + if (i < 0) { i += self->dimensions[0]; + } return Buffer_ass_item(self, i, value); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0) { return -1; + } - if (step == 1) + if (step == 1) { return Buffer_ass_slice(self, start, stop, value); + } else { PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors"); @@ -1390,8 +1421,9 @@ PyObject *BPyInit_bgl(void) submodule = PyModule_Create(&BGL_module_def); dict = PyModule_GetDict(submodule); - if (PyType_Ready(&BGL_bufferType) < 0) + if (PyType_Ready(&BGL_bufferType) < 0) { return NULL; /* should never happen */ + } PyModule_AddObject(submodule, "Buffer", (PyObject *)&BGL_bufferType); Py_INCREF((PyObject *)&BGL_bufferType); @@ -2554,8 +2586,9 @@ static PyObject *Method_ShaderSource(PyObject *UNUSED(self), PyObject *args) unsigned int shader; const char *source; - if (!PyArg_ParseTuple(args, "Is", &shader, &source)) + if (!PyArg_ParseTuple(args, "Is", &shader, &source)) { return NULL; + } glShaderSource(shader, 1, (const char **)&source, NULL); diff --git a/source/blender/python/generic/blf_py_api.c b/source/blender/python/generic/blf_py_api.c index 79ffb9aa892..9161e5d979b 100644 --- a/source/blender/python/generic/blf_py_api.c +++ b/source/blender/python/generic/blf_py_api.c @@ -50,8 +50,9 @@ static PyObject *py_blf_position(PyObject *UNUSED(self), PyObject *args) int fontid; float x, y, z; - if (!PyArg_ParseTuple(args, "ifff:blf.position", &fontid, &x, &y, &z)) + if (!PyArg_ParseTuple(args, "ifff:blf.position", &fontid, &x, &y, &z)) { return NULL; + } BLF_position(fontid, x, y, z); @@ -75,8 +76,9 @@ static PyObject *py_blf_size(PyObject *UNUSED(self), PyObject *args) { int fontid, size, dpi; - if (!PyArg_ParseTuple(args, "iii:blf.size", &fontid, &size, &dpi)) + if (!PyArg_ParseTuple(args, "iii:blf.size", &fontid, &size, &dpi)) { return NULL; + } BLF_size(fontid, size, dpi); @@ -99,8 +101,9 @@ static PyObject *py_blf_aspect(PyObject *UNUSED(self), PyObject *args) float aspect; int fontid; - if (!PyArg_ParseTuple(args, "if:blf.aspect", &fontid, &aspect)) + if (!PyArg_ParseTuple(args, "if:blf.aspect", &fontid, &aspect)) { return NULL; + } BLF_aspect(fontid, aspect, aspect, 1.0); @@ -157,8 +160,9 @@ static PyObject *py_blf_blur(PyObject *UNUSED(self), PyObject *args) { int blur, fontid; - if (!PyArg_ParseTuple(args, "ii:blf.blur", &fontid, &blur)) + if (!PyArg_ParseTuple(args, "ii:blf.blur", &fontid, &blur)) { return NULL; + } BLF_blur(fontid, blur); @@ -183,8 +187,9 @@ static PyObject *py_blf_draw(PyObject *UNUSED(self), PyObject *args) int text_length; int fontid; - if (!PyArg_ParseTuple(args, "is#:blf.draw", &fontid, &text, &text_length)) + if (!PyArg_ParseTuple(args, "is#:blf.draw", &fontid, &text, &text_length)) { return NULL; + } BLF_draw(fontid, text, (unsigned int)text_length); @@ -210,8 +215,9 @@ static PyObject *py_blf_dimensions(PyObject *UNUSED(self), PyObject *args) PyObject *ret; int fontid; - if (!PyArg_ParseTuple(args, "is:blf.dimensions", &fontid, &text)) + if (!PyArg_ParseTuple(args, "is:blf.dimensions", &fontid, &text)) { return NULL; + } BLF_width_and_height(fontid, text, INT_MAX, &r_width, &r_height); @@ -243,8 +249,9 @@ static PyObject *py_blf_clipping(PyObject *UNUSED(self), PyObject *args) float xmin, ymin, xmax, ymax; int fontid; - if (!PyArg_ParseTuple(args, "iffff:blf.clipping", &fontid, &xmin, &ymin, &xmax, &ymax)) + if (!PyArg_ParseTuple(args, "iffff:blf.clipping", &fontid, &xmin, &ymin, &xmax, &ymax)) { return NULL; + } BLF_clipping(fontid, xmin, ymin, xmax, ymax); @@ -266,8 +273,9 @@ static PyObject *py_blf_word_wrap(PyObject *UNUSED(self), PyObject *args) int wrap_width; int fontid; - if (!PyArg_ParseTuple(args, "ii:blf.word_wrap", &fontid, &wrap_width)) + if (!PyArg_ParseTuple(args, "ii:blf.word_wrap", &fontid, &wrap_width)) { return NULL; + } BLF_wordwrap(fontid, wrap_width); @@ -288,8 +296,9 @@ static PyObject *py_blf_disable(PyObject *UNUSED(self), PyObject *args) { int option, fontid; - if (!PyArg_ParseTuple(args, "ii:blf.disable", &fontid, &option)) + if (!PyArg_ParseTuple(args, "ii:blf.disable", &fontid, &option)) { return NULL; + } BLF_disable(fontid, option); @@ -310,8 +319,9 @@ static PyObject *py_blf_enable(PyObject *UNUSED(self), PyObject *args) { int option, fontid; - if (!PyArg_ParseTuple(args, "ii:blf.enable", &fontid, &option)) + if (!PyArg_ParseTuple(args, "ii:blf.enable", &fontid, &option)) { return NULL; + } BLF_enable(fontid, option); @@ -333,8 +343,9 @@ static PyObject *py_blf_rotation(PyObject *UNUSED(self), PyObject *args) float angle; int fontid; - if (!PyArg_ParseTuple(args, "if:blf.rotation", &fontid, &angle)) + if (!PyArg_ParseTuple(args, "if:blf.rotation", &fontid, &angle)) { return NULL; + } BLF_rotation(fontid, angle); @@ -397,8 +408,9 @@ static PyObject *py_blf_shadow_offset(PyObject *UNUSED(self), PyObject *args) { int x, y, fontid; - if (!PyArg_ParseTuple(args, "iii:blf.shadow_offset", &fontid, &x, &y)) + if (!PyArg_ParseTuple(args, "iii:blf.shadow_offset", &fontid, &x, &y)) { return NULL; + } BLF_shadow_offset(fontid, x, y); @@ -419,8 +431,9 @@ static PyObject *py_blf_load(PyObject *UNUSED(self), PyObject *args) { const char *filename; - if (!PyArg_ParseTuple(args, "s:blf.load", &filename)) + if (!PyArg_ParseTuple(args, "s:blf.load", &filename)) { return NULL; + } return PyLong_FromLong(BLF_load(filename)); } @@ -437,8 +450,9 @@ static PyObject *py_blf_unload(PyObject *UNUSED(self), PyObject *args) { const char *filename; - if (!PyArg_ParseTuple(args, "s:blf.unload", &filename)) + if (!PyArg_ParseTuple(args, "s:blf.unload", &filename)) { return NULL; + } BLF_unload(filename); diff --git a/source/blender/python/generic/bpy_internal_import.c b/source/blender/python/generic/bpy_internal_import.c index 96b5645f0e7..0baa4008f2d 100644 --- a/source/blender/python/generic/bpy_internal_import.c +++ b/source/blender/python/generic/bpy_internal_import.c @@ -180,8 +180,9 @@ PyObject *bpy_text_import_name(const char *name, int *found) } /* we know this cant be importable, the name is too long for blender! */ - if (namelen >= (MAX_ID_NAME - 2) - 3) + if (namelen >= (MAX_ID_NAME - 2) - 3) { return NULL; + } memcpy(txtname, name, namelen); memcpy(&txtname[namelen], ".py", 4); @@ -200,10 +201,12 @@ PyObject *bpy_text_import_name(const char *name, int *found) maggie = maggie->next; } - if (!text) + if (!text) { return NULL; - else + } + else { *found = 1; + } return bpy_text_import(text); } @@ -229,8 +232,9 @@ PyObject *bpy_text_reimport(PyObject *module, int *found) *found = 0; /* get name, filename from the module itself */ - if ((name = PyModule_GetName(module)) == NULL) + if ((name = PyModule_GetName(module)) == NULL) { return NULL; + } { PyObject *module_file = PyModule_GetFilenameObject(module); @@ -248,10 +252,12 @@ PyObject *bpy_text_reimport(PyObject *module, int *found) text = BLI_findstring(&maggie->texts, BLI_path_basename(filepath), offsetof(ID, name) + 2); /* uh-oh.... didn't find it */ - if (!text) + if (!text) { return NULL; - else + } + else { *found = 1; + } if (bpy_text_compile(text) == false) { return NULL; @@ -283,8 +289,9 @@ static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObject /* import existing builtin modules or modules that have been imported already */ newmodule = PyImport_ImportModuleLevel(name, globals, locals, fromlist, level); - if (newmodule) + if (newmodule) { return newmodule; + } PyErr_Fetch(&exception, &err, &tb); /* get the python error in case we cant import as blender text either */ @@ -330,8 +337,9 @@ static PyObject *blender_reload(PyObject *UNUSED(self), PyObject *module) newmodule = PyObject_CallFunctionObjArgs(imp_reload_orig, module, NULL); - if (newmodule) + if (newmodule) { return newmodule; + } /* no file, try importing from memory */ PyErr_Fetch(&exception, &err, &tb); /*restore for probable later use */ diff --git a/source/blender/python/generic/idprop_py_api.c b/source/blender/python/generic/idprop_py_api.c index 6c5177d4759..f18d02a4405 100644 --- a/source/blender/python/generic/idprop_py_api.c +++ b/source/blender/python/generic/idprop_py_api.c @@ -419,11 +419,17 @@ static int idp_array_type_from_formatstr_and_size(const char *typestr, Py_ssize_ char format = PyC_StructFmt_type_from_str(typestr); if (PyC_StructFmt_type_is_float_any(format)) { - if (itemsize == 4) return IDP_FLOAT; - if (itemsize == 8) return IDP_DOUBLE; + if (itemsize == 4) { + return IDP_FLOAT; + } + if (itemsize == 8) { + return IDP_DOUBLE; + } } if (PyC_StructFmt_type_is_int_any(format)) { - if (itemsize == 4) return IDP_INT; + if (itemsize == 4) { + return IDP_INT; + } } return -1; @@ -431,9 +437,15 @@ static int idp_array_type_from_formatstr_and_size(const char *typestr, Py_ssize_ static const char *idp_format_from_array_type(int type) { - if (type == IDP_INT) return "i"; - if (type == IDP_FLOAT) return "f"; - if (type == IDP_DOUBLE) return "d"; + if (type == IDP_INT) { + return "i"; + } + if (type == IDP_FLOAT) { + return "f"; + } + if (type == IDP_DOUBLE) { + return "d"; + } return NULL; } @@ -936,8 +948,9 @@ PyObject *BPy_Wrap_GetKeys(IDProperty *prop) IDProperty *loop; int i; - for (i = 0, loop = prop->data.group.first; loop && (i < prop->len); loop = loop->next, i++) + for (i = 0, loop = prop->data.group.first; loop && (i < prop->len); loop = loop->next, i++) { PyList_SET_ITEM(list, i, PyUnicode_FromString(loop->name)); + } /* if the id prop is corrupt, count the remaining */ for ( ; loop; loop = loop->next, i++) { @@ -1067,7 +1080,9 @@ static PyObject *BPy_IDGroup_update(BPy_IDProperty *self, PyObject *value) else if (PyDict_Check(value)) { while (PyDict_Next(value, &i, &pkey, &pval)) { BPy_IDGroup_Map_SetItem(self, pkey, pval); - if (PyErr_Occurred()) return NULL; + if (PyErr_Occurred()) { + return NULL; + } } } else { @@ -1113,14 +1128,16 @@ static PyObject *BPy_IDGroup_get(BPy_IDProperty *self, PyObject *args) const char *key; PyObject *def = Py_None; - if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) + if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) { return NULL; + } idprop = IDP_GetPropertyFromGroup(self->prop, key); if (idprop) { PyObject *pyobj = BPy_IDGroup_WrapData(self->id, idprop, self->prop); - if (pyobj) + if (pyobj) { return pyobj; + } } Py_INCREF(def); @@ -1376,7 +1393,9 @@ static PyObject *BPy_IDArray_slice(BPy_IDArray *self, int begin, int end) int count; CLAMP(begin, 0, prop->len); - if (end < 0) end = prop->len + end + 1; + if (end < 0) { + end = prop->len + end + 1; + } CLAMP(end, 0, prop->len); begin = MIN2(begin, end); @@ -1446,17 +1465,20 @@ static PyObject *BPy_IDArray_subscript(BPy_IDArray *self, PyObject *item) if (PyIndex_Check(item)) { Py_ssize_t i; i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; - if (i < 0) + } + if (i < 0) { i += self->prop->len; + } return BPy_IDArray_GetItem(self, i); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, self->prop->len, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, self->prop->len, &start, &stop, &step, &slicelength) < 0) { return NULL; + } if (slicelength <= 0) { return PyTuple_New(0); @@ -1481,20 +1503,24 @@ static int BPy_IDArray_ass_subscript(BPy_IDArray *self, PyObject *item, PyObject { if (PyIndex_Check(item)) { Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return -1; - if (i < 0) + } + if (i < 0) { i += self->prop->len; + } return BPy_IDArray_SetItem(self, i, value); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, self->prop->len, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, self->prop->len, &start, &stop, &step, &slicelength) < 0) { return -1; + } - if (step == 1) + if (step == 1) { return BPy_IDArray_ass_slice(self, start, stop, value); + } else { PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors"); return -1; @@ -1516,9 +1542,9 @@ static PyMappingMethods BPy_IDArray_AsMapping = { static int itemsize_by_idarray_type(int array_type) { - if (array_type == IDP_INT) return sizeof(int); - if (array_type == IDP_FLOAT) return sizeof(float); - if (array_type == IDP_DOUBLE) return sizeof(double); + if (array_type == IDP_INT) { return sizeof(int); } + if (array_type == IDP_FLOAT) { return sizeof(float); } + if (array_type == IDP_DOUBLE) { return sizeof(double); } return -1; /* should never happen */ } diff --git a/source/blender/python/generic/py_capi_utils.c b/source/blender/python/generic/py_capi_utils.c index f18e794ead3..0c10737609c 100644 --- a/source/blender/python/generic/py_capi_utils.c +++ b/source/blender/python/generic/py_capi_utils.c @@ -319,8 +319,12 @@ void PyC_FileAndNum(const char **filename, int *lineno) { PyFrameObject *frame; - if (filename) *filename = NULL; - if (lineno) *lineno = -1; + if (filename) { + *filename = NULL; + } + if (lineno) { + *lineno = -1; + } if (!(frame = PyThreadState_GET()->frame)) { return; @@ -384,10 +388,13 @@ PyObject *PyC_Object_GetAttrStringArgs(PyObject *o, Py_ssize_t n, ...) attr = va_arg(vargs, char *); item = PyObject_GetAttrString(item, attr); - if (item) + if (item) { Py_DECREF(item); - else /* python will set the error value here */ + } + else { + /* python will set the error value here */ break; + } } va_end(vargs); @@ -527,8 +534,9 @@ PyObject *PyC_ExceptionBuffer(void) PyObject *error_type, *error_value, *error_traceback; - if (!PyErr_Occurred()) + if (!PyErr_Occurred()) { return NULL; + } PyErr_Fetch(&error_type, &error_value, &error_traceback); @@ -593,8 +601,9 @@ PyObject *PyC_ExceptionBuffer_Simple(void) PyObject *error_type, *error_value, *error_traceback; - if (!PyErr_Occurred()) + if (!PyErr_Occurred()) { return NULL; + } PyErr_Fetch(&error_type, &error_value, &error_traceback); @@ -775,9 +784,10 @@ void PyC_SetHomePath(const char *py_path_bundle) #ifdef __APPLE__ /* OSX allow file/directory names to contain : character (represented as / in the Finder) * but current Python lib (release 3.1.1) doesn't handle these correctly */ - if (strchr(py_path_bundle, ':')) + if (strchr(py_path_bundle, ':')) { printf("Warning : Blender application is located in a path containing : or / chars\ \nThis may make python import function fail\n"); + } #endif diff --git a/source/blender/python/gpu/gpu_py_offscreen.c b/source/blender/python/gpu/gpu_py_offscreen.c index 5482677defc..cd9e162b1aa 100644 --- a/source/blender/python/gpu/gpu_py_offscreen.c +++ b/source/blender/python/gpu/gpu_py_offscreen.c @@ -299,8 +299,9 @@ static PyObject *bpygpu_offscreen_bind_context_exit(BPyGPUOffScreen *self, PyObj static void BPyGPUOffScreen__tp_dealloc(BPyGPUOffScreen *self) { - if (self->ofs) + if (self->ofs) { GPU_offscreen_free(self->ofs); + } Py_TYPE(self)->tp_free((PyObject *)self); } diff --git a/source/blender/python/gpu/gpu_py_types.c b/source/blender/python/gpu/gpu_py_types.c index 7ed1832eb57..67bdc070168 100644 --- a/source/blender/python/gpu/gpu_py_types.c +++ b/source/blender/python/gpu/gpu_py_types.c @@ -45,18 +45,24 @@ PyObject *BPyInit_gpu_types(void) submodule = PyModule_Create(&BPyGPU_types_module_def); - if (PyType_Ready(&BPyGPUVertFormat_Type) < 0) + if (PyType_Ready(&BPyGPUVertFormat_Type) < 0) { return NULL; - if (PyType_Ready(&BPyGPUVertBuf_Type) < 0) + } + if (PyType_Ready(&BPyGPUVertBuf_Type) < 0) { return NULL; - if (PyType_Ready(&BPyGPUIndexBuf_Type) < 0) + } + if (PyType_Ready(&BPyGPUIndexBuf_Type) < 0) { return NULL; - if (PyType_Ready(&BPyGPUBatch_Type) < 0) + } + if (PyType_Ready(&BPyGPUBatch_Type) < 0) { return NULL; - if (PyType_Ready(&BPyGPUOffScreen_Type) < 0) + } + if (PyType_Ready(&BPyGPUOffScreen_Type) < 0) { return NULL; - if (PyType_Ready(&BPyGPUShader_Type) < 0) + } + if (PyType_Ready(&BPyGPUShader_Type) < 0) { return NULL; + } #define MODULE_TYPE_ADD(s, t) \ PyModule_AddObject(s, t.tp_name, (PyObject *)&t); Py_INCREF((PyObject *)&t) diff --git a/source/blender/python/intern/bpy.c b/source/blender/python/intern/bpy.c index 55d226e1461..f67ed1a3713 100644 --- a/source/blender/python/intern/bpy.c +++ b/source/blender/python/intern/bpy.c @@ -126,9 +126,15 @@ static PyObject *bpy_blend_paths(PyObject *UNUSED(self), PyObject *args, PyObjec return NULL; } - if (absolute) flag |= BKE_BPATH_TRAVERSE_ABS; - if (!packed) flag |= BKE_BPATH_TRAVERSE_SKIP_PACKED; - if (local) flag |= BKE_BPATH_TRAVERSE_SKIP_LIBRARY; + if (absolute) { + flag |= BKE_BPATH_TRAVERSE_ABS; + } + if (!packed) { + flag |= BKE_BPATH_TRAVERSE_SKIP_PACKED; + } + if (local) { + flag |= BKE_BPATH_TRAVERSE_SKIP_LIBRARY; + } list = PyList_New(0); @@ -157,10 +163,10 @@ static PyObject *bpy_user_resource(PyObject *UNUSED(self), PyObject *args, PyObj } /* stupid string compare */ - if (STREQ(type, "DATAFILES")) folder_id = BLENDER_USER_DATAFILES; - else if (STREQ(type, "CONFIG")) folder_id = BLENDER_USER_CONFIG; - else if (STREQ(type, "SCRIPTS")) folder_id = BLENDER_USER_SCRIPTS; - else if (STREQ(type, "AUTOSAVE")) folder_id = BLENDER_USER_AUTOSAVE; + if (STREQ(type, "DATAFILES")) { folder_id = BLENDER_USER_DATAFILES; } + else if (STREQ(type, "CONFIG")) { folder_id = BLENDER_USER_CONFIG; } + else if (STREQ(type, "SCRIPTS")) { folder_id = BLENDER_USER_SCRIPTS; } + else if (STREQ(type, "AUTOSAVE")) { folder_id = BLENDER_USER_AUTOSAVE; } else { PyErr_SetString(PyExc_ValueError, "invalid resource argument"); return NULL; @@ -203,9 +209,9 @@ static PyObject *bpy_resource_path(PyObject *UNUSED(self), PyObject *args, PyObj } /* stupid string compare */ - if (STREQ(type, "USER")) folder_id = BLENDER_RESOURCE_PATH_USER; - else if (STREQ(type, "LOCAL")) folder_id = BLENDER_RESOURCE_PATH_LOCAL; - else if (STREQ(type, "SYSTEM")) folder_id = BLENDER_RESOURCE_PATH_SYSTEM; + if (STREQ(type, "USER")) { folder_id = BLENDER_RESOURCE_PATH_USER; } + else if (STREQ(type, "LOCAL")) { folder_id = BLENDER_RESOURCE_PATH_LOCAL; } + else if (STREQ(type, "SYSTEM")) { folder_id = BLENDER_RESOURCE_PATH_SYSTEM; } else { PyErr_SetString(PyExc_ValueError, "invalid resource argument"); return NULL; diff --git a/source/blender/python/intern/bpy_app.c b/source/blender/python/intern/bpy_app.c index 252fd1b3e23..2cd3086dae1 100644 --- a/source/blender/python/intern/bpy_app.c +++ b/source/blender/python/intern/bpy_app.c @@ -253,8 +253,12 @@ static int bpy_app_debug_set(PyObject *UNUSED(self), PyObject *value, void *clos return -1; } - if (param) G.debug |= flag; - else G.debug &= ~flag; + if (param) { + G.debug |= flag; + } + else { + G.debug &= ~flag; + } return 0; } @@ -278,8 +282,12 @@ static int bpy_app_global_flag_set(PyObject *UNUSED(self), PyObject *value, void return -1; } - if (param) G.f |= flag; - else G.f &= ~flag; + if (param) { + G.f |= flag; + } + else { + G.f &= ~flag; + } return 0; } diff --git a/source/blender/python/intern/bpy_app_handlers.c b/source/blender/python/intern/bpy_app_handlers.c index b6b9f294810..c91c0d69a16 100644 --- a/source/blender/python/intern/bpy_app_handlers.c +++ b/source/blender/python/intern/bpy_app_handlers.c @@ -90,8 +90,9 @@ static PyObject *bpy_app_handlers_persistent_new(PyTypeObject *UNUSED(type), PyO { PyObject *value; - if (!PyArg_ParseTuple(args, "O:bpy.app.handlers.persistent", &value)) + if (!PyArg_ParseTuple(args, "O:bpy.app.handlers.persistent", &value)) { return NULL; + } if (PyFunction_Check(value)) { PyObject **dict_ptr = _PyObject_GetDictPtr(value); diff --git a/source/blender/python/intern/bpy_app_translations.c b/source/blender/python/intern/bpy_app_translations.c index 1ed68201a2e..f571caee8ec 100644 --- a/source/blender/python/intern/bpy_app_translations.c +++ b/source/blender/python/intern/bpy_app_translations.c @@ -89,8 +89,9 @@ static bool _ghashutil_keycmp(const void *a, const void *b) const GHashKey *B = b; /* Note: comparing msgid first, most of the time it will be enough! */ - if (BLI_ghashutil_strcmp(A->msgid, B->msgid) == false) + if (BLI_ghashutil_strcmp(A->msgid, B->msgid) == false) { return BLI_ghashutil_strcmp(A->msgctxt, B->msgctxt); + } return true; /* true means they are not equal! */ } @@ -249,8 +250,9 @@ const char *BPY_app_translations_py_pgettext(const char *msgctxt, const char *ms const char *tmp; /* Just in case, should never happen! */ - if (!_translations) + if (!_translations) { return msgid; + } tmp = BLT_lang_get(); if (!STREQ(tmp, locale) || !_translations_cache) { @@ -458,8 +460,9 @@ static PyObject *app_translations_locales_get(PyObject *UNUSED(self), void *UNUS if (items) { /* This is not elegant, but simple! */ for (it = items; it->identifier; it++) { - if (it->value) + if (it->value) { num_locales++; + } } } @@ -467,8 +470,9 @@ static PyObject *app_translations_locales_get(PyObject *UNUSED(self), void *UNUS if (items) { for (it = items; it->identifier; it++) { - if (it->value) + if (it->value) { PyTuple_SET_ITEM(ret, pos++, PyUnicode_FromString(it->description)); + } } } @@ -801,8 +805,9 @@ PyObject *BPY_app_translations_struct(void) PyStructSequence_InitType(&BlenderAppTranslationsContextsType, &app_translations_contexts_desc); } - if (PyType_Ready(&BlenderAppTranslationsType) < 0) + if (PyType_Ready(&BlenderAppTranslationsType) < 0) { return NULL; + } ret = PyObject_CallObject((PyObject *)&BlenderAppTranslationsType, NULL); diff --git a/source/blender/python/intern/bpy_capi_utils.c b/source/blender/python/intern/bpy_capi_utils.c index 3a5b3077ee6..549a06f5b28 100644 --- a/source/blender/python/intern/bpy_capi_utils.c +++ b/source/blender/python/intern/bpy_capi_utils.c @@ -48,8 +48,9 @@ char *BPy_enum_as_string(const EnumPropertyItem *item) char *cstring; for (e = item; item->identifier; item++) { - if (item->identifier[0]) + if (item->identifier[0]) { BLI_dynstr_appendf(dynstr, (e == item) ? "'%s'" : ", '%s'", item->identifier); + } } cstring = BLI_dynstr_get_cstring(dynstr); @@ -93,8 +94,9 @@ bool BPy_errors_to_report_ex(ReportList *reports, const bool use_full, const boo { PyObject *pystring; - if (!PyErr_Occurred()) + if (!PyErr_Occurred()) { return 1; + } /* less hassle if we allow NULL */ if (reports == NULL) { diff --git a/source/blender/python/intern/bpy_driver.c b/source/blender/python/intern/bpy_driver.c index 93d9225ad01..cb23739ca33 100644 --- a/source/blender/python/intern/bpy_driver.c +++ b/source/blender/python/intern/bpy_driver.c @@ -69,13 +69,17 @@ int bpy_pydriver_create_dict(void) PyObject *d, *mod; /* validate namespace for driver evaluation */ - if (bpy_pydriver_Dict) return -1; + if (bpy_pydriver_Dict) { + return -1; + } d = PyDict_New(); - if (d == NULL) + if (d == NULL) { return -1; - else + } + else { bpy_pydriver_Dict = d; + } /* import some modules: builtins, bpy, math, (Blender.noise)*/ PyDict_SetItemString(d, "__builtins__", PyEval_GetBuiltins()); @@ -205,8 +209,9 @@ void BPY_driver_reset(void) PyGILState_STATE gilstate; bool use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } if (bpy_pydriver_Dict) { /* free the global dict used by pydrivers */ PyDict_Clear(bpy_pydriver_Dict); @@ -227,8 +232,9 @@ void BPY_driver_reset(void) /* freed when clearing driver dict */ g_pydriver_state_prev.self = NULL; - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } return; } @@ -399,8 +405,9 @@ float BPY_driver_exec(struct PathResolvedRNA *anim_rna, ChannelDriver *driver, C /* get the py expression to be evaluated */ expr = driver_orig->expression; - if (expr[0] == '\0') + if (expr[0] == '\0') { return 0.0f; + } #ifndef USE_BYTECODE_WHITELIST if (!(G.f & G_FLAG_SCRIPT_AUTOEXEC)) { @@ -418,8 +425,9 @@ float BPY_driver_exec(struct PathResolvedRNA *anim_rna, ChannelDriver *driver, C use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } /* needed since drivers are updated directly after undo where 'main' is * re-allocated [#28807] */ @@ -429,8 +437,9 @@ float BPY_driver_exec(struct PathResolvedRNA *anim_rna, ChannelDriver *driver, C if (!bpy_pydriver_Dict) { if (bpy_pydriver_create_dict() != 0) { fprintf(stderr, "PyDriver error: couldn't create Python dictionary\n"); - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } return 0.0f; } } @@ -445,8 +454,9 @@ float BPY_driver_exec(struct PathResolvedRNA *anim_rna, ChannelDriver *driver, C bpy_pydriver_namespace_clear_self(); } - if (driver_orig->expr_comp == NULL) + if (driver_orig->expr_comp == NULL) { driver_orig->flag |= DRIVER_FLAG_RECOMPILE; + } /* compile the expression first if it hasn't been compiled or needs to be rebuilt */ if (driver_orig->flag & DRIVER_FLAG_RECOMPILE) { @@ -571,8 +581,9 @@ float BPY_driver_exec(struct PathResolvedRNA *anim_rna, ChannelDriver *driver, C retval = PyRun_String(expr, Py_eval_input, bpy_pydriver_Dict, driver_vars); #else /* evaluate the compiled expression */ - if (expr_code) + if (expr_code) { retval = PyEval_EvalCode((void *)expr_code, bpy_pydriver_Dict, driver_vars); + } #endif /* decref the driver vars first... */ @@ -593,8 +604,9 @@ float BPY_driver_exec(struct PathResolvedRNA *anim_rna, ChannelDriver *driver, C Py_DECREF(retval); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (isfinite(result)) { return (float)result; diff --git a/source/blender/python/intern/bpy_interface.c b/source/blender/python/intern/bpy_interface.c index 189fb97f3d2..e07e39642e9 100644 --- a/source/blender/python/intern/bpy_interface.c +++ b/source/blender/python/intern/bpy_interface.c @@ -98,8 +98,9 @@ void BPY_context_update(bContext *C) /* don't do this from a non-main (e.g. render) thread, it can cause a race * condition on C->data.recursion. ideal solution would be to disable * context entirely from non-main threads, but that's more complicated */ - if (!BLI_thread_is_main()) + if (!BLI_thread_is_main()) { return; + } BPy_SetContext(C); bpy_import_main_set(CTX_data_main(C)); @@ -110,8 +111,9 @@ void bpy_context_set(bContext *C, PyGILState_STATE *gilstate) { py_call_level++; - if (gilstate) + if (gilstate) { *gilstate = PyGILState_Ensure(); + } if (py_call_level == 1) { BPY_context_update(C); @@ -135,8 +137,9 @@ void bpy_context_clear(bContext *UNUSED(C), PyGILState_STATE *gilstate) { py_call_level--; - if (gilstate) + if (gilstate) { PyGILState_Release(*gilstate); + } if (py_call_level < 0) { fprintf(stderr, "ERROR: Python context internal state bug. this should not happen!\n"); @@ -163,14 +166,16 @@ void BPY_text_free_code(Text *text) PyGILState_STATE gilstate; bool use_gil = !PyC_IsInterpreterActive(); - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } Py_DECREF((PyObject *)text->compiled); text->compiled = NULL; - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } } } @@ -184,8 +189,9 @@ void BPY_modules_update(bContext *C) /* refreshes the main struct */ BPY_update_rna_module(); - if (bpy_context_module) + if (bpy_context_module) { bpy_context_module->ptr.data = (void *)C; + } } void BPY_context_set(bContext *C) @@ -371,11 +377,13 @@ void BPY_python_end(void) printf("*bpy stats* - "); printf("tot exec: %d, ", bpy_timer_count); printf("tot run: %.4fsec, ", bpy_timer_run_tot); - if (bpy_timer_count > 0) + if (bpy_timer_count > 0) { printf("average run: %.6fsec, ", (bpy_timer_run_tot / bpy_timer_count)); + } - if (bpy_timer > 0.0) + if (bpy_timer > 0.0) { printf("tot usage %.4f%%", (bpy_timer_run_tot / bpy_timer) * 100.0); + } printf("\n"); @@ -750,8 +758,9 @@ void BPY_modules_load_user(bContext *C) Text *text; /* can happen on file load */ - if (bmain == NULL) + if (bmain == NULL) { return; + } /* update pointers since this can run from a nested script * on file load */ @@ -802,8 +811,9 @@ int BPY_context_member_get(bContext *C, const char *member, bContextDataResult * PointerRNA *ptr = NULL; bool done = false; - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } pyctx = (PyObject *)CTX_py_dict_get(C); item = PyDict_GetItemString(pyctx, member); @@ -870,8 +880,9 @@ int BPY_context_member_get(bContext *C, const char *member, bContextDataResult * CLOG_INFO(BPY_LOG_CONTEXT, 2, "'%s' found", member); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } return done; } @@ -971,8 +982,9 @@ PyInit_bpy(void) dealloc_obj_Type.tp_dealloc = dealloc_obj_dealloc; dealloc_obj_Type.tp_flags = Py_TPFLAGS_DEFAULT; - if (PyType_Ready(&dealloc_obj_Type) < 0) + if (PyType_Ready(&dealloc_obj_Type) < 0) { return NULL; + } dob = (dealloc_obj *) dealloc_obj_Type.tp_alloc(&dealloc_obj_Type, 0); dob->mod = bpy_proxy; /* borrow */ diff --git a/source/blender/python/intern/bpy_library_load.c b/source/blender/python/intern/bpy_library_load.c index bf12db0f3a1..77fb6bf1525 100644 --- a/source/blender/python/intern/bpy_library_load.c +++ b/source/blender/python/intern/bpy_library_load.c @@ -476,8 +476,9 @@ int BPY_library_load_module(PyObject *mod_par) /* some compilers don't like accessing this directly, delay assignment */ bpy_lib_Type.tp_getattro = PyObject_GenericGetAttr; - if (PyType_Ready(&bpy_lib_Type) < 0) + if (PyType_Ready(&bpy_lib_Type) < 0) { return -1; + } return 0; } diff --git a/source/blender/python/intern/bpy_operator.c b/source/blender/python/intern/bpy_operator.c index 98b2f871c54..ff6bd3840e9 100644 --- a/source/blender/python/intern/bpy_operator.c +++ b/source/blender/python/intern/bpy_operator.c @@ -93,8 +93,9 @@ static PyObject *pyop_poll(PyObject *UNUSED(self), PyObject *args) return NULL; } - if (!PyArg_ParseTuple(args, "s|Os:_bpy.ops.poll", &opname, &context_dict, &context_str)) + if (!PyArg_ParseTuple(args, "s|Os:_bpy.ops.poll", &opname, &context_dict, &context_str)) { return NULL; + } ot = WM_operatortype_find(opname, true); @@ -362,8 +363,9 @@ static PyObject *pyop_as_string(PyObject *UNUSED(self), PyObject *args) error_val = pyrna_pydict_to_props(&ptr, kw, false, "Converting py args to operator properties: "); } - if (error_val == 0) + if (error_val == 0) { buf = WM_operator_pystring_ex(C, NULL, all_args, macro_args, ot, &ptr); + } WM_operator_properties_free(&ptr); diff --git a/source/blender/python/intern/bpy_operator_wrap.c b/source/blender/python/intern/bpy_operator_wrap.c index 6f1450fcbc2..6a130a7c52b 100644 --- a/source/blender/python/intern/bpy_operator_wrap.c +++ b/source/blender/python/intern/bpy_operator_wrap.c @@ -162,8 +162,9 @@ PyObject *PYOP_wrap_macro_define(PyObject *UNUSED(self), PyObject *args) const char *opname; const char *macroname; - if (!PyArg_ParseTuple(args, "Os:_bpy.ops.macro_define", ¯o, &opname)) + if (!PyArg_ParseTuple(args, "Os:_bpy.ops.macro_define", ¯o, &opname)) { return NULL; + } if (WM_operatortype_find(opname, true) == NULL) { PyErr_Format(PyExc_ValueError, diff --git a/source/blender/python/intern/bpy_props.c b/source/blender/python/intern/bpy_props.c index 385b02f231e..18a39f39e70 100644 --- a/source/blender/python/intern/bpy_props.c +++ b/source/blender/python/intern/bpy_props.c @@ -201,10 +201,12 @@ static PyObject *bpy_prop_deferred_return(PyObject *func, PyObject *kw) PyTuple_SET_ITEM(ret, 0, func); Py_INCREF(func); - if (kw == NULL) + if (kw == NULL) { kw = PyDict_New(); - else + } + else { Py_INCREF(kw); + } PyTuple_SET_ITEM(ret, 1, kw); @@ -282,8 +284,9 @@ static bool bpy_prop_boolean_get_cb(struct PointerRNA *ptr, struct PropertyRNA * use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_GET]; @@ -313,8 +316,9 @@ static bool bpy_prop_boolean_get_cb(struct PointerRNA *ptr, struct PropertyRNA * Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -342,8 +346,9 @@ static void bpy_prop_boolean_set_cb(struct PointerRNA *ptr, struct PropertyRNA * use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_SET]; @@ -369,8 +374,9 @@ static void bpy_prop_boolean_set_cb(struct PointerRNA *ptr, struct PropertyRNA * Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -395,8 +401,9 @@ static bool bpy_prop_poll_cb(struct PointerRNA *self, PointerRNA candidate, stru py_candidate = pyrna_struct_as_instance(&candidate); py_func = py_data[BPY_DATA_CB_SLOT_POLL]; - if (!is_write_ok) + if (!is_write_ok) { pyrna_write_set(true); + } args = PyTuple_New(2); PyTuple_SET_ITEM(args, 0, py_self); @@ -416,8 +423,9 @@ static bool bpy_prop_poll_cb(struct PointerRNA *self, PointerRNA candidate, stru } PyGILState_Release(gilstate); - if (!is_write_ok) + if (!is_write_ok) { pyrna_write_set(false); + } return result; } @@ -442,8 +450,9 @@ static void bpy_prop_boolean_array_get_cb(struct PointerRNA *ptr, struct Propert use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_GET]; @@ -458,15 +467,17 @@ static void bpy_prop_boolean_array_get_cb(struct PointerRNA *ptr, struct Propert if (ret == NULL) { PyC_Err_PrintWithFunc(py_func); - for (i = 0; i < len; ++i) + for (i = 0; i < len; ++i) { values[i] = false; + } } else { if (PyC_AsArray(values, ret, len, &PyBool_Type, false, "BoolVectorProperty get") == -1) { PyC_Err_PrintWithFunc(py_func); - for (i = 0; i < len; ++i) + for (i = 0; i < len; ++i) { values[i] = false; + } /* PyC_AsArray decrements refcount internally on error */ } @@ -475,8 +486,9 @@ static void bpy_prop_boolean_array_get_cb(struct PointerRNA *ptr, struct Propert } } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -504,8 +516,9 @@ static void bpy_prop_boolean_array_set_cb(struct PointerRNA *ptr, struct Propert use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_SET]; @@ -532,8 +545,9 @@ static void bpy_prop_boolean_array_set_cb(struct PointerRNA *ptr, struct Propert Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -560,8 +574,9 @@ static int bpy_prop_int_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop) use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_GET]; @@ -588,8 +603,9 @@ static int bpy_prop_int_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop) Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -617,8 +633,9 @@ static void bpy_prop_int_set_cb(struct PointerRNA *ptr, struct PropertyRNA *prop use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_SET]; @@ -644,8 +661,9 @@ static void bpy_prop_int_set_cb(struct PointerRNA *ptr, struct PropertyRNA *prop Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -672,8 +690,9 @@ static void bpy_prop_int_array_get_cb(struct PointerRNA *ptr, struct PropertyRNA use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_GET]; @@ -688,15 +707,17 @@ static void bpy_prop_int_array_get_cb(struct PointerRNA *ptr, struct PropertyRNA if (ret == NULL) { PyC_Err_PrintWithFunc(py_func); - for (i = 0; i < len; ++i) + for (i = 0; i < len; ++i) { values[i] = 0; + } } else { if (PyC_AsArray(values, ret, len, &PyLong_Type, false, "IntVectorProperty get") == -1) { PyC_Err_PrintWithFunc(py_func); - for (i = 0; i < len; ++i) + for (i = 0; i < len; ++i) { values[i] = 0; + } /* PyC_AsArray decrements refcount internally on error */ } @@ -705,8 +726,9 @@ static void bpy_prop_int_array_get_cb(struct PointerRNA *ptr, struct PropertyRNA } } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -734,8 +756,9 @@ static void bpy_prop_int_array_set_cb(struct PointerRNA *ptr, struct PropertyRNA use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_SET]; @@ -762,8 +785,9 @@ static void bpy_prop_int_array_set_cb(struct PointerRNA *ptr, struct PropertyRNA Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -790,8 +814,9 @@ static float bpy_prop_float_get_cb(struct PointerRNA *ptr, struct PropertyRNA *p use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_GET]; @@ -818,8 +843,9 @@ static float bpy_prop_float_get_cb(struct PointerRNA *ptr, struct PropertyRNA *p Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -847,8 +873,9 @@ static void bpy_prop_float_set_cb(struct PointerRNA *ptr, struct PropertyRNA *pr use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_SET]; @@ -874,8 +901,9 @@ static void bpy_prop_float_set_cb(struct PointerRNA *ptr, struct PropertyRNA *pr Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -902,8 +930,9 @@ static void bpy_prop_float_array_get_cb(struct PointerRNA *ptr, struct PropertyR use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_GET]; @@ -918,15 +947,17 @@ static void bpy_prop_float_array_get_cb(struct PointerRNA *ptr, struct PropertyR if (ret == NULL) { PyC_Err_PrintWithFunc(py_func); - for (i = 0; i < len; ++i) + for (i = 0; i < len; ++i) { values[i] = 0.0f; + } } else { if (PyC_AsArray(values, ret, len, &PyFloat_Type, false, "FloatVectorProperty get") == -1) { PyC_Err_PrintWithFunc(py_func); - for (i = 0; i < len; ++i) + for (i = 0; i < len; ++i) { values[i] = 0.0f; + } /* PyC_AsArray decrements refcount internally on error */ } @@ -935,8 +966,9 @@ static void bpy_prop_float_array_get_cb(struct PointerRNA *ptr, struct PropertyR } } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -964,8 +996,9 @@ static void bpy_prop_float_array_set_cb(struct PointerRNA *ptr, struct PropertyR use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_SET]; @@ -992,8 +1025,9 @@ static void bpy_prop_float_array_set_cb(struct PointerRNA *ptr, struct PropertyR Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -1019,8 +1053,9 @@ static void bpy_prop_string_get_cb(struct PointerRNA *ptr, struct PropertyRNA *p use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_GET]; @@ -1051,8 +1086,9 @@ static void bpy_prop_string_get_cb(struct PointerRNA *ptr, struct PropertyRNA *p Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -1079,8 +1115,9 @@ static int bpy_prop_string_length_cb(struct PointerRNA *ptr, struct PropertyRNA use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_GET]; @@ -1111,8 +1148,9 @@ static int bpy_prop_string_length_cb(struct PointerRNA *ptr, struct PropertyRNA Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -1141,8 +1179,9 @@ static void bpy_prop_string_set_cb(struct PointerRNA *ptr, struct PropertyRNA *p use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_SET]; @@ -1155,8 +1194,9 @@ static void bpy_prop_string_set_cb(struct PointerRNA *ptr, struct PropertyRNA *p PyErr_SetString(PyExc_ValueError, "the return value must be a string"); PyC_Err_PrintWithFunc(py_func); } - else + else { PyTuple_SET_ITEM(args, 1, py_value); + } ret = PyObject_CallObject(py_func, args); @@ -1174,8 +1214,9 @@ static void bpy_prop_string_set_cb(struct PointerRNA *ptr, struct PropertyRNA *p Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -1202,8 +1243,9 @@ static int bpy_prop_enum_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_GET]; @@ -1230,8 +1272,9 @@ static int bpy_prop_enum_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -1259,8 +1302,9 @@ static void bpy_prop_enum_set_cb(struct PointerRNA *ptr, struct PropertyRNA *pro use_gil = true; /* !PyC_IsInterpreterActive(); */ - if (use_gil) + if (use_gil) { gilstate = PyGILState_Ensure(); + } py_func = py_data[BPY_DATA_CB_SLOT_SET]; @@ -1286,8 +1330,9 @@ static void bpy_prop_enum_set_cb(struct PointerRNA *ptr, struct PropertyRNA *pro Py_DECREF(ret); } - if (use_gil) + if (use_gil) { PyGILState_Release(gilstate); + } if (!is_write_ok) { pyrna_write_set(false); @@ -1423,8 +1468,9 @@ static const EnumPropertyItem *enum_items_from_py(PyObject *seq_fast, PyObject * } } - if (tmp_icon) + if (tmp_icon) { tmp.icon = icon_id_from_name(tmp_icon); + } items[i] = tmp; @@ -2139,8 +2185,9 @@ static PyObject *BPy_BoolVectorProperty(PyObject *self, PyObject *args, PyObject return NULL; } - if (pydef && PyC_AsArray(def, pydef, size, &PyBool_Type, false, "BoolVectorProperty(default=sequence)") == -1) + if (pydef && PyC_AsArray(def, pydef, size, &PyBool_Type, false, "BoolVectorProperty(default=sequence)") == -1) { return NULL; + } if (bpy_prop_callback_check(update_cb, "update", 2) == -1) { return NULL; @@ -2155,7 +2202,9 @@ static PyObject *BPy_BoolVectorProperty(PyObject *self, PyObject *args, PyObject // prop = RNA_def_boolean_array(srna, id, size, pydef ? def:NULL, name ? name : id, description); prop = RNA_def_property(srna, id, PROP_BOOLEAN, subtype); RNA_def_property_array(prop, size); - if (pydef) RNA_def_property_boolean_array_default(prop, def); + if (pydef) { + RNA_def_property_boolean_array_default(prop, def); + } RNA_def_property_ui_text(prop, name ? name : id, description); if (py_tags) { @@ -2366,8 +2415,9 @@ static PyObject *BPy_IntVectorProperty(PyObject *self, PyObject *args, PyObject return NULL; } - if (pydef && PyC_AsArray(def, pydef, size, &PyLong_Type, false, "IntVectorProperty(default=sequence)") == -1) + if (pydef && PyC_AsArray(def, pydef, size, &PyLong_Type, false, "IntVectorProperty(default=sequence)") == -1) { return NULL; + } if (bpy_prop_callback_check(update_cb, "update", 2) == -1) { return NULL; @@ -2381,7 +2431,9 @@ static PyObject *BPy_IntVectorProperty(PyObject *self, PyObject *args, PyObject prop = RNA_def_property(srna, id, PROP_INT, subtype); RNA_def_property_array(prop, size); - if (pydef) RNA_def_property_int_array_default(prop, def); + if (pydef) { + RNA_def_property_int_array_default(prop, def); + } RNA_def_property_range(prop, min, max); RNA_def_property_ui_text(prop, name ? name : id, description); RNA_def_property_ui_range(prop, MAX2(soft_min, min), MIN2(soft_max, max), step, 3); @@ -2618,8 +2670,9 @@ static PyObject *BPy_FloatVectorProperty(PyObject *self, PyObject *args, PyObjec return NULL; } - if (pydef && PyC_AsArray(def, pydef, size, &PyFloat_Type, false, "FloatVectorProperty(default=sequence)") == -1) + if (pydef && PyC_AsArray(def, pydef, size, &PyFloat_Type, false, "FloatVectorProperty(default=sequence)") == -1) { return NULL; + } if (bpy_prop_callback_check(update_cb, "update", 2) == -1) { return NULL; @@ -2633,7 +2686,9 @@ static PyObject *BPy_FloatVectorProperty(PyObject *self, PyObject *args, PyObjec prop = RNA_def_property(srna, id, PROP_FLOAT, subtype | unit); RNA_def_property_array(prop, size); - if (pydef) RNA_def_property_float_array_default(prop, def); + if (pydef) { + RNA_def_property_float_array_default(prop, def); + } RNA_def_property_range(prop, min, max); RNA_def_property_ui_text(prop, name ? name : id, description); RNA_def_property_ui_range(prop, MAX2(soft_min, min), MIN2(soft_max, max), step, precision); @@ -2728,8 +2783,12 @@ static PyObject *BPy_StringProperty(PyObject *self, PyObject *args, PyObject *kw } prop = RNA_def_property(srna, id, PROP_STRING, subtype); - if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen + 1); /* +1 since it includes null terminator */ - if (def && def[0]) RNA_def_property_string_default(prop, def); + if (maxlen != 0) { + RNA_def_property_string_maxlength(prop, maxlen + 1); /* +1 since it includes null terminator */ + } + if (def && def[0]) { + RNA_def_property_string_default(prop, def); + } RNA_def_property_ui_text(prop, name ? name : id, description); if (py_tags) { @@ -2890,8 +2949,12 @@ static PyObject *BPy_EnumProperty(PyObject *self, PyObject *args, PyObject *kw) } } - if (opts & PROP_ENUM_FLAG) prop = RNA_def_enum_flag(srna, id, eitems, defvalue, name ? name : id, description); - else prop = RNA_def_enum(srna, id, eitems, defvalue, name ? name : id, description); + if (opts & PROP_ENUM_FLAG) { + prop = RNA_def_enum_flag(srna, id, eitems, defvalue, name ? name : id, description); + } + else { + prop = RNA_def_enum(srna, id, eitems, defvalue, name ? name : id, description); + } if (py_tags) { RNA_def_property_tags(prop, prop_tags); @@ -2994,8 +3057,9 @@ PyObject *BPy_PointerProperty(PyObject *self, PyObject *args, PyObject *kw) BPY_PROPDEF_CHECK(PointerProperty, property_flag_items); ptype = pointer_type_from_py(type, "PointerProperty(...)"); - if (!ptype) + if (!ptype) { return NULL; + } if (!RNA_struct_is_a(ptype, &RNA_PropertyGroup) && !RNA_struct_is_ID(ptype)) { PyErr_Format(PyExc_TypeError, "PointerProperty(...) expected an RNA type derived from %.200s or %.200s", @@ -3077,8 +3141,9 @@ PyObject *BPy_CollectionProperty(PyObject *self, PyObject *args, PyObject *kw) BPY_PROPDEF_CHECK(CollectionProperty, property_flag_items); ptype = pointer_type_from_py(type, "CollectionProperty(...):"); - if (!ptype) + if (!ptype) { return NULL; + } if (!RNA_struct_is_a(ptype, &RNA_PropertyGroup)) { PyErr_Format( diff --git a/source/blender/python/intern/bpy_rna.c b/source/blender/python/intern/bpy_rna.c index 4e96479242b..f695464ec42 100644 --- a/source/blender/python/intern/bpy_rna.c +++ b/source/blender/python/intern/bpy_rna.c @@ -314,8 +314,12 @@ static bool rna_id_write_error(PointerRNA *ptr, PyObject *key) if (!ELEM(idcode, ID_WM, ID_SCR, ID_WS)) { /* may need more added here */ const char *idtype = BKE_idcode_to_name(idcode); const char *pyname; - if (key && PyUnicode_Check(key)) pyname = _PyUnicode_AsString(key); - else pyname = ""; + if (key && PyUnicode_Check(key)) { + pyname = _PyUnicode_AsString(key); + } + else { + pyname = ""; + } /* make a nice string error */ BLI_assert(idtype != NULL); @@ -392,8 +396,9 @@ static int mathutils_rna_vector_get(BaseMathObject *bmo, int subtype) PYRNA_PROP_CHECK_INT(self); - if (self->prop == NULL) + if (self->prop == NULL) { return -1; + } RNA_property_float_get_array(&self->ptr, self->prop, bmo->data); @@ -414,8 +419,9 @@ static int mathutils_rna_vector_set(BaseMathObject *bmo, int subtype) PYRNA_PROP_CHECK_INT(self); - if (self->prop == NULL) + if (self->prop == NULL) { return -1; + } #ifdef USE_PEDANTIC_WRITE if (rna_disallow_writes && rna_id_write_error(&self->ptr, NULL)) { @@ -465,8 +471,9 @@ static int mathutils_rna_vector_get_index(BaseMathObject *bmo, int UNUSED(subtyp PYRNA_PROP_CHECK_INT(self); - if (self->prop == NULL) + if (self->prop == NULL) { return -1; + } bmo->data[index] = RNA_property_float_get_index(&self->ptr, self->prop, index); return 0; @@ -478,8 +485,9 @@ static int mathutils_rna_vector_set_index(BaseMathObject *bmo, int UNUSED(subtyp PYRNA_PROP_CHECK_INT(self); - if (self->prop == NULL) + if (self->prop == NULL) { return -1; + } #ifdef USE_PEDANTIC_WRITE if (rna_disallow_writes && rna_id_write_error(&self->ptr, NULL)) { @@ -522,8 +530,9 @@ static int mathutils_rna_matrix_get(BaseMathObject *bmo, int UNUSED(subtype)) PYRNA_PROP_CHECK_INT(self); - if (self->prop == NULL) + if (self->prop == NULL) { return -1; + } RNA_property_float_get_array(&self->ptr, self->prop, bmo->data); return 0; @@ -535,8 +544,9 @@ static int mathutils_rna_matrix_set(BaseMathObject *bmo, int UNUSED(subtype)) PYRNA_PROP_CHECK_INT(self); - if (self->prop == NULL) + if (self->prop == NULL) { return -1; + } #ifdef USE_PEDANTIC_WRITE if (rna_disallow_writes && rna_id_write_error(&self->ptr, NULL)) { @@ -639,8 +649,10 @@ PyObject *pyrna_math_object_from_array(PointerRNA *ptr, PropertyRNA *prop) totdim = RNA_property_array_dimension(ptr, prop, NULL); if (totdim == 1 || (totdim == 2 && subtype == PROP_MATRIX)) { - if (!is_thick) - ret = pyrna_prop_CreatePyObject(ptr, prop); /* owned by the mathutils PyObject */ + if (!is_thick) { + /* owned by the mathutils PyObject */ + ret = pyrna_prop_CreatePyObject(ptr, prop); + } switch (subtype) { case PROP_ALL_VECTOR_SUBTYPES: @@ -801,8 +813,9 @@ static PyObject *pyrna_struct_richcmp(PyObject *a, PyObject *b, int op) PyObject *res; int ok = -1; /* zero is true */ - if (BPy_StructRNA_Check(a) && BPy_StructRNA_Check(b)) + if (BPy_StructRNA_Check(a) && BPy_StructRNA_Check(b)) { ok = pyrna_struct_compare((BPy_StructRNA *)a, (BPy_StructRNA *)b); + } switch (op) { case Py_NE: @@ -831,8 +844,9 @@ static PyObject *pyrna_prop_richcmp(PyObject *a, PyObject *b, int op) PyObject *res; int ok = -1; /* zero is true */ - if (BPy_PropertyRNA_Check(a) && BPy_PropertyRNA_Check(b)) + if (BPy_PropertyRNA_Check(a) && BPy_PropertyRNA_Check(b)) { ok = pyrna_prop_compare((BPy_PropertyRNA *)a, (BPy_PropertyRNA *)b); + } switch (op) { case Py_NE: @@ -888,8 +902,10 @@ static PyObject *pyrna_struct_repr(BPy_StructRNA *self) PyObject *tmp_str; PyObject *ret; - if (id == NULL || !PYRNA_STRUCT_IS_VALID(self)) - return pyrna_struct_str(self); /* fallback */ + if (id == NULL || !PYRNA_STRUCT_IS_VALID(self)) { + /* fallback */ + return pyrna_struct_str(self); + } tmp_str = PyUnicode_FromString(id->name + 2); @@ -959,8 +975,9 @@ static PyObject *pyrna_prop_str(BPy_PropertyRNA *self) len = pyrna_prop_array_length((BPy_PropertyArrayRNA *)self); } - if (len != -1) + if (len != -1) { sprintf(--c, "[%d]", len); + } } /* if a pointer, try to print name of pointer target too */ @@ -1004,8 +1021,10 @@ static PyObject *pyrna_prop_repr_ex( PYRNA_PROP_CHECK_OBJ(self); - if (id == NULL) - return pyrna_prop_str(self); /* fallback */ + if (id == NULL) { + /* fallback */ + return pyrna_prop_str(self); + } tmp_str = PyUnicode_FromString(id->name + 2); @@ -1066,19 +1085,23 @@ static Py_hash_t pyrna_struct_hash(BPy_StructRNA *self) static long pyrna_prop_hash(BPy_PropertyRNA *self) { long x, y; - if (self->ptr.data == NULL) + if (self->ptr.data == NULL) { x = 0; + } else { x = _Py_HashPointer(self->ptr.data); - if (x == -1) + if (x == -1) { return -1; + } } y = _Py_HashPointer((void *)(self->prop)); - if (y == -1) + if (y == -1) { return -1; + } x ^= y; - if (x == -1) + if (x == -1) { x = -2; + } return x; } @@ -1425,8 +1448,9 @@ static PyObject *pyrna_enum_to_py(PointerRNA *ptr, PropertyRNA *prop, int val) PyErr_Warn(PyExc_RuntimeWarning, error_str); #endif - if (ptr_name) + if (ptr_name) { MEM_freeN((void *)ptr_name); + } } ret = PyUnicode_FromString(""); @@ -1582,7 +1606,9 @@ int pyrna_pydict_to_props( while (PyDict_Next(kw, &pos, &key, &value)) { arg_name = _PyUnicode_AsString(key); - if (RNA_struct_find_property(ptr, arg_name) == NULL) break; + if (RNA_struct_find_property(ptr, arg_name) == NULL) { + break; + } arg_name = NULL; } @@ -1649,8 +1675,12 @@ static int pyrna_py_to_prop( return -1; } else { - if (data) *((bool *)data) = param; - else RNA_property_boolean_set(ptr, prop, param); + if (data) { + *((bool *)data) = param; + } + else { + RNA_property_boolean_set(ptr, prop, param); + } } break; } @@ -1755,8 +1785,12 @@ static int pyrna_py_to_prop( return -1; } else { - if (data) *((char **)data) = (char *)param; - else RNA_property_string_set_bytes(ptr, prop, param, PyBytes_Size(value)); + if (data) { + *((char **)data) = (char *)param; + } + else { + RNA_property_string_set_bytes(ptr, prop, param, PyBytes_Size(value)); + } } } else { @@ -1796,8 +1830,12 @@ static int pyrna_py_to_prop( else { /* same as bytes */ /* XXX, this is suspect but needed for function calls, need to see if theres a better way */ - if (data) *((char **)data) = (char *)param; - else RNA_property_string_set(ptr, prop, param); + if (data) { + *((char **)data) = (char *)param; + } + else { + RNA_property_string_set(ptr, prop, param); + } } #ifdef USE_STRING_COERCE Py_XDECREF(value_coerce); @@ -1823,8 +1861,12 @@ static int pyrna_py_to_prop( } } - if (data) *((int *)data) = val; - else RNA_property_enum_set(ptr, prop, val); + if (data) { + *((int *)data) = val; + } + else { + RNA_property_enum_set(ptr, prop, val); + } break; } @@ -1922,23 +1964,29 @@ static int pyrna_py_to_prop( if (flag_parameter & PARM_RNAPTR) { if (flag & PROP_THICK_WRAP) { - if (value == Py_None) + if (value == Py_None) { memset(data, 0, sizeof(PointerRNA)); - else if (RNA_struct_is_a(param->ptr.type, ptr_type)) + } + else if (RNA_struct_is_a(param->ptr.type, ptr_type)) { *((PointerRNA *)data) = param->ptr; - else + } + else { raise_error = true; + } } else { /* for function calls, we sometimes want to pass the 'ptr' directly, * watch out that it remains valid!, possibly we could support this later if needed */ BLI_assert(value_new == NULL); - if (value == Py_None) + if (value == Py_None) { *((void **)data) = NULL; - else if (RNA_struct_is_a(param->ptr.type, ptr_type)) + } + else if (RNA_struct_is_a(param->ptr.type, ptr_type)) { *((PointerRNA **)data) = ¶m->ptr; - else + } + else { raise_error = true; + } } } else if (value == Py_None) { @@ -1953,10 +2001,12 @@ static int pyrna_py_to_prop( } else { /* data == NULL, assign to RNA */ - if (value == Py_None || RNA_struct_is_a(param->ptr.type, ptr_type)) + if (value == Py_None || RNA_struct_is_a(param->ptr.type, ptr_type)) { RNA_property_pointer_set(ptr, prop, value == Py_None ? PointerRNA_NULL : param->ptr); - else + } + else { raise_error = true; + } } if (raise_error) { @@ -2027,8 +2077,9 @@ static int pyrna_py_to_prop( link->ptr = itemptr; BLI_addtail(lb, link); } - else + else { RNA_property_collection_add(ptr, prop, &itemptr); + } if (pyrna_pydict_to_props( &itemptr, item, true, @@ -2152,10 +2203,12 @@ static Py_ssize_t pyrna_prop_array_length(BPy_PropertyArrayRNA *self) { PYRNA_PROP_CHECK_INT((BPy_PropertyRNA *)self); - if (RNA_property_array_dimension(&self->ptr, self->prop, NULL) > 1) + if (RNA_property_array_dimension(&self->ptr, self->prop, NULL) > 1) { return RNA_property_multi_array_length(&self->ptr, self->prop, self->arraydim); - else + } + else { return RNA_property_array_length(&self->ptr, self->prop); + } } static Py_ssize_t pyrna_prop_collection_length(BPy_PropertyRNA *self) @@ -2271,10 +2324,13 @@ static PyObject *pyrna_prop_array_subscript_int(BPy_PropertyArrayRNA *self, int len = pyrna_prop_array_length(self); - if (keynum < 0) keynum += len; + if (keynum < 0) { + keynum += len; + } - if (keynum >= 0 && keynum < len) + if (keynum >= 0 && keynum < len) { return pyrna_prop_array_to_py_index(self, keynum); + } PyErr_Format(PyExc_IndexError, "bpy_prop_array[index]: index %d out of range", keynum); @@ -2287,8 +2343,9 @@ static PyObject *pyrna_prop_collection_subscript_str(BPy_PropertyRNA *self, cons PYRNA_PROP_CHECK_OBJ(self); - if (RNA_property_collection_lookup_string(&self->ptr, self->prop, keyname, &newptr)) + if (RNA_property_collection_lookup_string(&self->ptr, self->prop, keyname, &newptr)) { return pyrna_struct_CreatePyObject(&newptr); + } PyErr_Format(PyExc_KeyError, "bpy_prop_collection[key]: key \"%.200s\" not found", keyname); return NULL; @@ -2463,8 +2520,9 @@ static PyObject *pyrna_prop_array_subscript_slice( totdim = RNA_property_array_dimension(ptr, prop, NULL); if (totdim > 1) { - for (count = start; count < stop; count++) + for (count = start; count < stop; count++) { PyTuple_SET_ITEM(tuple, count - start, pyrna_prop_array_to_py_index(self, count)); + } } else { switch (RNA_property_type(prop)) { @@ -2476,8 +2534,9 @@ static PyObject *pyrna_prop_array_subscript_slice( else { values = values_stack; } RNA_property_float_get_array(ptr, prop, values); - for (count = start; count < stop; count++) + for (count = start; count < stop; count++) { PyTuple_SET_ITEM(tuple, count - start, PyFloat_FromDouble(values[count])); + } if (values != values_stack) { PyMem_FREE(values); @@ -2492,8 +2551,9 @@ static PyObject *pyrna_prop_array_subscript_slice( else { values = values_stack; } RNA_property_boolean_get_array(ptr, prop, values); - for (count = start; count < stop; count++) + for (count = start; count < stop; count++) { PyTuple_SET_ITEM(tuple, count - start, PyBool_FromLong(values[count])); + } if (values != values_stack) { PyMem_FREE(values); @@ -2508,8 +2568,9 @@ static PyObject *pyrna_prop_array_subscript_slice( else { values = values_stack; } RNA_property_int_get_array(ptr, prop, values); - for (count = start; count < stop; count++) + for (count = start; count < stop; count++) { PyTuple_SET_ITEM(tuple, count - start, PyLong_FromLong(values[count])); + } if (values != values_stack) { PyMem_FREE(values); @@ -2537,8 +2598,9 @@ static PyObject *pyrna_prop_collection_subscript(BPy_PropertyRNA *self, PyObject } else if (PyIndex_Check(key)) { Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; + } return pyrna_prop_collection_subscript_int(self, i); } @@ -2560,14 +2622,22 @@ static PyObject *pyrna_prop_collection_subscript(BPy_PropertyRNA *self, PyObject Py_ssize_t start = 0, stop = PY_SSIZE_T_MAX; /* avoid PySlice_GetIndicesEx because it needs to know the length ahead of time. */ - if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) return NULL; - if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) return NULL; + if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) { + return NULL; + } + if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) { + return NULL; + } if (start < 0 || stop < 0) { /* only get the length for negative values */ Py_ssize_t len = (Py_ssize_t)RNA_property_collection_length(&self->ptr, self->prop); - if (start < 0) start += len; - if (stop < 0) stop += len; + if (start < 0) { + start += len; + } + if (stop < 0) { + stop += len; + } } if (stop - start <= 0) { @@ -2662,8 +2732,9 @@ static int pyrna_prop_collection_ass_subscript(BPy_PropertyRNA *self, PyObject * #endif if (PyIndex_Check(key)) { Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return -1; + } return pyrna_prop_collection_ass_subscript_int(self, i, value); } @@ -2726,8 +2797,9 @@ static PyObject *pyrna_prop_array_subscript(BPy_PropertyArrayRNA *self, PyObject #endif if (PyIndex_Check(key)) { Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; + } return pyrna_prop_array_subscript_int(self, i); } else if (PySlice_Check(key)) { @@ -2751,8 +2823,9 @@ static PyObject *pyrna_prop_array_subscript(BPy_PropertyArrayRNA *self, PyObject int len = pyrna_prop_array_length(self); Py_ssize_t start, stop, slicelength; - if (PySlice_GetIndicesEx(key, len, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(key, len, &start, &stop, &step, &slicelength) < 0) { return NULL; + } if (slicelength <= 0) { return PyTuple_New(0); @@ -2963,8 +3036,12 @@ static int prop_subscript_ass_array_slice( totdim - arraydim, &dimsize[arraydim], range); - if (PyErr_Occurred()) ret = -1; - else RNA_property_float_set_array(ptr, prop, values); + if (PyErr_Occurred()) { + ret = -1; + } + else { + RNA_property_float_set_array(ptr, prop, values); + } break; } case PROP_INT: @@ -2986,8 +3063,12 @@ static int prop_subscript_ass_array_slice( totdim - arraydim, &dimsize[arraydim], range); - if (PyErr_Occurred()) ret = -1; - else RNA_property_int_set_array(ptr, prop, values); + if (PyErr_Occurred()) { + ret = -1; + } + else { + RNA_property_int_set_array(ptr, prop, values); + } break; } case PROP_BOOLEAN: @@ -3006,8 +3087,12 @@ static int prop_subscript_ass_array_slice( value_items, &values[arrayoffset + (start * span)], totdim - arraydim, &dimsize[arraydim]); - if (PyErr_Occurred()) ret = -1; - else RNA_property_boolean_set_array(ptr, prop, values); + if (PyErr_Occurred()) { + ret = -1; + } + else { + RNA_property_boolean_set_array(ptr, prop, values); + } break; } default: @@ -3034,10 +3119,13 @@ static int prop_subscript_ass_array_int(BPy_PropertyArrayRNA *self, Py_ssize_t k len = pyrna_prop_array_length(self); - if (keynum < 0) keynum += len; + if (keynum < 0) { + keynum += len; + } - if (keynum >= 0 && keynum < len) + if (keynum >= 0 && keynum < len) { return pyrna_py_to_prop_array_index(self, keynum, value); + } PyErr_SetString(PyExc_IndexError, "bpy_prop_array[index] = value: index out of range"); @@ -3165,8 +3253,9 @@ static int pyrna_prop_collection_contains(BPy_PropertyRNA *self, PyObject *key) return -1; } - if (RNA_property_collection_lookup_string(&self->ptr, self->prop, keyname, &newptr)) + if (RNA_property_collection_lookup_string(&self->ptr, self->prop, keyname, &newptr)) { return 1; + } return 0; } @@ -3191,8 +3280,9 @@ static int pyrna_struct_contains(BPy_StructRNA *self, PyObject *value) group = RNA_struct_idprops(&self->ptr, 0); - if (!group) + if (!group) { return 0; + } return IDP_GetPropertyFromGroup(group, name) ? 1 : 0; } @@ -3335,8 +3425,9 @@ static PyObject *pyrna_struct_keys(BPy_PropertyRNA *self) group = RNA_struct_idprops(&self->ptr, 0); - if (group == NULL) + if (group == NULL) { return PyList_New(0); + } return BPy_Wrap_GetKeys(group); } @@ -3363,8 +3454,9 @@ static PyObject *pyrna_struct_items(BPy_PropertyRNA *self) group = RNA_struct_idprops(&self->ptr, 0); - if (group == NULL) + if (group == NULL) { return PyList_New(0); + } return BPy_Wrap_GetItems(self->ptr.id.data, group); } @@ -3391,8 +3483,9 @@ static PyObject *pyrna_struct_values(BPy_PropertyRNA *self) group = RNA_struct_idprops(&self->ptr, 0); - if (group == NULL) + if (group == NULL) { return PyList_New(0); + } return BPy_Wrap_GetValues(self->ptr.id.data, group); } @@ -3413,8 +3506,9 @@ static PyObject *pyrna_struct_is_property_set(BPy_StructRNA *self, PyObject *arg PYRNA_STRUCT_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "s:is_property_set", &name)) + if (!PyArg_ParseTuple(args, "s:is_property_set", &name)) { return NULL; + } if ((prop = RNA_struct_find_property(&self->ptr, name)) == NULL) { PyErr_Format(PyExc_TypeError, @@ -3438,8 +3532,9 @@ static PyObject *pyrna_struct_property_unset(BPy_StructRNA *self, PyObject *args PYRNA_STRUCT_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "s:property_unset", &name)) + if (!PyArg_ParseTuple(args, "s:property_unset", &name)) { return NULL; + } if ((prop = RNA_struct_find_property(&self->ptr, name)) == NULL) { PyErr_Format(PyExc_TypeError, @@ -3468,8 +3563,9 @@ static PyObject *pyrna_struct_is_property_hidden(BPy_StructRNA *self, PyObject * PYRNA_STRUCT_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "s:is_property_hidden", &name)) + if (!PyArg_ParseTuple(args, "s:is_property_hidden", &name)) { return NULL; + } if ((prop = RNA_struct_find_property(&self->ptr, name)) == NULL) { PyErr_Format(PyExc_TypeError, @@ -3496,8 +3592,9 @@ static PyObject *pyrna_struct_is_property_readonly(BPy_StructRNA *self, PyObject PYRNA_STRUCT_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "s:is_property_readonly", &name)) + if (!PyArg_ParseTuple(args, "s:is_property_readonly", &name)) { return NULL; + } if ((prop = RNA_struct_find_property(&self->ptr, name)) == NULL) { PyErr_Format(PyExc_TypeError, @@ -3592,8 +3689,9 @@ static PyObject *pyrna_struct_path_resolve(BPy_StructRNA *self, PyObject *args) PYRNA_STRUCT_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "s|O!:path_resolve", &path, &PyBool_Type, &coerce)) + if (!PyArg_ParseTuple(args, "s|O!:path_resolve", &path, &PyBool_Type, &coerce)) { return NULL; + } if (RNA_path_resolve_full(&self->ptr, path, &r_ptr, &r_prop, &index)) { if (r_prop) { @@ -3650,8 +3748,9 @@ static PyObject *pyrna_struct_path_from_id(BPy_StructRNA *self, PyObject *args) PYRNA_STRUCT_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "|s:path_from_id", &name)) + if (!PyArg_ParseTuple(args, "|s:path_from_id", &name)) { return NULL; + } if (name) { prop = RNA_struct_find_property(&self->ptr, name); @@ -3990,8 +4089,9 @@ static PyObject *pyrna_struct_dir(BPy_StructRNA *self) * */ ret = PyList_New(0); - if (!BPy_StructRNA_CheckExact(self)) + if (!BPy_StructRNA_CheckExact(self)) { pyrna_dir_members_py(ret, (PyObject *)self); + } pyrna_dir_members_rna(ret, &self->ptr); @@ -4636,8 +4736,9 @@ static PyObject *pyrna_prop_collection_items(BPy_PropertyRNA *self) nameptr = RNA_struct_name_get_alloc(&itemptr, name, sizeof(name), &namelen); if (nameptr) { PyTuple_SET_ITEM(item, 0, PyUnicode_FromStringAndSize(nameptr, namelen)); - if (name != nameptr) + if (name != nameptr) { MEM_freeN(nameptr); + } } else { /* a bit strange but better then returning an empty list */ @@ -4693,8 +4794,9 @@ static PyObject *pyrna_struct_get(BPy_StructRNA *self, PyObject *args) PYRNA_STRUCT_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) + if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) { return NULL; + } /* mostly copied from BPy_IDGroup_Map_GetItem */ if (RNA_struct_idprops_check(self->ptr.type) == 0) { @@ -4737,8 +4839,9 @@ static PyObject *pyrna_struct_pop(BPy_StructRNA *self, PyObject *args) PYRNA_STRUCT_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) + if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) { return NULL; + } /* mostly copied from BPy_IDGroup_Map_GetItem */ if (RNA_struct_idprops_check(self->ptr.type) == 0) { @@ -4801,14 +4904,16 @@ static PyObject *pyrna_prop_collection_get(BPy_PropertyRNA *self, PyObject *args PYRNA_PROP_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "O|O:get", &key_ob, &def)) + if (!PyArg_ParseTuple(args, "O|O:get", &key_ob, &def)) { return NULL; + } if (PyUnicode_Check(key_ob)) { const char *key = _PyUnicode_AsString(key_ob); - if (RNA_property_collection_lookup_string(&self->ptr, self->prop, key, &newptr)) + if (RNA_property_collection_lookup_string(&self->ptr, self->prop, key, &newptr)) { return pyrna_struct_CreatePyObject(&newptr); + } } else if (PyTuple_Check(key_ob)) { PyObject *ret = pyrna_prop_collection_subscript_str_lib_pair(self, key_ob, @@ -4942,13 +5047,16 @@ static int foreach_parse_args( *size = RNA_raw_type_sizeof(*raw_type); #if 0 /* works fine but not strictly needed, we could allow RNA_property_collection_raw_* to do the checks */ - if ((*attr_tot) < 1) + if ((*attr_tot) < 1) { *attr_tot = 1; + } - if (RNA_property_type(self->prop) == PROP_COLLECTION) + if (RNA_property_type(self->prop) == PROP_COLLECTION) { array_tot = RNA_property_collection_length(&self->ptr, self->prop); - else + } + else { array_tot = RNA_property_array_length(&self->ptr, self->prop); + } target_tot = array_tot * (*attr_tot); @@ -4978,14 +5086,26 @@ static bool foreach_compat_buffer(RawPropertyType raw_type, int attr_signed, con switch (raw_type) { case PROP_RAW_CHAR: - if (attr_signed) return (f == 'b') ? 1 : 0; - else return (f == 'B') ? 1 : 0; + if (attr_signed) { + return (f == 'b') ? 1 : 0; + } + else { + return (f == 'B') ? 1 : 0; + } case PROP_RAW_SHORT: - if (attr_signed) return (f == 'h') ? 1 : 0; - else return (f == 'H') ? 1 : 0; + if (attr_signed) { + return (f == 'h') ? 1 : 0; + } + else { + return (f == 'H') ? 1 : 0; + } case PROP_RAW_INT: - if (attr_signed) return (f == 'i') ? 1 : 0; - else return (f == 'I') ? 1 : 0; + if (attr_signed) { + return (f == 'i') ? 1 : 0; + } + else { + return (f == 'I') ? 1 : 0; + } case PROP_RAW_BOOLEAN: return (f == '?') ? 1 : 0; case PROP_RAW_FLOAT: @@ -5013,11 +5133,13 @@ static PyObject *foreach_getset(BPy_PropertyRNA *self, PyObject *args, int set) bool attr_signed; RawPropertyType raw_type; - if (foreach_parse_args(self, args, &attr, &seq, &tot, &size, &raw_type, &attr_tot, &attr_signed) == -1) + if (foreach_parse_args(self, args, &attr, &seq, &tot, &size, &raw_type, &attr_tot, &attr_signed) == -1) { return NULL; + } - if (tot == 0) + if (tot == 0) { Py_RETURN_NONE; + } @@ -5098,7 +5220,10 @@ static PyObject *foreach_getset(BPy_PropertyRNA *self, PyObject *args, int set) ok = RNA_property_collection_raw_get(NULL, &self->ptr, self->prop, attr, array, raw_type, tot); - if (!ok) i = tot; /* skip the loop */ + if (!ok) { + /* skip the loop */ + i = tot; + } for ( ; i < tot; i++) { @@ -5135,8 +5260,9 @@ static PyObject *foreach_getset(BPy_PropertyRNA *self, PyObject *args, int set) } } - if (array) + if (array) { PyMem_Free(array); + } if (PyErr_Occurred()) { /* Maybe we could make our own error */ @@ -5348,8 +5474,9 @@ static PyObject *pyrna_prop_new(PyTypeObject *type, PyObject *args, PyObject *UN { BPy_PropertyRNA *base; - if (!PyArg_ParseTuple(args, "O!:bpy_prop.__new__", &pyrna_prop_Type, &base)) + if (!PyArg_ParseTuple(args, "O!:bpy_prop.__new__", &pyrna_prop_Type, &base)) { return NULL; + } if (type == Py_TYPE(base)) { return Py_INCREF_RET((PyObject *)base); @@ -5383,8 +5510,9 @@ static PyObject *pyrna_param_to_py(PointerRNA *ptr, PropertyRNA *prop, void *dat len = data_alloc->array_tot; data = data_alloc->array; } - else + else { len = RNA_property_array_length(ptr, prop); + } /* resolve the array from a new pytype */ @@ -5393,13 +5521,15 @@ static PyObject *pyrna_param_to_py(PointerRNA *ptr, PropertyRNA *prop, void *dat switch (type) { case PROP_BOOLEAN: ret = PyTuple_New(len); - for (a = 0; a < len; a++) + for (a = 0; a < len; a++) { PyTuple_SET_ITEM(ret, a, PyBool_FromLong(((bool *)data)[a])); + } break; case PROP_INT: ret = PyTuple_New(len); - for (a = 0; a < len; a++) + for (a = 0; a < len; a++) { PyTuple_SET_ITEM(ret, a, PyLong_FromLong(((int *)data)[a])); + } break; case PROP_FLOAT: switch (RNA_property_subtype(prop)) { @@ -5420,8 +5550,9 @@ static PyObject *pyrna_param_to_py(PointerRNA *ptr, PropertyRNA *prop, void *dat #endif default: ret = PyTuple_New(len); - for (a = 0; a < len; a++) + for (a = 0; a < len; a++) { PyTuple_SET_ITEM(ret, a, PyFloat_FromDouble(((float *)data)[a])); + } break; } break; @@ -5451,10 +5582,12 @@ static PyObject *pyrna_param_to_py(PointerRNA *ptr, PropertyRNA *prop, void *dat PyObject *value_coerce = NULL; const int subtype = RNA_property_subtype(prop); - if (flag & PROP_THICK_WRAP) + if (flag & PROP_THICK_WRAP) { data_ch = (char *)data; - else + } + else { data_ch = *(char **)data; + } #ifdef USE_STRING_COERCE if (subtype == PROP_BYTESTRING) { @@ -5674,8 +5807,9 @@ static PyObject *pyrna_func_call(BPy_FunctionRNA *self, PyObject *args, PyObject #else item = small_dict_get_item_string(kw, RNA_property_identifier(parm)); /* borrow ref */ #endif - if (item) + if (item) { kw_tot++; /* make sure invalid keywords are not given */ + } kw_arg = true; } @@ -5712,19 +5846,21 @@ static PyObject *pyrna_func_call(BPy_FunctionRNA *self, PyObject *args, PyObject char error_prefix[512]; PyErr_Clear(); /* re-raise */ - if (kw_arg == true) + if (kw_arg == true) { BLI_snprintf(error_prefix, sizeof(error_prefix), "%.200s.%.200s(): error with keyword argument \"%.200s\" - ", RNA_struct_identifier(self_ptr->type), RNA_function_identifier(self_func), RNA_property_identifier(parm)); - else + } + else { BLI_snprintf(error_prefix, sizeof(error_prefix), "%.200s.%.200s(): error with argument %d, \"%.200s\" - ", RNA_struct_identifier(self_ptr->type), RNA_function_identifier(self_func), i, RNA_property_identifier(parm)); + } pyrna_py_to_prop(&funcptr, parm, iter.data, item, error_prefix); @@ -5783,8 +5919,9 @@ static PyObject *pyrna_func_call(BPy_FunctionRNA *self, PyObject *args, PyObject RNA_parameter_list_begin(&parms, &iter); for (; iter.valid; RNA_parameter_list_next(&iter)) { parm = iter.parm; - if (RNA_parameter_flag(parm) & PARM_OUTPUT) + if (RNA_parameter_flag(parm) & PARM_OUTPUT) { continue; + } BLI_dynstr_appendf(good_args, first ? "%s" : ", %s", RNA_property_identifier(parm)); first = false; @@ -5831,18 +5968,21 @@ static PyObject *pyrna_func_call(BPy_FunctionRNA *self, PyObject *args, PyObject for (; iter.valid; RNA_parameter_list_next(&iter)) { parm = iter.parm; - if (RNA_parameter_flag(parm) & PARM_OUTPUT) + if (RNA_parameter_flag(parm) & PARM_OUTPUT) { PyTuple_SET_ITEM(ret, i++, pyrna_param_to_py(&funcptr, parm, iter.data)); + } } RNA_parameter_list_end(&iter); } - else + else { ret = pyrna_param_to_py(&funcptr, pret_single, retdata_single); + } /* possible there is an error in conversion */ - if (ret == NULL) + if (ret == NULL) { err = -1; + } } } } @@ -5865,11 +6005,13 @@ static PyObject *pyrna_func_call(BPy_FunctionRNA *self, PyObject *args, PyObject RNA_parameter_list_end(&iter); RNA_parameter_list_free(&parms); - if (ret) + if (ret) { return ret; + } - if (err == -1) + if (err == -1) { return NULL; + } Py_RETURN_NONE; } @@ -6660,8 +6802,9 @@ static void pyrna_subtype_set_rna(PyObject *newclass, StructRNA *srna) Py_INCREF(newclass); - if (RNA_struct_py_type_get(srna)) + if (RNA_struct_py_type_get(srna)) { PyC_ObSpit("RNA WAS SET - ", RNA_struct_py_type_get(srna)); + } Py_XDECREF(((PyObject *)RNA_struct_py_type_get(srna))); @@ -7074,30 +7217,38 @@ void BPY_rna_init(void) #endif /* metaclass */ - if (PyType_Ready(&pyrna_struct_meta_idprop_Type) < 0) + if (PyType_Ready(&pyrna_struct_meta_idprop_Type) < 0) { return; + } - if (PyType_Ready(&pyrna_struct_Type) < 0) + if (PyType_Ready(&pyrna_struct_Type) < 0) { return; + } - if (PyType_Ready(&pyrna_prop_Type) < 0) + if (PyType_Ready(&pyrna_prop_Type) < 0) { return; + } - if (PyType_Ready(&pyrna_prop_array_Type) < 0) + if (PyType_Ready(&pyrna_prop_array_Type) < 0) { return; + } - if (PyType_Ready(&pyrna_prop_collection_Type) < 0) + if (PyType_Ready(&pyrna_prop_collection_Type) < 0) { return; + } - if (PyType_Ready(&pyrna_prop_collection_idprop_Type) < 0) + if (PyType_Ready(&pyrna_prop_collection_idprop_Type) < 0) { return; + } - if (PyType_Ready(&pyrna_func_Type) < 0) + if (PyType_Ready(&pyrna_func_Type) < 0) { return; + } #ifdef USE_PYRNA_ITER - if (PyType_Ready(&pyrna_prop_collection_iter_Type) < 0) + if (PyType_Ready(&pyrna_prop_collection_iter_Type) < 0) { return; + } #endif } @@ -7239,8 +7390,9 @@ PyObject *BPY_rna_types(void) pyrna_basetype_Type.tp_flags = Py_TPFLAGS_DEFAULT; pyrna_basetype_Type.tp_methods = pyrna_basetype_methods; - if (PyType_Ready(&pyrna_basetype_Type) < 0) + if (PyType_Ready(&pyrna_basetype_Type) < 0) { return NULL; + } } /* static members for the base class */ @@ -7288,8 +7440,9 @@ StructRNA *pyrna_struct_as_srna(PyObject *self, const bool parent, const char *e if (parent) { /* be very careful with this since it will return a parent classes srna. * modifying this will do confusing stuff! */ - if (py_srna == NULL) + if (py_srna == NULL) { py_srna = (BPy_StructRNA *)PyObject_GetAttr(self, bpy_intern_str_bl_rna); + } } if (py_srna == NULL) { @@ -7473,8 +7626,9 @@ static int pyrna_deferred_register_props(StructRNA *srna, PyObject *class_dict) } ret = deferred_register_prop(srna, key, item); - if (ret != 0) + if (ret != 0) { break; + } } } @@ -7518,8 +7672,9 @@ int pyrna_deferred_register_class(StructRNA *srna, PyTypeObject *py_class) { /* Panels and Menus don't need this * save some time and skip the checks here */ - if (!RNA_struct_idprops_register_check(srna)) + if (!RNA_struct_idprops_register_check(srna)) { return 0; + } return pyrna_deferred_register_class_recursive(srna, py_class); } @@ -7541,16 +7696,18 @@ static int rna_function_arg_count(FunctionRNA *func, int *min_count) if (!(RNA_parameter_flag(parm) & PARM_OUTPUT)) { if (!done_min_count && (RNA_parameter_flag(parm) & PARM_PYFUNC_OPTIONAL)) { /* From now on, following parameters are optional in py func */ - if (min_count) + if (min_count) { *min_count = count; + } done_min_count = true; } count++; } } - if (!done_min_count && min_count) + if (!done_min_count && min_count) { *min_count = count; + } return count; } @@ -7567,8 +7724,9 @@ static int bpy_class_validate_recursive(PointerRNA *dummyptr, StructRNA *srna, v const char *py_class_name = ((PyTypeObject *)py_class)->tp_name; /* __name__ */ if (srna_base) { - if (bpy_class_validate_recursive(dummyptr, srna_base, py_data, have_function) != 0) + if (bpy_class_validate_recursive(dummyptr, srna_base, py_data, have_function) != 0) { return -1; + } } if (base_class) { @@ -7591,8 +7749,9 @@ static int bpy_class_validate_recursive(PointerRNA *dummyptr, StructRNA *srna, v * Keep this as-is since its working but we should be using 'FUNC_USE_SELF_TYPE' for many functions. */ const bool is_staticmethod = (flag & FUNC_NO_SELF) && !(flag & FUNC_USE_SELF_TYPE); - if (!(flag & FUNC_REGISTER)) + if (!(flag & FUNC_REGISTER)) { continue; + } item = PyObject_GetAttrString(py_class, RNA_function_identifier(func)); @@ -7672,8 +7831,9 @@ static int bpy_class_validate_recursive(PointerRNA *dummyptr, StructRNA *srna, v PropertyRNA *prop = (PropertyRNA *)link; const int flag = RNA_property_flag(prop); - if (!(flag & PROP_REGISTER)) + if (!(flag & PROP_REGISTER)) { continue; + } /* TODO(campbell): Use Python3.7x _PyObject_LookupAttr(), also in the macro below. */ identifier = RNA_property_identifier(prop); @@ -7769,8 +7929,9 @@ static int bpy_class_call(bContext *C, PointerRNA *ptr, FunctionRNA *func, Param /* XXX, this is needed because render engine calls without a context * this should be supported at some point but at the moment its not! */ - if (C == NULL) + if (C == NULL) { C = BPy_GetContext(); + } /* annoying!, need to check if the screen gets set to NULL which is a * hint that the file was actually re-loaded. */ @@ -7792,8 +7953,9 @@ static int bpy_class_call(bContext *C, PointerRNA *ptr, FunctionRNA *func, Param } /* end exception */ - if (py_class_instance == NULL) + if (py_class_instance == NULL) { py_srna = pyrna_struct_CreatePyObject(ptr); + } if (py_class_instance) { /* special case, instance is cached */ @@ -8055,8 +8217,9 @@ static void bpy_class_free(void *pyob_ptr) /* remove the rna attribute instead. */ PyDict_DelItem(((PyTypeObject *)self)->tp_dict, bpy_intern_str_bl_rna); - if (PyErr_Occurred()) + if (PyErr_Occurred()) { PyErr_Clear(); + } #if 0 /* needs further investigation, too annoying so quiet for now */ if (G.debug & G_DEBUG_PYTHON) { @@ -8197,8 +8360,9 @@ static PyObject *pyrna_register_class(PyObject *UNUSED(self), PyObject *py_class /* warning: gets parent classes srna, only for the register function */ srna = pyrna_struct_as_srna(py_class, true, "register_class(...):"); - if (srna == NULL) + if (srna == NULL) { return NULL; + } /* fails in cases, cant use this check but would like to :| */ #if 0 @@ -8245,8 +8409,9 @@ static PyObject *pyrna_register_class(PyObject *UNUSED(self), PyObject *py_class /* python errors validating are not converted into reports so the check above will fail. * the cause for returning NULL will be printed as an error */ - if (srna_new == NULL) + if (srna_new == NULL) { return NULL; + } pyrna_subtype_set_rna(py_class, srna_new); /* takes a ref to py_class */ @@ -8260,8 +8425,9 @@ static PyObject *pyrna_register_class(PyObject *UNUSED(self), PyObject *py_class * * item = PyObject_GetAttrString(py_class, "__dict__"); */ - if (pyrna_deferred_register_class(srna_new, (PyTypeObject *)py_class) != 0) + if (pyrna_deferred_register_class(srna_new, (PyTypeObject *)py_class) != 0) { return NULL; + } /* call classed register method () */ switch (_PyObject_LookupAttr(py_class, bpy_intern_str_register, &py_cls_meth)) { @@ -8354,8 +8520,9 @@ static PyObject *pyrna_unregister_class(PyObject *UNUSED(self), PyObject *py_cla } srna = pyrna_struct_as_srna(py_class, false, "unregister_class(...):"); - if (srna == NULL) + if (srna == NULL) { return NULL; + } /* check that we have a unregister callback for this type */ unreg = RNA_struct_unregister(srna); @@ -8423,8 +8590,9 @@ static PyObject *pyrna_unregister_class(PyObject *UNUSED(self), PyObject *py_cla unreg(CTX_data_main(C), srna); /* calls bpy_class_free, this decref's py_class */ PyDict_DelItem(((PyTypeObject *)py_class)->tp_dict, bpy_intern_str_bl_rna); - if (PyErr_Occurred()) + if (PyErr_Occurred()) { PyErr_Clear(); //return NULL; + } Py_RETURN_NONE; } diff --git a/source/blender/python/intern/bpy_rna_anim.c b/source/blender/python/intern/bpy_rna_anim.c index faead661f1f..a25906ac9a1 100644 --- a/source/blender/python/intern/bpy_rna_anim.c +++ b/source/blender/python/intern/bpy_rna_anim.c @@ -339,8 +339,9 @@ PyObject *pyrna_struct_keyframe_insert(BPy_StructRNA *self, PyObject *args, PyOb } MEM_freeN((void *)path_full); - if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) + if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) { return NULL; + } return PyBool_FromLong(result); } @@ -356,8 +357,9 @@ PyObject *pyrna_struct_keyframe_insert(BPy_StructRNA *self, PyObject *args, PyOb result = insert_keyframe(G_MAIN, depsgraph, &reports, id, NULL, group_name, path_full, index, cfra, keytype, NULL, options); MEM_freeN((void *)path_full); - if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) + if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) { return NULL; + } return PyBool_FromLong(result); } @@ -452,8 +454,9 @@ PyObject *pyrna_struct_keyframe_delete(BPy_StructRNA *self, PyObject *args, PyOb } MEM_freeN((void *)path_full); - if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) + if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) { return NULL; + } return PyBool_FromLong(result); } @@ -466,8 +469,9 @@ PyObject *pyrna_struct_keyframe_delete(BPy_StructRNA *self, PyObject *args, PyOb result = delete_keyframe(G.main, &reports, (ID *)self->ptr.id.data, NULL, group_name, path_full, index, cfra, 0); MEM_freeN((void *)path_full); - if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) + if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) { return NULL; + } return PyBool_FromLong(result); } @@ -493,8 +497,9 @@ PyObject *pyrna_struct_driver_add(BPy_StructRNA *self, PyObject *args) PYRNA_STRUCT_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "s|i:driver_add", &path, &index)) + if (!PyArg_ParseTuple(args, "s|i:driver_add", &path, &index)) { return NULL; + } if (pyrna_struct_anim_args_parse( &self->ptr, "bpy_struct.driver_add():", path, @@ -512,8 +517,9 @@ PyObject *pyrna_struct_driver_add(BPy_StructRNA *self, PyObject *args) result = ANIM_add_driver(&reports, (ID *)self->ptr.id.data, path_full, index, CREATEDRIVER_WITH_FMODIFIER, DRIVER_TYPE_PYTHON); - if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) + if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) { return NULL; + } if (result) { ID *id = self->ptr.id.data; @@ -592,8 +598,9 @@ PyObject *pyrna_struct_driver_remove(BPy_StructRNA *self, PyObject *args) MEM_freeN((void *)path_full); } - if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) + if (BPy_reports_to_error(&reports, PyExc_RuntimeError, true) == -1) { return NULL; + } WM_event_add_notifier(BPy_GetContext(), NC_ANIMATION | ND_FCURVES_ORDER, NULL); diff --git a/source/blender/python/intern/bpy_rna_array.c b/source/blender/python/intern/bpy_rna_array.c index a87da8782bc..4cc3c4c0fae 100644 --- a/source/blender/python/intern/bpy_rna_array.c +++ b/source/blender/python/intern/bpy_rna_array.c @@ -276,8 +276,9 @@ static int validate_array_length(PyObject *rvalue, PointerRNA *ptr, PropertyRNA * * arr[2][3][4] = x * lvalue_dim = 2 */ - for (i = lvalue_dim; i < totdim; i++) + for (i = lvalue_dim; i < totdim; i++) { len *= dimsize[i]; + } } if (tot != len) { @@ -308,8 +309,9 @@ static int validate_array(PyObject *rvalue, PointerRNA *ptr, PropertyRNA *prop, if (MatrixObject_Check(rvalue)) { MatrixObject *pymat = (MatrixObject *)rvalue; - if (BaseMath_ReadCallback(pymat) == -1) + if (BaseMath_ReadCallback(pymat) == -1) { return -1; + } if (RNA_property_type(prop) != PROP_FLOAT) { PyErr_Format(PyExc_ValueError, "%s %.200s.%.200s, matrix assign to non float array", @@ -512,8 +514,9 @@ static int py_to_array_index( lvalue_dim++; - for (i = lvalue_dim; i < totdim; i++) + for (i = lvalue_dim; i < totdim; i++) { index *= dimsize[i]; + } index += arrayoffset; @@ -751,8 +754,9 @@ static PyObject *pyrna_py_from_array_internal(PointerRNA *ptr, PropertyRNA *prop for (i = 0; i < len; i++) { PyObject *item; - if (dim + 1 < totdim) + if (dim + 1 < totdim) { item = pyrna_py_from_array_internal(ptr, prop, dim + 1, index); + } else { item = pyrna_array_index(ptr, prop, *index); *index = *index + 1; @@ -802,8 +806,9 @@ PyObject *pyrna_py_from_array_index(BPy_PropertyArrayRNA *self, PointerRNA *ptr, * x = arr[2][3] * index = offset + 3 * 5 */ - for (i = arraydim + 1; i < totdim; i++) + for (i = arraydim + 1; i < totdim; i++) { index *= dimsize[i]; + } ret->arrayoffset = arrayoffset + index; } @@ -822,7 +827,9 @@ PyObject *pyrna_py_from_array(PointerRNA *ptr, PropertyRNA *prop) ret = pyrna_math_object_from_array(ptr, prop); /* is this a maths object? */ - if (ret) return ret; + if (ret) { + return ret; + } return pyrna_prop_CreatePyObject(ptr, prop); } @@ -834,8 +841,10 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value) int type; int i; - if (len == 0) /* possible with dynamic arrays */ + if (len == 0) { + /* possible with dynamic arrays */ return 0; + } if (RNA_property_array_dimension(ptr, prop, NULL) > 1) { PyErr_SetString(PyExc_TypeError, "PropertyRNA - multi dimensional arrays not supported yet"); @@ -871,8 +880,9 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value) } } - if (tmp_arr != tmp) + if (tmp_arr != tmp) { PyMem_FREE(tmp_arr); + } return i < len ? 1 : 0; } @@ -904,8 +914,9 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value) } } - if (tmp_arr != tmp) + if (tmp_arr != tmp) { PyMem_FREE(tmp_arr); + } return i < len ? 1 : 0; } @@ -937,8 +948,9 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value) } } - if (tmp_arr != tmp) + if (tmp_arr != tmp) { PyMem_FREE(tmp_arr); + } return i < len ? 1 : 0; } diff --git a/source/blender/python/intern/bpy_rna_callback.c b/source/blender/python/intern/bpy_rna_callback.c index 025ea586fee..30ea657200c 100644 --- a/source/blender/python/intern/bpy_rna_callback.c +++ b/source/blender/python/intern/bpy_rna_callback.c @@ -136,8 +136,9 @@ PyObject *pyrna_callback_add(BPy_StructRNA *self, PyObject *args) char *cb_event_str = NULL; int cb_event; - if (!PyArg_ParseTuple(args, "OO!|s:bpy_struct.callback_add", &cb_func, &PyTuple_Type, &cb_args, &cb_event_str)) + if (!PyArg_ParseTuple(args, "OO!|s:bpy_struct.callback_add", &cb_func, &PyTuple_Type, &cb_args, &cb_event_str)) { return NULL; + } if (!PyCallable_Check(cb_func)) { PyErr_SetString(PyExc_TypeError, "callback_add(): first argument isn't callable"); @@ -174,8 +175,9 @@ PyObject *pyrna_callback_remove(BPy_StructRNA *self, PyObject *args) void *handle; void *customdata; - if (!PyArg_ParseTuple(args, "O!:callback_remove", &PyCapsule_Type, &py_handle)) + if (!PyArg_ParseTuple(args, "O!:callback_remove", &PyCapsule_Type, &py_handle)) { return NULL; + } handle = PyCapsule_GetPointer(py_handle, rna_capsual_id); @@ -205,21 +207,21 @@ PyObject *pyrna_callback_remove(BPy_StructRNA *self, PyObject *args) /* reverse of rna_Space_refine() */ static eSpace_Type rna_Space_refine_reverse(StructRNA *srna) { - if (srna == &RNA_SpaceView3D) return SPACE_VIEW3D; - if (srna == &RNA_SpaceGraphEditor) return SPACE_GRAPH; - if (srna == &RNA_SpaceOutliner) return SPACE_OUTLINER; - if (srna == &RNA_SpaceProperties) return SPACE_PROPERTIES; - if (srna == &RNA_SpaceFileBrowser) return SPACE_FILE; - if (srna == &RNA_SpaceImageEditor) return SPACE_IMAGE; - if (srna == &RNA_SpaceInfo) return SPACE_INFO; - if (srna == &RNA_SpaceSequenceEditor) return SPACE_SEQ; - if (srna == &RNA_SpaceTextEditor) return SPACE_TEXT; - if (srna == &RNA_SpaceDopeSheetEditor) return SPACE_ACTION; - if (srna == &RNA_SpaceNLA) return SPACE_NLA; - if (srna == &RNA_SpaceNodeEditor) return SPACE_NODE; - if (srna == &RNA_SpaceConsole) return SPACE_CONSOLE; - if (srna == &RNA_SpacePreferences) return SPACE_USERPREF; - if (srna == &RNA_SpaceClipEditor) return SPACE_CLIP; + if (srna == &RNA_SpaceView3D) { return SPACE_VIEW3D; } + if (srna == &RNA_SpaceGraphEditor) { return SPACE_GRAPH; } + if (srna == &RNA_SpaceOutliner) { return SPACE_OUTLINER; } + if (srna == &RNA_SpaceProperties) { return SPACE_PROPERTIES; } + if (srna == &RNA_SpaceFileBrowser) { return SPACE_FILE; } + if (srna == &RNA_SpaceImageEditor) { return SPACE_IMAGE; } + if (srna == &RNA_SpaceInfo) { return SPACE_INFO; } + if (srna == &RNA_SpaceSequenceEditor) { return SPACE_SEQ; } + if (srna == &RNA_SpaceTextEditor) { return SPACE_TEXT; } + if (srna == &RNA_SpaceDopeSheetEditor) { return SPACE_ACTION; } + if (srna == &RNA_SpaceNLA) { return SPACE_NLA; } + if (srna == &RNA_SpaceNodeEditor) { return SPACE_NODE; } + if (srna == &RNA_SpaceConsole) { return SPACE_CONSOLE; } + if (srna == &RNA_SpacePreferences) { return SPACE_USERPREF; } + if (srna == &RNA_SpaceClipEditor) { return SPACE_CLIP; } return SPACE_EMPTY; } diff --git a/source/blender/python/intern/bpy_traceback.c b/source/blender/python/intern/bpy_traceback.c index dd4d96cb806..77cd8d8a9b7 100644 --- a/source/blender/python/intern/bpy_traceback.c +++ b/source/blender/python/intern/bpy_traceback.c @@ -58,17 +58,20 @@ parse_syntax_error(PyObject *err, PyObject **message, PyObject **filename, /* new style errors. `err' is an instance */ *message = _PyObject_GetAttrId(err, &PyId_msg); - if (!*message) + if (!*message) { goto finally; + } v = _PyObject_GetAttrId(err, &PyId_filename); - if (!v) + if (!v) { goto finally; + } if (v == Py_None) { Py_DECREF(v); *filename = _PyUnicode_FromId(&PyId_string); - if (*filename == NULL) + if (*filename == NULL) { goto finally; + } Py_INCREF(*filename); } else { @@ -76,31 +79,36 @@ parse_syntax_error(PyObject *err, PyObject **message, PyObject **filename, } v = _PyObject_GetAttrId(err, &PyId_lineno); - if (!v) + if (!v) { goto finally; + } hold = PyLong_AsLong(v); Py_DECREF(v); - if (hold < 0 && PyErr_Occurred()) + if (hold < 0 && PyErr_Occurred()) { goto finally; + } *lineno = (int)hold; v = _PyObject_GetAttrId(err, &PyId_offset); - if (!v) + if (!v) { goto finally; + } if (v == Py_None) { *offset = -1; Py_DECREF(v); } else { hold = PyLong_AsLong(v); Py_DECREF(v); - if (hold < 0 && PyErr_Occurred()) + if (hold < 0 && PyErr_Occurred()) { goto finally; + } *offset = (int)hold; } v = _PyObject_GetAttrId(err, &PyId_text); - if (!v) + if (!v) { goto finally; + } if (v == Py_None) { Py_DECREF(v); *text = NULL; diff --git a/source/blender/python/mathutils/mathutils.c b/source/blender/python/mathutils/mathutils.c index f577ef3b441..41738ced41a 100644 --- a/source/blender/python/mathutils/mathutils.c +++ b/source/blender/python/mathutils/mathutils.c @@ -105,15 +105,17 @@ Py_hash_t mathutils_array_hash(const float *array, size_t array_len) i = 0; while (--len >= 0) { y = _Py_HashDouble((double)(array[i++])); - if (y == -1) + if (y == -1) { return -1; + } x = (x ^ y) * mult; /* the cast might truncate len; that doesn't change hash stability */ mult += (Py_hash_t)(82520UL + len + len); } x += 97531UL; - if (x == (Py_uhash_t)-1) + if (x == (Py_uhash_t)-1) { x = -2; + } return x; } @@ -392,8 +394,9 @@ int EXPP_VectorsAreEqual(const float *vecA, const float *vecB, int size, int flo { int x; for (x = 0; x < size; x++) { - if (EXPP_FloatsAreEqual(vecA[x], vecB[x], floatSteps) == 0) + if (EXPP_FloatsAreEqual(vecA[x], vecB[x], floatSteps) == 0) { return 0; + } } return 1; } @@ -425,8 +428,10 @@ unsigned char Mathutils_RegisterCallback(Mathutils_Callback *cb) /* find the first free slot */ for (i = 0; mathutils_callbacks[i]; i++) { - if (mathutils_callbacks[i] == cb) /* already registered? */ + if (mathutils_callbacks[i] == cb) { + /* already registered? */ return i; + } } BLI_assert(i + 1 < MATHUTILS_TOT_CB); @@ -611,18 +616,24 @@ PyMODINIT_FUNC PyInit_mathutils(void) PyObject *submodule; PyObject *sys_modules = PyImport_GetModuleDict(); - if (PyType_Ready(&vector_Type) < 0) + if (PyType_Ready(&vector_Type) < 0) { return NULL; - if (PyType_Ready(&matrix_Type) < 0) + } + if (PyType_Ready(&matrix_Type) < 0) { return NULL; - if (PyType_Ready(&matrix_access_Type) < 0) + } + if (PyType_Ready(&matrix_access_Type) < 0) { return NULL; - if (PyType_Ready(&euler_Type) < 0) + } + if (PyType_Ready(&euler_Type) < 0) { return NULL; - if (PyType_Ready(&quaternion_Type) < 0) + } + if (PyType_Ready(&quaternion_Type) < 0) { return NULL; - if (PyType_Ready(&color_Type) < 0) + } + if (PyType_Ready(&color_Type) < 0) { return NULL; + } mod = PyModule_Create(&M_Mathutils_module_def); diff --git a/source/blender/python/mathutils/mathutils_Color.c b/source/blender/python/mathutils/mathutils_Color.c index b05b8c81cf9..c97d2720720 100644 --- a/source/blender/python/mathutils/mathutils_Color.c +++ b/source/blender/python/mathutils/mathutils_Color.c @@ -52,8 +52,9 @@ static PyObject *Color_new(PyTypeObject *type, PyObject *args, PyObject *kwds) case 0: break; case 1: - if ((mathutils_array_parse(col, COLOR_SIZE, COLOR_SIZE, PyTuple_GET_ITEM(args, 0), "mathutils.Color()")) == -1) + if ((mathutils_array_parse(col, COLOR_SIZE, COLOR_SIZE, PyTuple_GET_ITEM(args, 0), "mathutils.Color()")) == -1) { return NULL; + } break; default: PyErr_SetString(PyExc_TypeError, @@ -101,8 +102,9 @@ PyDoc_STRVAR(Color_copy_doc, ); static PyObject *Color_copy(ColorObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } return Color_CreatePyObject(self->col, Py_TYPE(self)); } @@ -121,8 +123,9 @@ static PyObject *Color_repr(ColorObject *self) { PyObject *ret, *tuple; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } tuple = Color_ToTupleExt(self, -1); @@ -137,8 +140,9 @@ static PyObject *Color_str(ColorObject *self) { DynStr *ds; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } ds = BLI_dynstr_new(); @@ -160,8 +164,9 @@ static PyObject *Color_richcmpr(PyObject *a, PyObject *b, int op) ColorObject *colA = (ColorObject *)a; ColorObject *colB = (ColorObject *)b; - if (BaseMath_ReadCallback(colA) == -1 || BaseMath_ReadCallback(colB) == -1) + if (BaseMath_ReadCallback(colA) == -1 || BaseMath_ReadCallback(colB) == -1) { return NULL; + } ok = EXPP_VectorsAreEqual(colA->col, colB->col, COLOR_SIZE, 1) ? 0 : -1; } @@ -190,11 +195,13 @@ static PyObject *Color_richcmpr(PyObject *a, PyObject *b, int op) static Py_hash_t Color_hash(ColorObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return -1; + } - if (BaseMathObject_Prepare_ForHash(self) == -1) + if (BaseMathObject_Prepare_ForHash(self) == -1) { return -1; + } return mathutils_array_hash(self->col, COLOR_SIZE); } @@ -210,7 +217,9 @@ static int Color_len(ColorObject *UNUSED(self)) /* sequence accessor (get) */ static PyObject *Color_item(ColorObject *self, int i) { - if (i < 0) i = COLOR_SIZE - i; + if (i < 0) { + i = COLOR_SIZE - i; + } if (i < 0 || i >= COLOR_SIZE) { PyErr_SetString(PyExc_IndexError, @@ -219,8 +228,9 @@ static PyObject *Color_item(ColorObject *self, int i) return NULL; } - if (BaseMath_ReadIndexCallback(self, i) == -1) + if (BaseMath_ReadIndexCallback(self, i) == -1) { return NULL; + } return PyFloat_FromDouble(self->col[i]); @@ -231,8 +241,9 @@ static int Color_ass_item(ColorObject *self, int i, PyObject *value) { float f; - if (BaseMath_Prepare_ForWrite(self) == -1) + if (BaseMath_Prepare_ForWrite(self) == -1) { return -1; + } f = PyFloat_AsDouble(value); if (f == -1 && PyErr_Occurred()) { /* parsed item not a number */ @@ -242,7 +253,9 @@ static int Color_ass_item(ColorObject *self, int i, PyObject *value) return -1; } - if (i < 0) i = COLOR_SIZE - i; + if (i < 0) { + i = COLOR_SIZE - i; + } if (i < 0 || i >= COLOR_SIZE) { PyErr_SetString(PyExc_IndexError, "color[item] = x: " @@ -252,8 +265,9 @@ static int Color_ass_item(ColorObject *self, int i, PyObject *value) self->col[i] = f; - if (BaseMath_WriteIndexCallback(self, i) == -1) + if (BaseMath_WriteIndexCallback(self, i) == -1) { return -1; + } return 0; } @@ -264,11 +278,14 @@ static PyObject *Color_slice(ColorObject *self, int begin, int end) PyObject *tuple; int count; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } CLAMP(begin, 0, COLOR_SIZE); - if (end < 0) end = (COLOR_SIZE + 1) + end; + if (end < 0) { + end = (COLOR_SIZE + 1) + end; + } CLAMP(end, 0, COLOR_SIZE); begin = MIN2(begin, end); @@ -286,16 +303,20 @@ static int Color_ass_slice(ColorObject *self, int begin, int end, PyObject *seq) int i, size; float col[COLOR_SIZE]; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } CLAMP(begin, 0, COLOR_SIZE); - if (end < 0) end = (COLOR_SIZE + 1) + end; + if (end < 0) { + end = (COLOR_SIZE + 1) + end; + } CLAMP(end, 0, COLOR_SIZE); begin = MIN2(begin, end); - if ((size = mathutils_array_parse(col, 0, COLOR_SIZE, seq, "mathutils.Color[begin:end] = []")) == -1) + if ((size = mathutils_array_parse(col, 0, COLOR_SIZE, seq, "mathutils.Color[begin:end] = []")) == -1) { return -1; + } if (size != (end - begin)) { PyErr_SetString(PyExc_ValueError, @@ -304,8 +325,9 @@ static int Color_ass_slice(ColorObject *self, int begin, int end, PyObject *seq) return -1; } - for (i = 0; i < COLOR_SIZE; i++) + for (i = 0; i < COLOR_SIZE; i++) { self->col[begin + i] = col[i]; + } (void)BaseMath_WriteCallback(self); return 0; @@ -316,17 +338,20 @@ static PyObject *Color_subscript(ColorObject *self, PyObject *item) if (PyIndex_Check(item)) { Py_ssize_t i; i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; - if (i < 0) + } + if (i < 0) { i += COLOR_SIZE; + } return Color_item(self, i); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, COLOR_SIZE, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, COLOR_SIZE, &start, &stop, &step, &slicelength) < 0) { return NULL; + } if (slicelength <= 0) { return PyTuple_New(0); @@ -352,20 +377,24 @@ static int Color_ass_subscript(ColorObject *self, PyObject *item, PyObject *valu { if (PyIndex_Check(item)) { Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return -1; - if (i < 0) + } + if (i < 0) { i += COLOR_SIZE; + } return Color_ass_item(self, i, value); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, COLOR_SIZE, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, COLOR_SIZE, &start, &stop, &step, &slicelength) < 0) { return -1; + } - if (step == 1) + if (step == 1) { return Color_ass_slice(self, start, stop, value); + } else { PyErr_SetString(PyExc_IndexError, "slice steps not supported with color"); @@ -419,8 +448,9 @@ static PyObject *Color_add(PyObject *v1, PyObject *v2) color1 = (ColorObject *)v1; color2 = (ColorObject *)v2; - if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1) + if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1) { return NULL; + } add_vn_vnvn(col, color1->col, color2->col, COLOR_SIZE); @@ -442,8 +472,9 @@ static PyObject *Color_iadd(PyObject *v1, PyObject *v2) color1 = (ColorObject *)v1; color2 = (ColorObject *)v2; - if (BaseMath_ReadCallback_ForWrite(color1) == -1 || BaseMath_ReadCallback(color2) == -1) + if (BaseMath_ReadCallback_ForWrite(color1) == -1 || BaseMath_ReadCallback(color2) == -1) { return NULL; + } add_vn_vn(color1->col, color2->col, COLOR_SIZE); @@ -468,8 +499,9 @@ static PyObject *Color_sub(PyObject *v1, PyObject *v2) color1 = (ColorObject *)v1; color2 = (ColorObject *)v2; - if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1) + if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1) { return NULL; + } sub_vn_vnvn(col, color1->col, color2->col, COLOR_SIZE); @@ -491,8 +523,9 @@ static PyObject *Color_isub(PyObject *v1, PyObject *v2) color1 = (ColorObject *)v1; color2 = (ColorObject *)v2; - if (BaseMath_ReadCallback_ForWrite(color1) == -1 || BaseMath_ReadCallback(color2) == -1) + if (BaseMath_ReadCallback_ForWrite(color1) == -1 || BaseMath_ReadCallback(color2) == -1) { return NULL; + } sub_vn_vn(color1->col, color2->col, COLOR_SIZE); @@ -516,13 +549,15 @@ static PyObject *Color_mul(PyObject *v1, PyObject *v2) if (ColorObject_Check(v1)) { color1 = (ColorObject *)v1; - if (BaseMath_ReadCallback(color1) == -1) + if (BaseMath_ReadCallback(color1) == -1) { return NULL; + } } if (ColorObject_Check(v2)) { color2 = (ColorObject *)v2; - if (BaseMath_ReadCallback(color2) == -1) + if (BaseMath_ReadCallback(color2) == -1) { return NULL; + } } @@ -558,8 +593,9 @@ static PyObject *Color_div(PyObject *v1, PyObject *v2) if (ColorObject_Check(v1)) { color1 = (ColorObject *)v1; - if (BaseMath_ReadCallback(color1) == -1) + if (BaseMath_ReadCallback(color1) == -1) { return NULL; + } } else { PyErr_SetString(PyExc_TypeError, @@ -590,8 +626,9 @@ static PyObject *Color_imul(PyObject *v1, PyObject *v2) ColorObject *color = (ColorObject *)v1; float scalar; - if (BaseMath_ReadCallback_ForWrite(color) == -1) + if (BaseMath_ReadCallback_ForWrite(color) == -1) { return NULL; + } /* only support color *= float */ if (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) == 0) { /* COLOR *= FLOAT */ @@ -616,8 +653,9 @@ static PyObject *Color_idiv(PyObject *v1, PyObject *v2) ColorObject *color = (ColorObject *)v1; float scalar; - if (BaseMath_ReadCallback_ForWrite(color) == -1) + if (BaseMath_ReadCallback_ForWrite(color) == -1) { return NULL; + } /* only support color /= float */ if (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) == 0) { /* COLOR /= FLOAT */ @@ -648,8 +686,9 @@ static PyObject *Color_neg(ColorObject *self) { float tcol[COLOR_SIZE]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } negate_vn_vn(tcol, self->col, COLOR_SIZE); return Color_CreatePyObject(tcol, Py_TYPE(self)); @@ -718,8 +757,9 @@ static PyObject *Color_channel_hsv_get(ColorObject *self, void *type) float hsv[3]; int i = POINTER_AS_INT(type); - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } rgb_to_hsv(self->col[0], self->col[1], self->col[2], &(hsv[0]), &(hsv[1]), &(hsv[2])); @@ -739,16 +779,18 @@ static int Color_channel_hsv_set(ColorObject *self, PyObject *value, void *type) return -1; } - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } rgb_to_hsv_v(self->col, hsv); CLAMP(f, 0.0f, 1.0f); hsv[i] = f; hsv_to_rgb_v(hsv, self->col); - if (BaseMath_WriteCallback(self) == -1) + if (BaseMath_WriteCallback(self) == -1) { return -1; + } return 0; } @@ -760,8 +802,9 @@ static PyObject *Color_hsv_get(ColorObject *self, void *UNUSED(closure)) float hsv[3]; PyObject *ret; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } rgb_to_hsv(self->col[0], self->col[1], self->col[2], &(hsv[0]), &(hsv[1]), &(hsv[2])); @@ -777,11 +820,13 @@ static int Color_hsv_set(ColorObject *self, PyObject *value, void *UNUSED(closur { float hsv[3]; - if (mathutils_array_parse(hsv, 3, 3, value, "mathutils.Color.hsv = value") == -1) + if (mathutils_array_parse(hsv, 3, 3, value, "mathutils.Color.hsv = value") == -1) { return -1; + } - if (BaseMath_Prepare_ForWrite(self) == -1) + if (BaseMath_Prepare_ForWrite(self) == -1) { return -1; + } CLAMP(hsv[0], 0.0f, 1.0f); CLAMP(hsv[1], 0.0f, 1.0f); @@ -789,8 +834,9 @@ static int Color_hsv_set(ColorObject *self, PyObject *value, void *UNUSED(closur hsv_to_rgb_v(hsv, self->col); - if (BaseMath_WriteCallback(self) == -1) + if (BaseMath_WriteCallback(self) == -1) { return -1; + } return 0; } @@ -913,10 +959,12 @@ PyObject *Color_CreatePyObject( self->cb_type = self->cb_subtype = 0; /* NEW */ - if (col) + if (col) { copy_v3_v3(self->col, col); - else + } + else { zero_v3(self->col); + } self->flag = BASE_MATH_FLAG_DEFAULT; } diff --git a/source/blender/python/mathutils/mathutils_Euler.c b/source/blender/python/mathutils/mathutils_Euler.c index a3336309574..e928049644b 100644 --- a/source/blender/python/mathutils/mathutils_Euler.c +++ b/source/blender/python/mathutils/mathutils_Euler.c @@ -51,19 +51,22 @@ static PyObject *Euler_new(PyTypeObject *type, PyObject *args, PyObject *kwds) return NULL; } - if (!PyArg_ParseTuple(args, "|Os:mathutils.Euler", &seq, &order_str)) + if (!PyArg_ParseTuple(args, "|Os:mathutils.Euler", &seq, &order_str)) { return NULL; + } switch (PyTuple_GET_SIZE(args)) { case 0: break; case 2: - if ((order = euler_order_from_string(order_str, "mathutils.Euler()")) == -1) + if ((order = euler_order_from_string(order_str, "mathutils.Euler()")) == -1) { return NULL; + } ATTR_FALLTHROUGH; case 1: - if (mathutils_array_parse(eul, EULER_SIZE, EULER_SIZE, seq, "mathutils.Euler()") == -1) + if (mathutils_array_parse(eul, EULER_SIZE, EULER_SIZE, seq, "mathutils.Euler()") == -1) { return NULL; + } break; } return Euler_CreatePyObject(eul, order, type); @@ -141,8 +144,9 @@ static PyObject *Euler_to_quaternion(EulerObject *self) { float quat[4]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } eulO_to_quat(quat, self->eul, self->order); @@ -162,8 +166,9 @@ static PyObject *Euler_to_matrix(EulerObject *self) { float mat[9]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } eulO_to_mat3((float (*)[3])mat, self->eul, self->order); @@ -177,13 +182,15 @@ PyDoc_STRVAR(Euler_zero_doc, ); static PyObject *Euler_zero(EulerObject *self) { - if (BaseMath_Prepare_ForWrite(self) == -1) + if (BaseMath_Prepare_ForWrite(self) == -1) { return NULL; + } zero_v3(self->eul); - if (BaseMath_WriteCallback(self) == -1) + if (BaseMath_WriteCallback(self) == -1) { return NULL; + } Py_RETURN_NONE; } @@ -218,8 +225,9 @@ static PyObject *Euler_rotate_axis(EulerObject *self, PyObject *args) return NULL; } - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } rotate_eulO(self->eul, self->order, (char)axis, angle); @@ -241,11 +249,13 @@ static PyObject *Euler_rotate(EulerObject *self, PyObject *value) { float self_rmat[3][3], other_rmat[3][3], rmat[3][3]; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } - if (mathutils_any_to_rotmat(other_rmat, value, "euler.rotate(value)") == -1) + if (mathutils_any_to_rotmat(other_rmat, value, "euler.rotate(value)") == -1) { return NULL; + } eulO_to_mat3(self_rmat, self->eul, self->order); mul_m3_m3m3(rmat, other_rmat, self_rmat); @@ -268,8 +278,9 @@ static PyObject *Euler_make_compatible(EulerObject *self, PyObject *value) { float teul[EULER_SIZE]; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } if (mathutils_array_parse(teul, EULER_SIZE, EULER_SIZE, value, "euler.make_compatible(other), invalid 'other' arg") == -1) @@ -300,8 +311,9 @@ PyDoc_STRVAR(Euler_copy_doc, ); static PyObject *Euler_copy(EulerObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } return Euler_CreatePyObject(self->eul, self->order, Py_TYPE(self)); } @@ -320,8 +332,9 @@ static PyObject *Euler_repr(EulerObject *self) { PyObject *ret, *tuple; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } tuple = Euler_ToTupleExt(self, -1); @@ -336,8 +349,9 @@ static PyObject *Euler_str(EulerObject *self) { DynStr *ds; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } ds = BLI_dynstr_new(); @@ -357,8 +371,9 @@ static PyObject *Euler_richcmpr(PyObject *a, PyObject *b, int op) EulerObject *eulA = (EulerObject *)a; EulerObject *eulB = (EulerObject *)b; - if (BaseMath_ReadCallback(eulA) == -1 || BaseMath_ReadCallback(eulB) == -1) + if (BaseMath_ReadCallback(eulA) == -1 || BaseMath_ReadCallback(eulB) == -1) { return NULL; + } ok = ((eulA->order == eulB->order) && EXPP_VectorsAreEqual(eulA->eul, eulB->eul, EULER_SIZE, 1)) ? 0 : -1; } @@ -387,11 +402,13 @@ static PyObject *Euler_richcmpr(PyObject *a, PyObject *b, int op) static Py_hash_t Euler_hash(EulerObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return -1; + } - if (BaseMathObject_Prepare_ForHash(self) == -1) + if (BaseMathObject_Prepare_ForHash(self) == -1) { return -1; + } return mathutils_array_hash(self->eul, EULER_SIZE); } @@ -407,7 +424,9 @@ static int Euler_len(EulerObject *UNUSED(self)) /* sequence accessor (get) */ static PyObject *Euler_item(EulerObject *self, int i) { - if (i < 0) i = EULER_SIZE - i; + if (i < 0) { + i = EULER_SIZE - i; + } if (i < 0 || i >= EULER_SIZE) { PyErr_SetString(PyExc_IndexError, @@ -416,8 +435,9 @@ static PyObject *Euler_item(EulerObject *self, int i) return NULL; } - if (BaseMath_ReadIndexCallback(self, i) == -1) + if (BaseMath_ReadIndexCallback(self, i) == -1) { return NULL; + } return PyFloat_FromDouble(self->eul[i]); @@ -428,8 +448,9 @@ static int Euler_ass_item(EulerObject *self, int i, PyObject *value) { float f; - if (BaseMath_Prepare_ForWrite(self) == -1) + if (BaseMath_Prepare_ForWrite(self) == -1) { return -1; + } f = PyFloat_AsDouble(value); if (f == -1 && PyErr_Occurred()) { /* parsed item not a number */ @@ -439,7 +460,9 @@ static int Euler_ass_item(EulerObject *self, int i, PyObject *value) return -1; } - if (i < 0) i = EULER_SIZE - i; + if (i < 0) { + i = EULER_SIZE - i; + } if (i < 0 || i >= EULER_SIZE) { PyErr_SetString(PyExc_IndexError, @@ -450,8 +473,9 @@ static int Euler_ass_item(EulerObject *self, int i, PyObject *value) self->eul[i] = f; - if (BaseMath_WriteIndexCallback(self, i) == -1) + if (BaseMath_WriteIndexCallback(self, i) == -1) { return -1; + } return 0; } @@ -462,11 +486,14 @@ static PyObject *Euler_slice(EulerObject *self, int begin, int end) PyObject *tuple; int count; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } CLAMP(begin, 0, EULER_SIZE); - if (end < 0) end = (EULER_SIZE + 1) + end; + if (end < 0) { + end = (EULER_SIZE + 1) + end; + } CLAMP(end, 0, EULER_SIZE); begin = MIN2(begin, end); @@ -484,16 +511,20 @@ static int Euler_ass_slice(EulerObject *self, int begin, int end, PyObject *seq) int i, size; float eul[EULER_SIZE]; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } CLAMP(begin, 0, EULER_SIZE); - if (end < 0) end = (EULER_SIZE + 1) + end; + if (end < 0) { + end = (EULER_SIZE + 1) + end; + } CLAMP(end, 0, EULER_SIZE); begin = MIN2(begin, end); - if ((size = mathutils_array_parse(eul, 0, EULER_SIZE, seq, "mathutils.Euler[begin:end] = []")) == -1) + if ((size = mathutils_array_parse(eul, 0, EULER_SIZE, seq, "mathutils.Euler[begin:end] = []")) == -1) { return -1; + } if (size != (end - begin)) { PyErr_SetString(PyExc_ValueError, @@ -502,8 +533,9 @@ static int Euler_ass_slice(EulerObject *self, int begin, int end, PyObject *seq) return -1; } - for (i = 0; i < EULER_SIZE; i++) + for (i = 0; i < EULER_SIZE; i++) { self->eul[begin + i] = eul[i]; + } (void)BaseMath_WriteCallback(self); return 0; @@ -514,17 +546,20 @@ static PyObject *Euler_subscript(EulerObject *self, PyObject *item) if (PyIndex_Check(item)) { Py_ssize_t i; i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; - if (i < 0) + } + if (i < 0) { i += EULER_SIZE; + } return Euler_item(self, i); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, EULER_SIZE, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, EULER_SIZE, &start, &stop, &step, &slicelength) < 0) { return NULL; + } if (slicelength <= 0) { return PyTuple_New(0); @@ -551,20 +586,24 @@ static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *valu { if (PyIndex_Check(item)) { Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return -1; - if (i < 0) + } + if (i < 0) { i += EULER_SIZE; + } return Euler_ass_item(self, i, value); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, EULER_SIZE, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, EULER_SIZE, &start, &stop, &step, &slicelength) < 0) { return -1; + } - if (step == 1) + if (step == 1) { return Euler_ass_slice(self, start, stop, value); + } else { PyErr_SetString(PyExc_IndexError, "slice steps not supported with euler"); @@ -621,8 +660,10 @@ PyDoc_STRVAR(Euler_order_doc, ); static PyObject *Euler_order_get(EulerObject *self, void *UNUSED(closure)) { - if (BaseMath_ReadCallback(self) == -1) /* can read order too */ + if (BaseMath_ReadCallback(self) == -1) { + /* can read order too */ return NULL; + } return PyUnicode_FromString(euler_order_str(self)); } @@ -632,8 +673,9 @@ static int Euler_order_set(EulerObject *self, PyObject *value, void *UNUSED(clos const char *order_str; short order; - if (BaseMath_Prepare_ForWrite(self) == -1) + if (BaseMath_Prepare_ForWrite(self) == -1) { return -1; + } if (((order_str = _PyUnicode_AsString(value)) == NULL) || ((order = euler_order_from_string(order_str, "euler.order")) == -1)) diff --git a/source/blender/python/mathutils/mathutils_Matrix.c b/source/blender/python/mathutils/mathutils_Matrix.c index 1f2d955c449..6477493d4a6 100644 --- a/source/blender/python/mathutils/mathutils_Matrix.c +++ b/source/blender/python/mathutils/mathutils_Matrix.c @@ -89,10 +89,12 @@ static int mathutils_matrix_row_get(BaseMathObject *bmo, int row) MatrixObject *self = (MatrixObject *)bmo->cb_user; int col; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return -1; - if (!matrix_row_vector_check(self, (VectorObject *)bmo, row)) + } + if (!matrix_row_vector_check(self, (VectorObject *)bmo, row)) { return -1; + } for (col = 0; col < self->num_col; col++) { bmo->data[col] = MATRIX_ITEM(self, row, col); @@ -106,10 +108,12 @@ static int mathutils_matrix_row_set(BaseMathObject *bmo, int row) MatrixObject *self = (MatrixObject *)bmo->cb_user; int col; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; - if (!matrix_row_vector_check(self, (VectorObject *)bmo, row)) + } + if (!matrix_row_vector_check(self, (VectorObject *)bmo, row)) { return -1; + } for (col = 0; col < self->num_col; col++) { MATRIX_ITEM(self, row, col) = bmo->data[col]; @@ -123,10 +127,12 @@ static int mathutils_matrix_row_get_index(BaseMathObject *bmo, int row, int col) { MatrixObject *self = (MatrixObject *)bmo->cb_user; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return -1; - if (!matrix_row_vector_check(self, (VectorObject *)bmo, row)) + } + if (!matrix_row_vector_check(self, (VectorObject *)bmo, row)) { return -1; + } bmo->data[col] = MATRIX_ITEM(self, row, col); return 0; @@ -136,10 +142,12 @@ static int mathutils_matrix_row_set_index(BaseMathObject *bmo, int row, int col) { MatrixObject *self = (MatrixObject *)bmo->cb_user; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; - if (!matrix_row_vector_check(self, (VectorObject *)bmo, row)) + } + if (!matrix_row_vector_check(self, (VectorObject *)bmo, row)) { return -1; + } MATRIX_ITEM(self, row, col) = bmo->data[col]; @@ -174,10 +182,12 @@ static int mathutils_matrix_col_get(BaseMathObject *bmo, int col) int num_row; int row; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return -1; - if (!matrix_col_vector_check(self, (VectorObject *)bmo, col)) + } + if (!matrix_col_vector_check(self, (VectorObject *)bmo, col)) { return -1; + } /* for 'translation' size will always be '3' even on 4x4 vec */ num_row = min_ii(self->num_row, ((VectorObject *)bmo)->size); @@ -195,10 +205,12 @@ static int mathutils_matrix_col_set(BaseMathObject *bmo, int col) int num_row; int row; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; - if (!matrix_col_vector_check(self, (VectorObject *)bmo, col)) + } + if (!matrix_col_vector_check(self, (VectorObject *)bmo, col)) { return -1; + } /* for 'translation' size will always be '3' even on 4x4 vec */ num_row = min_ii(self->num_row, ((VectorObject *)bmo)->size); @@ -215,10 +227,12 @@ static int mathutils_matrix_col_get_index(BaseMathObject *bmo, int col, int row) { MatrixObject *self = (MatrixObject *)bmo->cb_user; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return -1; - if (!matrix_col_vector_check(self, (VectorObject *)bmo, col)) + } + if (!matrix_col_vector_check(self, (VectorObject *)bmo, col)) { return -1; + } bmo->data[row] = MATRIX_ITEM(self, row, col); return 0; @@ -228,10 +242,12 @@ static int mathutils_matrix_col_set_index(BaseMathObject *bmo, int col, int row) { MatrixObject *self = (MatrixObject *)bmo->cb_user; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; - if (!matrix_col_vector_check(self, (VectorObject *)bmo, col)) + } + if (!matrix_col_vector_check(self, (VectorObject *)bmo, col)) { return -1; + } MATRIX_ITEM(self, row, col) = bmo->data[row]; @@ -266,8 +282,9 @@ static int mathutils_matrix_translation_get(BaseMathObject *bmo, int col) MatrixObject *self = (MatrixObject *)bmo->cb_user; int row; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return -1; + } for (row = 0; row < 3; row++) { bmo->data[row] = MATRIX_ITEM(self, row, col); @@ -281,8 +298,9 @@ static int mathutils_matrix_translation_set(BaseMathObject *bmo, int col) MatrixObject *self = (MatrixObject *)bmo->cb_user; int row; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } for (row = 0; row < 3; row++) { MATRIX_ITEM(self, row, col) = bmo->data[row]; @@ -296,8 +314,9 @@ static int mathutils_matrix_translation_get_index(BaseMathObject *bmo, int col, { MatrixObject *self = (MatrixObject *)bmo->cb_user; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return -1; + } bmo->data[row] = MATRIX_ITEM(self, row, col); return 0; @@ -307,8 +326,9 @@ static int mathutils_matrix_translation_set_index(BaseMathObject *bmo, int col, { MatrixObject *self = (MatrixObject *)bmo->cb_user; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } MATRIX_ITEM(self, row, col) = bmo->data[row]; @@ -516,8 +536,9 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args) if (vec) { float tvec[3]; - if (mathutils_array_parse(tvec, 3, 3, vec, "Matrix.Rotation(angle, size, axis), invalid 'axis' arg") == -1) + if (mathutils_array_parse(tvec, 3, 3, vec, "Matrix.Rotation(angle, size, axis), invalid 'axis' arg") == -1) { return NULL; + } axis_angle_to_mat3((float (*)[3])mat, tvec, angle); } @@ -554,8 +575,9 @@ static PyObject *C_Matrix_Translation(PyObject *cls, PyObject *value) unit_m4(mat); - if (mathutils_array_parse(mat[3], 3, 4, value, "mathutils.Matrix.Translation(vector), invalid vector arg") == -1) + if (mathutils_array_parse(mat[3], 3, 4, value, "mathutils.Matrix.Translation(vector), invalid vector arg") == -1) { return NULL; + } return Matrix_CreatePyObject(&mat[0][0], 4, 4, (PyTypeObject *)cls); } @@ -1079,8 +1101,9 @@ static PyObject *Matrix_to_quaternion(MatrixObject *self) { float quat[4]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } /* must be 3-4 cols, 3-4 rows, square matrix */ if ((self->num_row < 3) || (self->num_col < 3) || (self->num_row != self->num_col)) { @@ -1125,15 +1148,18 @@ static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args) float mat[3][3]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } - if (!PyArg_ParseTuple(args, "|sO!:to_euler", &order_str, &euler_Type, &eul_compat)) + if (!PyArg_ParseTuple(args, "|sO!:to_euler", &order_str, &euler_Type, &eul_compat)) { return NULL; + } if (eul_compat) { - if (BaseMath_ReadCallback(eul_compat) == -1) + if (BaseMath_ReadCallback(eul_compat) == -1) { return NULL; + } copy_v3_v3(eul_compatf, eul_compat->eul); } @@ -1155,19 +1181,28 @@ static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args) if (order_str) { order = euler_order_from_string(order_str, "Matrix.to_euler()"); - if (order == -1) + if (order == -1) { return NULL; + } } normalize_m3(mat); if (eul_compat) { - if (order == 1) mat3_normalized_to_compatible_eul(eul, eul_compatf, mat); - else mat3_normalized_to_compatible_eulO(eul, eul_compatf, order, mat); + if (order == 1) { + mat3_normalized_to_compatible_eul(eul, eul_compatf, mat); + } + else { + mat3_normalized_to_compatible_eulO(eul, eul_compatf, order, mat); + } } else { - if (order == 1) mat3_normalized_to_eul(eul, mat); - else mat3_normalized_to_eulO(eul, order, mat); + if (order == 1) { + mat3_normalized_to_eul(eul, mat); + } + else { + mat3_normalized_to_eulO(eul, order, mat); + } } return Euler_CreatePyObject(eul, order, NULL); @@ -1228,8 +1263,9 @@ PyDoc_STRVAR(Matrix_to_4x4_doc, ); static PyObject *Matrix_to_4x4(MatrixObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (self->num_row == 4 && self->num_col == 4) { return Matrix_CreatePyObject(self->matrix, 4, 4, Py_TYPE(self)); @@ -1259,8 +1295,9 @@ static PyObject *Matrix_to_3x3(MatrixObject *self) { float mat[3][3]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if ((self->num_row < 3) || (self->num_col < 3)) { PyErr_SetString(PyExc_ValueError, @@ -1283,8 +1320,9 @@ PyDoc_STRVAR(Matrix_to_translation_doc, ); static PyObject *Matrix_to_translation(MatrixObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if ((self->num_row < 3) || self->num_col < 4) { PyErr_SetString(PyExc_ValueError, @@ -1312,8 +1350,9 @@ static PyObject *Matrix_to_scale(MatrixObject *self) float mat[3][3]; float size[3]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } /*must be 3-4 cols, 3-4 rows, square matrix */ if ((self->num_row < 3) || (self->num_col < 3)) { @@ -1401,8 +1440,9 @@ PyDoc_STRVAR(Matrix_invert_doc, ); static PyObject *Matrix_invert(MatrixObject *self, PyObject *args) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } if (matrix_invert_is_compat(self) == false) { return NULL; @@ -1419,8 +1459,9 @@ static PyObject *Matrix_invert(MatrixObject *self, PyObject *args) if (PyTuple_GET_SIZE(args) == 1) { MatrixObject *fallback = (MatrixObject *)PyTuple_GET_ITEM(args, 0); - if (BaseMath_ReadCallback(fallback) == -1) + if (BaseMath_ReadCallback(fallback) == -1) { return NULL; + } if (self != fallback) { matrix_copy(self, fallback); @@ -1451,8 +1492,9 @@ static PyObject *Matrix_inverted(MatrixObject *self, PyObject *args) { float mat[MATRIX_MAX_DIM * MATRIX_MAX_DIM]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (matrix_invert_args_check(self, args, false) == false) { return NULL; @@ -1482,8 +1524,9 @@ static PyObject *Matrix_inverted(MatrixObject *self, PyObject *args) static PyObject *Matrix_inverted_noargs(MatrixObject *self) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } if (matrix_invert_is_compat(self) == false) { return NULL; @@ -1512,8 +1555,9 @@ PyDoc_STRVAR(Matrix_invert_safe_doc, ); static PyObject *Matrix_invert_safe(MatrixObject *self) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } if (matrix_invert_is_compat(self) == false) { return NULL; @@ -1539,8 +1583,9 @@ static PyObject *Matrix_inverted_safe(MatrixObject *self) { float mat[MATRIX_MAX_DIM * MATRIX_MAX_DIM]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (matrix_invert_is_compat(self) == false) { return NULL; @@ -1563,8 +1608,9 @@ PyDoc_STRVAR(Matrix_adjugate_doc, ); static PyObject *Matrix_adjugate(MatrixObject *self) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } if (self->num_col != self->num_row) { PyErr_SetString(PyExc_ValueError, @@ -1618,11 +1664,13 @@ static PyObject *Matrix_rotate(MatrixObject *self, PyObject *value) { float self_rmat[3][3], other_rmat[3][3], rmat[3][3]; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } - if (mathutils_any_to_rotmat(other_rmat, value, "matrix.rotate(value)") == -1) + if (mathutils_any_to_rotmat(other_rmat, value, "matrix.rotate(value)") == -1) { return NULL; + } if (self->num_row != 3 || self->num_col != 3) { PyErr_SetString(PyExc_ValueError, @@ -1664,8 +1712,9 @@ static PyObject *Matrix_decompose(MatrixObject *self) return NULL; } - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } mat4_to_loc_rot_size(loc, rot, size, (float (*)[4])self->matrix); mat3_to_quat(quat, rot); @@ -1698,8 +1747,9 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args) MatrixObject *mat2 = NULL; float fac, mat[MATRIX_MAX_DIM * MATRIX_MAX_DIM]; - if (!PyArg_ParseTuple(args, "O!f:lerp", &matrix_Type, &mat2, &fac)) + if (!PyArg_ParseTuple(args, "O!f:lerp", &matrix_Type, &mat2, &fac)) { return NULL; + } if (self->num_col != mat2->num_col || self->num_row != mat2->num_row) { PyErr_SetString(PyExc_ValueError, @@ -1708,8 +1758,9 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args) return NULL; } - if (BaseMath_ReadCallback(self) == -1 || BaseMath_ReadCallback(mat2) == -1) + if (BaseMath_ReadCallback(self) == -1 || BaseMath_ReadCallback(mat2) == -1) { return NULL; + } /* TODO, different sized matrix */ if (self->num_col == 4 && self->num_row == 4) { @@ -1749,8 +1800,9 @@ PyDoc_STRVAR(Matrix_determinant_doc, ); static PyObject *Matrix_determinant(MatrixObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (self->num_col != self->num_row) { PyErr_SetString(PyExc_ValueError, @@ -1771,8 +1823,9 @@ PyDoc_STRVAR(Matrix_transpose_doc, ); static PyObject *Matrix_transpose(MatrixObject *self) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } if (self->num_col != self->num_row) { PyErr_SetString(PyExc_ValueError, @@ -1818,8 +1871,9 @@ PyDoc_STRVAR(Matrix_normalize_doc, ); static PyObject *Matrix_normalize(MatrixObject *self) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } if (self->num_col != self->num_row) { PyErr_SetString(PyExc_ValueError, @@ -1867,13 +1921,15 @@ PyDoc_STRVAR(Matrix_zero_doc, ); static PyObject *Matrix_zero(MatrixObject *self) { - if (BaseMath_Prepare_ForWrite(self) == -1) + if (BaseMath_Prepare_ForWrite(self) == -1) { return NULL; + } copy_vn_fl(self->matrix, self->num_col * self->num_row, 0.0f); - if (BaseMath_WriteCallback(self) == -1) + if (BaseMath_WriteCallback(self) == -1) { return NULL; + } Py_RETURN_NONE; @@ -1906,8 +1962,9 @@ PyDoc_STRVAR(Matrix_identity_doc, ); static PyObject *Matrix_identity(MatrixObject *self) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } if (self->num_col != self->num_row) { PyErr_SetString(PyExc_ValueError, @@ -1918,8 +1975,9 @@ static PyObject *Matrix_identity(MatrixObject *self) matrix_identity_internal(self); - if (BaseMath_WriteCallback(self) == -1) + if (BaseMath_WriteCallback(self) == -1) { return NULL; + } Py_RETURN_NONE; } @@ -1941,8 +1999,9 @@ PyDoc_STRVAR(Matrix_copy_doc, ); static PyObject *Matrix_copy(MatrixObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } return Matrix_copy_notest(self, self->matrix); } @@ -1961,8 +2020,9 @@ static PyObject *Matrix_repr(MatrixObject *self) int col, row; PyObject *rows[MATRIX_MAX_DIM] = {NULL}; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } for (row = 0; row < self->num_row; row++) { rows[row] = PyTuple_New(self->num_col); @@ -1998,8 +2058,9 @@ static PyObject *Matrix_str(MatrixObject *self) char dummy_buf[64]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } ds = BLI_dynstr_new(); @@ -2035,8 +2096,9 @@ static PyObject *Matrix_richcmpr(PyObject *a, PyObject *b, int op) MatrixObject *matA = (MatrixObject *)a; MatrixObject *matB = (MatrixObject *)b; - if (BaseMath_ReadCallback(matA) == -1 || BaseMath_ReadCallback(matB) == -1) + if (BaseMath_ReadCallback(matA) == -1 || BaseMath_ReadCallback(matB) == -1) { return NULL; + } ok = ((matA->num_row == matB->num_row) && (matA->num_col == matB->num_col) && @@ -2070,11 +2132,13 @@ static Py_hash_t Matrix_hash(MatrixObject *self) { float mat[MATRIX_MAX_DIM * MATRIX_MAX_DIM]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return -1; + } - if (BaseMathObject_Prepare_ForHash(self) == -1) + if (BaseMathObject_Prepare_ForHash(self) == -1) { return -1; + } matrix_transpose_internal(mat, self); @@ -2093,8 +2157,9 @@ static int Matrix_len(MatrixObject *self) * the wrapped vector gives direct access to the matrix data */ static PyObject *Matrix_item_row(MatrixObject *self, int row) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } if (row < 0 || row >= self->num_row) { PyErr_SetString(PyExc_IndexError, @@ -2107,8 +2172,9 @@ static PyObject *Matrix_item_row(MatrixObject *self, int row) /* same but column access */ static PyObject *Matrix_item_col(MatrixObject *self, int col) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } if (col < 0 || col >= self->num_col) { PyErr_SetString(PyExc_IndexError, @@ -2126,8 +2192,9 @@ static int Matrix_ass_item_row(MatrixObject *self, int row, PyObject *value) { int col; float vec[MATRIX_MAX_DIM]; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } if (row >= self->num_row || row < 0) { PyErr_SetString(PyExc_IndexError, @@ -2151,8 +2218,9 @@ static int Matrix_ass_item_col(MatrixObject *self, int col, PyObject *value) { int row; float vec[MATRIX_MAX_DIM]; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } if (col >= self->num_col || col < 0) { PyErr_SetString(PyExc_IndexError, @@ -2182,8 +2250,9 @@ static PyObject *Matrix_slice(MatrixObject *self, int begin, int end) PyObject *tuple; int count; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } CLAMP(begin, 0, self->num_row); CLAMP(end, 0, self->num_row); @@ -2203,8 +2272,9 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va { PyObject *value_fast; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } CLAMP(begin, 0, self->num_row); CLAMP(end, 0, self->num_row); @@ -2276,8 +2346,9 @@ static PyObject *Matrix_add(PyObject *m1, PyObject *m2) return NULL; } - if (BaseMath_ReadCallback(mat1) == -1 || BaseMath_ReadCallback(mat2) == -1) + if (BaseMath_ReadCallback(mat1) == -1 || BaseMath_ReadCallback(mat2) == -1) { return NULL; + } if (mat1->num_col != mat2->num_col || mat1->num_row != mat2->num_row) { PyErr_SetString(PyExc_ValueError, @@ -2308,8 +2379,9 @@ static PyObject *Matrix_sub(PyObject *m1, PyObject *m2) return NULL; } - if (BaseMath_ReadCallback(mat1) == -1 || BaseMath_ReadCallback(mat2) == -1) + if (BaseMath_ReadCallback(mat1) == -1 || BaseMath_ReadCallback(mat2) == -1) { return NULL; + } if (mat1->num_col != mat2->num_col || mat1->num_row != mat2->num_row) { PyErr_SetString(PyExc_ValueError, @@ -2339,13 +2411,15 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2) if (MatrixObject_Check(m1)) { mat1 = (MatrixObject *)m1; - if (BaseMath_ReadCallback(mat1) == -1) + if (BaseMath_ReadCallback(mat1) == -1) { return NULL; + } } if (MatrixObject_Check(m2)) { mat2 = (MatrixObject *)m2; - if (BaseMath_ReadCallback(mat2) == -1) + if (BaseMath_ReadCallback(mat2) == -1) { return NULL; + } } if (mat1 && mat2) { @@ -2394,13 +2468,15 @@ static PyObject *Matrix_imul(PyObject *m1, PyObject *m2) if (MatrixObject_Check(m1)) { mat1 = (MatrixObject *)m1; - if (BaseMath_ReadCallback(mat1) == -1) + if (BaseMath_ReadCallback(mat1) == -1) { return NULL; + } } if (MatrixObject_Check(m2)) { mat2 = (MatrixObject *)m2; - if (BaseMath_ReadCallback(mat2) == -1) + if (BaseMath_ReadCallback(mat2) == -1) { return NULL; + } } if (mat1 && mat2) { @@ -2448,13 +2524,15 @@ static PyObject *Matrix_matmul(PyObject *m1, PyObject *m2) if (MatrixObject_Check(m1)) { mat1 = (MatrixObject *)m1; - if (BaseMath_ReadCallback(mat1) == -1) + if (BaseMath_ReadCallback(mat1) == -1) { return NULL; + } } if (MatrixObject_Check(m2)) { mat2 = (MatrixObject *)m2; - if (BaseMath_ReadCallback(mat2) == -1) + if (BaseMath_ReadCallback(mat2) == -1) { return NULL; + } } if (mat1 && mat2) { @@ -2487,8 +2565,9 @@ static PyObject *Matrix_matmul(PyObject *m1, PyObject *m2) if (VectorObject_Check(m2)) { VectorObject *vec2 = (VectorObject *)m2; float tvec[MATRIX_MAX_DIM]; - if (BaseMath_ReadCallback(vec2) == -1) + if (BaseMath_ReadCallback(vec2) == -1) { return NULL; + } if (column_vector_multiplication(tvec, vec2, mat1) == -1) { return NULL; } @@ -2518,13 +2597,15 @@ static PyObject *Matrix_imatmul(PyObject *m1, PyObject *m2) if (MatrixObject_Check(m1)) { mat1 = (MatrixObject *)m1; - if (BaseMath_ReadCallback(mat1) == -1) + if (BaseMath_ReadCallback(mat1) == -1) { return NULL; + } } if (MatrixObject_Check(m2)) { mat2 = (MatrixObject *)m2; - if (BaseMath_ReadCallback(mat2) == -1) + if (BaseMath_ReadCallback(mat2) == -1) { return NULL; + } } if (mat1 && mat2) { @@ -2587,17 +2668,20 @@ static PyObject *Matrix_subscript(MatrixObject *self, PyObject *item) if (PyIndex_Check(item)) { Py_ssize_t i; i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; - if (i < 0) + } + if (i < 0) { i += self->num_row; + } return Matrix_item_row(self, i); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, self->num_row, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, self->num_row, &start, &stop, &step, &slicelength) < 0) { return NULL; + } if (slicelength <= 0) { return PyTuple_New(0); @@ -2623,20 +2707,24 @@ static int Matrix_ass_subscript(MatrixObject *self, PyObject *item, PyObject *va { if (PyIndex_Check(item)) { Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return -1; - if (i < 0) + } + if (i < 0) { i += self->num_row; + } return Matrix_ass_item_row(self, i, value); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, self->num_row, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, self->num_row, &start, &stop, &step, &slicelength) < 0) { return -1; + } - if (step == 1) + if (step == 1) { return Matrix_ass_slice(self, start, stop, value); + } else { PyErr_SetString(PyExc_IndexError, "slice steps not supported with matrices"); @@ -2704,8 +2792,9 @@ static PyObject *Matrix_translation_get(MatrixObject *self, void *UNUSED(closure { PyObject *ret; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } /*must be 4x4 square matrix*/ if (self->num_row != 4 || self->num_col != 4) { @@ -2724,8 +2813,9 @@ static int Matrix_translation_set(MatrixObject *self, PyObject *value, void *UNU { float tvec[3]; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } /*must be 4x4 square matrix*/ if (self->num_row != 4 || self->num_col != 4) { @@ -2769,8 +2859,9 @@ static PyObject *Matrix_median_scale_get(MatrixObject *self, void *UNUSED(closur { float mat[3][3]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } /*must be 3-4 cols, 3-4 rows, square matrix*/ if ((self->num_row < 3) || (self->num_col < 3)) { @@ -2790,14 +2881,17 @@ PyDoc_STRVAR(Matrix_is_negative_doc, ); static PyObject *Matrix_is_negative_get(MatrixObject *self, void *UNUSED(closure)) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } /*must be 3-4 cols, 3-4 rows, square matrix*/ - if (self->num_row == 4 && self->num_col == 4) + if (self->num_row == 4 && self->num_col == 4) { return PyBool_FromLong(is_negative_m4((float (*)[4])self->matrix)); - else if (self->num_row == 3 && self->num_col == 3) + } + else if (self->num_row == 3 && self->num_col == 3) { return PyBool_FromLong(is_negative_m3((float (*)[3])self->matrix)); + } else { PyErr_SetString(PyExc_AttributeError, "Matrix.is_negative: " @@ -2811,14 +2905,17 @@ PyDoc_STRVAR(Matrix_is_orthogonal_doc, ); static PyObject *Matrix_is_orthogonal_get(MatrixObject *self, void *UNUSED(closure)) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } /*must be 3-4 cols, 3-4 rows, square matrix*/ - if (self->num_row == 4 && self->num_col == 4) + if (self->num_row == 4 && self->num_col == 4) { return PyBool_FromLong(is_orthonormal_m4((float (*)[4])self->matrix)); - else if (self->num_row == 3 && self->num_col == 3) + } + else if (self->num_row == 3 && self->num_col == 3) { return PyBool_FromLong(is_orthonormal_m3((float (*)[3])self->matrix)); + } else { PyErr_SetString(PyExc_AttributeError, "Matrix.is_orthogonal: " @@ -2832,14 +2929,17 @@ PyDoc_STRVAR(Matrix_is_orthogonal_axis_vectors_doc, ); static PyObject *Matrix_is_orthogonal_axis_vectors_get(MatrixObject *self, void *UNUSED(closure)) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } /*must be 3-4 cols, 3-4 rows, square matrix*/ - if (self->num_row == 4 && self->num_col == 4) + if (self->num_row == 4 && self->num_col == 4) { return PyBool_FromLong(is_orthogonal_m4((float (*)[4])self->matrix)); - else if (self->num_row == 3 && self->num_col == 3) + } + else if (self->num_row == 3 && self->num_col == 3) { return PyBool_FromLong(is_orthogonal_m3((float (*)[3])self->matrix)); + } else { PyErr_SetString(PyExc_AttributeError, "Matrix.is_orthogonal_axis_vectors: " @@ -3208,7 +3308,9 @@ static PyObject *MatrixAccess_slice(MatrixAccessObject *self, int begin, int end } CLAMP(begin, 0, matrix_access_len); - if (end < 0) end = (matrix_access_len + 1) + end; + if (end < 0) { + end = (matrix_access_len + 1) + end; + } CLAMP(end, 0, matrix_access_len); begin = MIN2(begin, end); @@ -3227,24 +3329,28 @@ static PyObject *MatrixAccess_subscript(MatrixAccessObject *self, PyObject *item if (PyIndex_Check(item)) { Py_ssize_t i; i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; + } if (self->type == MAT_ACCESS_ROW) { - if (i < 0) + if (i < 0) { i += matrix_user->num_row; + } return Matrix_item_row(matrix_user, i); } else { /* MAT_ACCESS_ROW */ - if (i < 0) + if (i < 0) { i += matrix_user->num_col; + } return Matrix_item_col(matrix_user, i); } } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, MatrixAccess_len(self), &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, MatrixAccess_len(self), &start, &stop, &step, &slicelength) < 0) { return NULL; + } if (slicelength <= 0) { return PyTuple_New(0); @@ -3272,17 +3378,20 @@ static int MatrixAccess_ass_subscript(MatrixAccessObject *self, PyObject *item, if (PyIndex_Check(item)) { Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return -1; + } if (self->type == MAT_ACCESS_ROW) { - if (i < 0) + if (i < 0) { i += matrix_user->num_row; + } return Matrix_ass_item_row(matrix_user, i, value); } else { /* MAT_ACCESS_ROW */ - if (i < 0) + if (i < 0) { i += matrix_user->num_col; + } return Matrix_ass_item_col(matrix_user, i, value); } diff --git a/source/blender/python/mathutils/mathutils_Quaternion.c b/source/blender/python/mathutils/mathutils_Quaternion.c index 5f7ab5fface..422a1ff28fa 100644 --- a/source/blender/python/mathutils/mathutils_Quaternion.c +++ b/source/blender/python/mathutils/mathutils_Quaternion.c @@ -87,31 +87,43 @@ static PyObject *Quaternion_to_euler(QuaternionObject *self, PyObject *args) short order = EULER_ORDER_XYZ; EulerObject *eul_compat = NULL; - if (!PyArg_ParseTuple(args, "|sO!:to_euler", &order_str, &euler_Type, &eul_compat)) + if (!PyArg_ParseTuple(args, "|sO!:to_euler", &order_str, &euler_Type, &eul_compat)) { return NULL; + } - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (order_str) { order = euler_order_from_string(order_str, "Matrix.to_euler()"); - if (order == -1) + if (order == -1) { return NULL; + } } normalize_qt_qt(tquat, self->quat); if (eul_compat) { - if (BaseMath_ReadCallback(eul_compat) == -1) + if (BaseMath_ReadCallback(eul_compat) == -1) { return NULL; + } - if (order == EULER_ORDER_XYZ) quat_to_compatible_eul(eul, eul_compat->eul, tquat); - else quat_to_compatible_eulO(eul, eul_compat->eul, order, tquat); + if (order == EULER_ORDER_XYZ) { + quat_to_compatible_eul(eul, eul_compat->eul, tquat); + } + else { + quat_to_compatible_eulO(eul, eul_compat->eul, order, tquat); + } } else { - if (order == EULER_ORDER_XYZ) quat_to_eul(eul, tquat); - else quat_to_eulO(eul, order, tquat); + if (order == EULER_ORDER_XYZ) { + quat_to_eul(eul, tquat); + } + else { + quat_to_eulO(eul, order, tquat); + } } return Euler_CreatePyObject(eul, order, NULL); @@ -129,8 +141,9 @@ static PyObject *Quaternion_to_matrix(QuaternionObject *self) { float mat[9]; /* all values are set */ - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } quat_to_mat3((float (*)[3])mat, self->quat); return Matrix_CreatePyObject(mat, 3, 3, NULL); @@ -153,8 +166,9 @@ static PyObject *Quaternion_to_axis_angle(QuaternionObject *self) float axis[3]; float angle; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } normalize_qt_qt(tquat, self->quat); quat_to_axis_angle(axis, &angle, tquat); @@ -185,8 +199,9 @@ static PyObject *Quaternion_to_exponential_map(QuaternionObject *self) { float expmap[3]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } quat_to_expmap(expmap, self->quat); return Vector_CreatePyObject(expmap, 3, NULL); @@ -206,8 +221,9 @@ static PyObject *Quaternion_cross(QuaternionObject *self, PyObject *value) { float quat[QUAT_SIZE], tquat[QUAT_SIZE]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (mathutils_array_parse(tquat, QUAT_SIZE, QUAT_SIZE, value, "Quaternion.cross(other), invalid 'other' arg") == -1) @@ -233,8 +249,9 @@ static PyObject *Quaternion_dot(QuaternionObject *self, PyObject *value) { float tquat[QUAT_SIZE]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (mathutils_array_parse(tquat, QUAT_SIZE, QUAT_SIZE, value, "Quaternion.dot(other), invalid 'other' arg") == -1) @@ -259,8 +276,9 @@ static PyObject *Quaternion_rotation_difference(QuaternionObject *self, PyObject { float tquat[QUAT_SIZE], quat[QUAT_SIZE]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (mathutils_array_parse(tquat, QUAT_SIZE, QUAT_SIZE, value, "Quaternion.difference(other), invalid 'other' arg") == -1) @@ -297,8 +315,9 @@ static PyObject *Quaternion_slerp(QuaternionObject *self, PyObject *args) return NULL; } - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (mathutils_array_parse(tquat, QUAT_SIZE, QUAT_SIZE, value, "Quaternion.slerp(other), invalid 'other' arg") == -1) @@ -331,11 +350,13 @@ static PyObject *Quaternion_rotate(QuaternionObject *self, PyObject *value) float self_rmat[3][3], other_rmat[3][3], rmat[3][3]; float tquat[4], length; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } - if (mathutils_any_to_rotmat(other_rmat, value, "Quaternion.rotate(value)") == -1) + if (mathutils_any_to_rotmat(other_rmat, value, "Quaternion.rotate(value)") == -1) { return NULL; + } length = normalize_qt_qt(tquat, self->quat); quat_to_mat3(self_rmat, tquat); @@ -358,8 +379,9 @@ PyDoc_STRVAR(Quaternion_normalize_doc, ); static PyObject *Quaternion_normalize(QuaternionObject *self) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } normalize_qt(self->quat); @@ -386,8 +408,9 @@ PyDoc_STRVAR(Quaternion_invert_doc, ); static PyObject *Quaternion_invert(QuaternionObject *self) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } invert_qt(self->quat); @@ -416,8 +439,9 @@ PyDoc_STRVAR(Quaternion_identity_doc, ); static PyObject *Quaternion_identity(QuaternionObject *self) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } unit_qt(self->quat); @@ -434,8 +458,9 @@ PyDoc_STRVAR(Quaternion_negate_doc, ); static PyObject *Quaternion_negate(QuaternionObject *self) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } mul_qt_fl(self->quat, -1.0f); @@ -450,8 +475,9 @@ PyDoc_STRVAR(Quaternion_conjugate_doc, ); static PyObject *Quaternion_conjugate(QuaternionObject *self) { - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } conjugate_qt(self->quat); @@ -484,8 +510,9 @@ PyDoc_STRVAR(Quaternion_copy_doc, ); static PyObject *Quaternion_copy(QuaternionObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } return Quaternion_CreatePyObject(self->quat, Py_TYPE(self)); } @@ -502,8 +529,9 @@ static PyObject *Quaternion_repr(QuaternionObject *self) { PyObject *ret, *tuple; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } tuple = Quaternion_to_tuple_ext(self, -1); @@ -518,8 +546,9 @@ static PyObject *Quaternion_str(QuaternionObject *self) { DynStr *ds; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } ds = BLI_dynstr_new(); @@ -539,8 +568,9 @@ static PyObject *Quaternion_richcmpr(PyObject *a, PyObject *b, int op) QuaternionObject *quatA = (QuaternionObject *)a; QuaternionObject *quatB = (QuaternionObject *)b; - if (BaseMath_ReadCallback(quatA) == -1 || BaseMath_ReadCallback(quatB) == -1) + if (BaseMath_ReadCallback(quatA) == -1 || BaseMath_ReadCallback(quatB) == -1) { return NULL; + } ok = (EXPP_VectorsAreEqual(quatA->quat, quatB->quat, QUAT_SIZE, 1)) ? 0 : -1; } @@ -569,11 +599,13 @@ static PyObject *Quaternion_richcmpr(PyObject *a, PyObject *b, int op) static Py_hash_t Quaternion_hash(QuaternionObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return -1; + } - if (BaseMathObject_Prepare_ForHash(self) == -1) + if (BaseMathObject_Prepare_ForHash(self) == -1) { return -1; + } return mathutils_array_hash(self->quat, QUAT_SIZE); } @@ -589,7 +621,9 @@ static int Quaternion_len(QuaternionObject *UNUSED(self)) /* sequence accessor (get) */ static PyObject *Quaternion_item(QuaternionObject *self, int i) { - if (i < 0) i = QUAT_SIZE - i; + if (i < 0) { + i = QUAT_SIZE - i; + } if (i < 0 || i >= QUAT_SIZE) { PyErr_SetString(PyExc_IndexError, @@ -598,8 +632,9 @@ static PyObject *Quaternion_item(QuaternionObject *self, int i) return NULL; } - if (BaseMath_ReadIndexCallback(self, i) == -1) + if (BaseMath_ReadIndexCallback(self, i) == -1) { return NULL; + } return PyFloat_FromDouble(self->quat[i]); @@ -610,8 +645,9 @@ static int Quaternion_ass_item(QuaternionObject *self, int i, PyObject *ob) { float f; - if (BaseMath_Prepare_ForWrite(self) == -1) + if (BaseMath_Prepare_ForWrite(self) == -1) { return -1; + } f = (float)PyFloat_AsDouble(ob); @@ -622,7 +658,9 @@ static int Quaternion_ass_item(QuaternionObject *self, int i, PyObject *ob) return -1; } - if (i < 0) i = QUAT_SIZE - i; + if (i < 0) { + i = QUAT_SIZE - i; + } if (i < 0 || i >= QUAT_SIZE) { PyErr_SetString(PyExc_IndexError, @@ -632,8 +670,9 @@ static int Quaternion_ass_item(QuaternionObject *self, int i, PyObject *ob) } self->quat[i] = f; - if (BaseMath_WriteIndexCallback(self, i) == -1) + if (BaseMath_WriteIndexCallback(self, i) == -1) { return -1; + } return 0; } @@ -644,11 +683,14 @@ static PyObject *Quaternion_slice(QuaternionObject *self, int begin, int end) PyObject *tuple; int count; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } CLAMP(begin, 0, QUAT_SIZE); - if (end < 0) end = (QUAT_SIZE + 1) + end; + if (end < 0) { + end = (QUAT_SIZE + 1) + end; + } CLAMP(end, 0, QUAT_SIZE); begin = MIN2(begin, end); @@ -666,16 +708,20 @@ static int Quaternion_ass_slice(QuaternionObject *self, int begin, int end, PyOb int i, size; float quat[QUAT_SIZE]; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } CLAMP(begin, 0, QUAT_SIZE); - if (end < 0) end = (QUAT_SIZE + 1) + end; + if (end < 0) { + end = (QUAT_SIZE + 1) + end; + } CLAMP(end, 0, QUAT_SIZE); begin = MIN2(begin, end); - if ((size = mathutils_array_parse(quat, 0, QUAT_SIZE, seq, "mathutils.Quaternion[begin:end] = []")) == -1) + if ((size = mathutils_array_parse(quat, 0, QUAT_SIZE, seq, "mathutils.Quaternion[begin:end] = []")) == -1) { return -1; + } if (size != (end - begin)) { PyErr_SetString(PyExc_ValueError, @@ -685,8 +731,9 @@ static int Quaternion_ass_slice(QuaternionObject *self, int begin, int end, PyOb } /* parsed well - now set in vector */ - for (i = 0; i < size; i++) + for (i = 0; i < size; i++) { self->quat[begin + i] = quat[i]; + } (void)BaseMath_WriteCallback(self); return 0; @@ -698,17 +745,20 @@ static PyObject *Quaternion_subscript(QuaternionObject *self, PyObject *item) if (PyIndex_Check(item)) { Py_ssize_t i; i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; - if (i < 0) + } + if (i < 0) { i += QUAT_SIZE; + } return Quaternion_item(self, i); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, QUAT_SIZE, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, QUAT_SIZE, &start, &stop, &step, &slicelength) < 0) { return NULL; + } if (slicelength <= 0) { return PyTuple_New(0); @@ -735,20 +785,24 @@ static int Quaternion_ass_subscript(QuaternionObject *self, PyObject *item, PyOb { if (PyIndex_Check(item)) { Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return -1; - if (i < 0) + } + if (i < 0) { i += QUAT_SIZE; + } return Quaternion_ass_item(self, i, value); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, QUAT_SIZE, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, QUAT_SIZE, &start, &stop, &step, &slicelength) < 0) { return -1; + } - if (step == 1) + if (step == 1) { return Quaternion_ass_slice(self, start, stop, value); + } else { PyErr_SetString(PyExc_IndexError, "slice steps not supported with quaternion"); @@ -781,8 +835,9 @@ static PyObject *Quaternion_add(PyObject *q1, PyObject *q2) quat1 = (QuaternionObject *)q1; quat2 = (QuaternionObject *)q2; - if (BaseMath_ReadCallback(quat1) == -1 || BaseMath_ReadCallback(quat2) == -1) + if (BaseMath_ReadCallback(quat1) == -1 || BaseMath_ReadCallback(quat2) == -1) { return NULL; + } add_qt_qtqt(quat, quat1->quat, quat2->quat, 1.0f); return Quaternion_CreatePyObject(quat, Py_TYPE(q1)); @@ -806,8 +861,9 @@ static PyObject *Quaternion_sub(PyObject *q1, PyObject *q2) quat1 = (QuaternionObject *)q1; quat2 = (QuaternionObject *)q2; - if (BaseMath_ReadCallback(quat1) == -1 || BaseMath_ReadCallback(quat2) == -1) + if (BaseMath_ReadCallback(quat1) == -1 || BaseMath_ReadCallback(quat2) == -1) { return NULL; + } for (x = 0; x < QUAT_SIZE; x++) { quat[x] = quat1->quat[x] - quat2->quat[x]; @@ -833,13 +889,15 @@ static PyObject *Quaternion_mul(PyObject *q1, PyObject *q2) if (QuaternionObject_Check(q1)) { quat1 = (QuaternionObject *)q1; - if (BaseMath_ReadCallback(quat1) == -1) + if (BaseMath_ReadCallback(quat1) == -1) { return NULL; + } } if (QuaternionObject_Check(q2)) { quat2 = (QuaternionObject *)q2; - if (BaseMath_ReadCallback(quat2) == -1) + if (BaseMath_ReadCallback(quat2) == -1) { return NULL; + } } if (quat1 && quat2) { /* QUAT * QUAT (element-wise product) */ @@ -876,13 +934,15 @@ static PyObject *Quaternion_imul(PyObject *q1, PyObject *q2) if (QuaternionObject_Check(q1)) { quat1 = (QuaternionObject *)q1; - if (BaseMath_ReadCallback(quat1) == -1) + if (BaseMath_ReadCallback(quat1) == -1) { return NULL; + } } if (QuaternionObject_Check(q2)) { quat2 = (QuaternionObject *)q2; - if (BaseMath_ReadCallback(quat2) == -1) + if (BaseMath_ReadCallback(quat2) == -1) { return NULL; + } } if (quat1 && quat2) { /* QUAT *= QUAT (inplace element-wise product) */ @@ -921,13 +981,15 @@ static PyObject *Quaternion_matmul(PyObject *q1, PyObject *q2) if (QuaternionObject_Check(q1)) { quat1 = (QuaternionObject *)q1; - if (BaseMath_ReadCallback(quat1) == -1) + if (BaseMath_ReadCallback(quat1) == -1) { return NULL; + } } if (QuaternionObject_Check(q2)) { quat2 = (QuaternionObject *)q2; - if (BaseMath_ReadCallback(quat2) == -1) + if (BaseMath_ReadCallback(quat2) == -1) { return NULL; + } } if (quat1 && quat2) { /* QUAT @ QUAT (cross product) */ @@ -973,13 +1035,15 @@ static PyObject *Quaternion_imatmul(PyObject *q1, PyObject *q2) if (QuaternionObject_Check(q1)) { quat1 = (QuaternionObject *)q1; - if (BaseMath_ReadCallback(quat1) == -1) + if (BaseMath_ReadCallback(quat1) == -1) { return NULL; + } } if (QuaternionObject_Check(q2)) { quat2 = (QuaternionObject *)q2; - if (BaseMath_ReadCallback(quat2) == -1) + if (BaseMath_ReadCallback(quat2) == -1) { return NULL; + } } if (quat1 && quat2) { /* QUAT @ QUAT (cross product) */ @@ -1005,8 +1069,9 @@ static PyObject *Quaternion_neg(QuaternionObject *self) { float tquat[QUAT_SIZE]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } negate_v4_v4(tquat, self->quat); return Quaternion_CreatePyObject(tquat, Py_TYPE(self)); @@ -1090,8 +1155,9 @@ PyDoc_STRVAR(Quaternion_magnitude_doc, ); static PyObject *Quaternion_magnitude_get(QuaternionObject *self, void *UNUSED(closure)) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } return PyFloat_FromDouble(sqrtf(dot_qtqt(self->quat, self->quat))); } @@ -1104,8 +1170,9 @@ static PyObject *Quaternion_angle_get(QuaternionObject *self, void *UNUSED(closu float tquat[4]; float angle; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } normalize_qt_qt(tquat, self->quat); @@ -1124,8 +1191,9 @@ static int Quaternion_angle_set(QuaternionObject *self, PyObject *value, void *U float axis[3], angle_dummy; float angle; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } len = normalize_qt_qt(tquat, self->quat); quat_to_axis_angle(axis, &angle_dummy, tquat); @@ -1145,8 +1213,9 @@ static int Quaternion_angle_set(QuaternionObject *self, PyObject *value, void *U axis_angle_to_quat(self->quat, axis, angle); mul_qt_fl(self->quat, len); - if (BaseMath_WriteCallback(self) == -1) + if (BaseMath_WriteCallback(self) == -1) { return -1; + } return 0; } @@ -1161,8 +1230,9 @@ static PyObject *Quaternion_axis_vector_get(QuaternionObject *self, void *UNUSED float axis[3]; float angle_dummy; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } normalize_qt_qt(tquat, self->quat); quat_to_axis_angle(axis, &angle_dummy, tquat); @@ -1180,22 +1250,25 @@ static int Quaternion_axis_vector_set(QuaternionObject *self, PyObject *value, v float axis[3]; float angle; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } len = normalize_qt_qt(tquat, self->quat); quat_to_axis_angle(axis, &angle, tquat); /* axis value is unused */ - if (mathutils_array_parse(axis, 3, 3, value, "quat.axis = other") == -1) + if (mathutils_array_parse(axis, 3, 3, value, "quat.axis = other") == -1) { return -1; + } quat__axis_angle_sanitize(axis, &angle); axis_angle_to_quat(self->quat, axis, angle); mul_qt_fl(self->quat, len); - if (BaseMath_WriteCallback(self) == -1) + if (BaseMath_WriteCallback(self) == -1) { return -1; + } return 0; } @@ -1215,8 +1288,9 @@ static PyObject *Quaternion_new(PyTypeObject *type, PyObject *args, PyObject *kw return NULL; } - if (!PyArg_ParseTuple(args, "|Od:mathutils.Quaternion", &seq, &angle)) + if (!PyArg_ParseTuple(args, "|Od:mathutils.Quaternion", &seq, &angle)) { return NULL; + } switch (PyTuple_GET_SIZE(args)) { case 0: @@ -1243,8 +1317,9 @@ static PyObject *Quaternion_new(PyTypeObject *type, PyObject *args, PyObject *kw case 2: { float axis[3]; - if (mathutils_array_parse(axis, 3, 3, seq, "mathutils.Quaternion()") == -1) + if (mathutils_array_parse(axis, 3, 3, seq, "mathutils.Quaternion()") == -1) { return NULL; + } angle = angle_wrap_rad(angle); /* clamp because of precision issues */ axis_angle_to_quat(quat, axis, angle); break; diff --git a/source/blender/python/mathutils/mathutils_Vector.c b/source/blender/python/mathutils/mathutils_Vector.c index 11b8eff85f6..1dd578096f9 100644 --- a/source/blender/python/mathutils/mathutils_Vector.c +++ b/source/blender/python/mathutils/mathutils_Vector.c @@ -197,8 +197,9 @@ static PyObject *C_Vector_Range(PyObject *cls, PyObject *args) size = (stop - start); - if ((size % step) != 0) + if ((size % step) != 0) { size += step; + } size /= step; @@ -338,13 +339,15 @@ PyDoc_STRVAR(Vector_zero_doc, ); static PyObject *Vector_zero(VectorObject *self) { - if (BaseMath_Prepare_ForWrite(self) == -1) + if (BaseMath_Prepare_ForWrite(self) == -1) { return NULL; + } copy_vn_fl(self->vec, self->size, 0.0f); - if (BaseMath_WriteCallback(self) == -1) + if (BaseMath_WriteCallback(self) == -1) { return NULL; + } Py_RETURN_NONE; } @@ -362,8 +365,9 @@ PyDoc_STRVAR(Vector_normalize_doc, static PyObject *Vector_normalize(VectorObject *self) { int size = (self->size == 4 ? 3 : self->size); - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } normalize_vn(self->vec, size); @@ -533,8 +537,9 @@ static PyObject *Vector_resize_3d(VectorObject *self) return NULL; } - if (self->size == 2) + if (self->size == 2) { self->vec[2] = 0.0f; + } self->size = 3; Py_RETURN_NONE; @@ -588,8 +593,9 @@ PyDoc_STRVAR(Vector_to_2d_doc, ); static PyObject *Vector_to_2d(VectorObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } return Vector_CreatePyObject(self->vec, 2, Py_TYPE(self)); } @@ -605,8 +611,9 @@ static PyObject *Vector_to_3d(VectorObject *self) { float tvec[3] = {0.0f}; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } memcpy(tvec, self->vec, sizeof(float) * MIN2(self->size, 3)); return Vector_CreatePyObject(tvec, 3, Py_TYPE(self)); @@ -623,8 +630,9 @@ static PyObject *Vector_to_4d(VectorObject *self) { float tvec[4] = {0.0f, 0.0f, 0.0f, 1.0f}; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } memcpy(tvec, self->vec, sizeof(float) * MIN2(self->size, 4)); return Vector_CreatePyObject(tvec, 4, Py_TYPE(self)); @@ -666,8 +674,9 @@ static PyObject *Vector_to_tuple(VectorObject *self, PyObject *args) { int ndigits = 0; - if (!PyArg_ParseTuple(args, "|i:to_tuple", &ndigits)) + if (!PyArg_ParseTuple(args, "|i:to_tuple", &ndigits)) { return NULL; + } if (ndigits > 22 || ndigits < 0) { PyErr_SetString(PyExc_ValueError, @@ -676,11 +685,13 @@ static PyObject *Vector_to_tuple(VectorObject *self, PyObject *args) return NULL; } - if (PyTuple_GET_SIZE(args) == 0) + if (PyTuple_GET_SIZE(args) == 0) { ndigits = -1; + } - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } return Vector_to_tuple_ext(self, ndigits); } @@ -703,8 +714,9 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args) const char *strack, *sup; short track = 2, up = 1; - if (!PyArg_ParseTuple(args, "|ss:to_track_quat", &strack, &sup)) + if (!PyArg_ParseTuple(args, "|ss:to_track_quat", &strack, &sup)) { return NULL; + } if (self->size != 3) { PyErr_SetString(PyExc_TypeError, @@ -713,8 +725,9 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args) return NULL; } - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (strack) { const char *axis_err_msg = "only X, -X, Y, -Y, Z or -Z for track axis"; @@ -826,13 +839,16 @@ static PyObject *Vector_orthogonal(VectorObject *self) return NULL; } - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } - if (self->size == 3) + if (self->size == 3) { ortho_v3_v3(vec, self->vec); - else + } + else { ortho_v2_v2(vec, self->vec); + } return Vector_CreatePyObject(vec, self->size, Py_TYPE(self)); } @@ -861,11 +877,13 @@ static PyObject *Vector_reflect(VectorObject *self, PyObject *value) float reflect[3] = {0.0f}; float tvec[MAX_DIMENSIONS]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } - if ((value_size = mathutils_array_parse(tvec, 2, 4, value, "Vector.reflect(other), invalid 'other' arg")) == -1) + if ((value_size = mathutils_array_parse(tvec, 2, 4, value, "Vector.reflect(other), invalid 'other' arg")) == -1) { return NULL; + } if (self->size < 2 || self->size > 4) { PyErr_SetString(PyExc_ValueError, @@ -904,8 +922,9 @@ static PyObject *Vector_cross(VectorObject *self, PyObject *value) PyObject *ret; float tvec[3]; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (self->size > 3) { PyErr_SetString(PyExc_ValueError, @@ -913,8 +932,9 @@ static PyObject *Vector_cross(VectorObject *self, PyObject *value) return NULL; } - if (mathutils_array_parse(tvec, self->size, self->size, value, "Vector.cross(other), invalid 'other' arg") == -1) + if (mathutils_array_parse(tvec, self->size, self->size, value, "Vector.cross(other), invalid 'other' arg") == -1) { return NULL; + } if (self->size == 3) { ret = Vector_CreatePyObject(NULL, 3, Py_TYPE(self)); @@ -942,8 +962,9 @@ static PyObject *Vector_dot(VectorObject *self, PyObject *value) float *tvec; PyObject *ret; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (mathutils_array_parse_alloc(&tvec, self->size, value, "Vector.dot(other), invalid 'other' arg") == -1) { return NULL; @@ -976,16 +997,19 @@ static PyObject *Vector_angle(VectorObject *self, PyObject *args) int x; PyObject *fallback = NULL; - if (!PyArg_ParseTuple(args, "O|O:angle", &value, &fallback)) + if (!PyArg_ParseTuple(args, "O|O:angle", &value, &fallback)) { return NULL; + } - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } /* don't use clamped size, rule of thumb is vector sizes must match, * even though n this case 'w' is ignored */ - if (mathutils_array_parse(tvec, self->size, self->size, value, "Vector.angle(other), invalid 'other' arg") == -1) + if (mathutils_array_parse(tvec, self->size, self->size, value, "Vector.angle(other), invalid 'other' arg") == -1) { return NULL; + } if (self->size > 4) { PyErr_SetString(PyExc_ValueError, @@ -1036,14 +1060,17 @@ static PyObject *Vector_angle_signed(VectorObject *self, PyObject *args) PyObject *value; PyObject *fallback = NULL; - if (!PyArg_ParseTuple(args, "O|O:angle_signed", &value, &fallback)) + if (!PyArg_ParseTuple(args, "O|O:angle_signed", &value, &fallback)) { return NULL; + } - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } - if (mathutils_array_parse(tvec, 2, 2, value, "Vector.angle_signed(other), invalid 'other' arg") == -1) + if (mathutils_array_parse(tvec, 2, 2, value, "Vector.angle_signed(other), invalid 'other' arg") == -1) { return NULL; + } if (self->size != 2) { PyErr_SetString(PyExc_ValueError, @@ -1094,11 +1121,13 @@ static PyObject *Vector_rotation_difference(VectorObject *self, PyObject *value) return NULL; } - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } - if (mathutils_array_parse(vec_b, 3, MAX_DIMENSIONS, value, "Vector.difference(other), invalid 'other' arg") == -1) + if (mathutils_array_parse(vec_b, 3, MAX_DIMENSIONS, value, "Vector.difference(other), invalid 'other' arg") == -1) { return NULL; + } normalize_v3_v3(vec_a, self->vec); normalize_v3(vec_b); @@ -1125,8 +1154,9 @@ static PyObject *Vector_project(VectorObject *self, PyObject *value) double dot = 0.0f, dot2 = 0.0f; int x; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } if (mathutils_array_parse_alloc(&tvec, size, value, "Vector.project(other), invalid 'other' arg") == -1) { return NULL; @@ -1164,8 +1194,9 @@ static PyObject *Vector_lerp(VectorObject *self, PyObject *args) float fac; float *tvec; - if (!PyArg_ParseTuple(args, "Of:lerp", &value, &fac)) + if (!PyArg_ParseTuple(args, "Of:lerp", &value, &fac)) { return NULL; + } if (BaseMath_ReadCallback(self) == -1) { return NULL; @@ -1205,8 +1236,9 @@ static PyObject *Vector_slerp(VectorObject *self, PyObject *args) int x; PyObject *fallback = NULL; - if (!PyArg_ParseTuple(args, "Of|O:slerp", &value, &fac, &fallback)) + if (!PyArg_ParseTuple(args, "Of|O:slerp", &value, &fac, &fallback)) { return NULL; + } if (BaseMath_ReadCallback(self) == -1) { return NULL; @@ -1281,11 +1313,13 @@ static PyObject *Vector_rotate(VectorObject *self, PyObject *value) { float other_rmat[3][3]; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return NULL; + } - if (mathutils_any_to_rotmat(other_rmat, value, "Vector.rotate(value)") == -1) + if (mathutils_any_to_rotmat(other_rmat, value, "Vector.rotate(value)") == -1) { return NULL; + } if (self->size < 3 || self->size > 4) { PyErr_SetString(PyExc_ValueError, @@ -1312,8 +1346,9 @@ PyDoc_STRVAR(Vector_copy_doc, ); static PyObject *Vector_copy(VectorObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } return Vector_CreatePyObject(self->vec, self->size, Py_TYPE(self)); } @@ -1329,8 +1364,9 @@ static PyObject *Vector_repr(VectorObject *self) { PyObject *ret, *tuple; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } tuple = Vector_to_tuple_ext(self, -1); ret = PyUnicode_FromFormat("Vector(%R)", tuple); @@ -1345,8 +1381,9 @@ static PyObject *Vector_str(VectorObject *self) DynStr *ds; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } ds = BLI_dynstr_new(); @@ -1371,7 +1408,9 @@ static int Vector_len(VectorObject *self) /* sequence accessor (get): vector[index] */ static PyObject *vector_item_internal(VectorObject *self, int i, const bool is_attr) { - if (i < 0) i = self->size - i; + if (i < 0) { + i = self->size - i; + } if (i < 0 || i >= self->size) { if (is_attr) { @@ -1386,8 +1425,9 @@ static PyObject *vector_item_internal(VectorObject *self, int i, const bool is_a return NULL; } - if (BaseMath_ReadIndexCallback(self, i) == -1) + if (BaseMath_ReadIndexCallback(self, i) == -1) { return NULL; + } return PyFloat_FromDouble(self->vec[i]); } @@ -1401,8 +1441,9 @@ static int vector_ass_item_internal(VectorObject *self, int i, PyObject *value, { float scalar; - if (BaseMath_Prepare_ForWrite(self) == -1) + if (BaseMath_Prepare_ForWrite(self) == -1) { return -1; + } if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */ PyErr_SetString(PyExc_TypeError, @@ -1411,7 +1452,9 @@ static int vector_ass_item_internal(VectorObject *self, int i, PyObject *value, return -1; } - if (i < 0) i = self->size - i; + if (i < 0) { + i = self->size - i; + } if (i < 0 || i >= self->size) { if (is_attr) { @@ -1428,8 +1471,9 @@ static int vector_ass_item_internal(VectorObject *self, int i, PyObject *value, } self->vec[i] = scalar; - if (BaseMath_WriteIndexCallback(self, i) == -1) + if (BaseMath_WriteIndexCallback(self, i) == -1) { return -1; + } return 0; } @@ -1444,11 +1488,14 @@ static PyObject *Vector_slice(VectorObject *self, int begin, int end) PyObject *tuple; int count; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } CLAMP(begin, 0, self->size); - if (end < 0) end = self->size + end + 1; + if (end < 0) { + end = self->size + end + 1; + } CLAMP(end, 0, self->size); begin = MIN2(begin, end); @@ -1465,8 +1512,9 @@ static int Vector_ass_slice(VectorObject *self, int begin, int end, PyObject *se int size = 0; float *vec = NULL; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } CLAMP(begin, 0, self->size); CLAMP(end, 0, self->size); @@ -1489,8 +1537,9 @@ static int Vector_ass_slice(VectorObject *self, int begin, int end, PyObject *se PyMem_Free(vec); - if (BaseMath_WriteCallback(self) == -1) + if (BaseMath_WriteCallback(self) == -1) { return -1; + } return 0; } @@ -1512,8 +1561,9 @@ static PyObject *Vector_add(PyObject *v1, PyObject *v2) vec1 = (VectorObject *)v1; vec2 = (VectorObject *)v2; - if (BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1) + if (BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1) { return NULL; + } /*VECTOR + VECTOR*/ if (vec1->size != vec2->size) { @@ -1558,8 +1608,9 @@ static PyObject *Vector_iadd(PyObject *v1, PyObject *v2) return NULL; } - if (BaseMath_ReadCallback_ForWrite(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1) + if (BaseMath_ReadCallback_ForWrite(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1) { return NULL; + } add_vn_vn(vec1->vec, vec2->vec, vec1->size); @@ -1584,8 +1635,9 @@ static PyObject *Vector_sub(PyObject *v1, PyObject *v2) vec1 = (VectorObject *)v1; vec2 = (VectorObject *)v2; - if (BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1) + if (BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1) { return NULL; + } if (vec1->size != vec2->size) { PyErr_SetString(PyExc_AttributeError, @@ -1629,8 +1681,9 @@ static PyObject *Vector_isub(PyObject *v1, PyObject *v2) return NULL; } - if (BaseMath_ReadCallback_ForWrite(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1) + if (BaseMath_ReadCallback_ForWrite(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1) { return NULL; + } sub_vn_vn(vec1->vec, vec2->vec, vec1->size); @@ -1722,13 +1775,15 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2) if (VectorObject_Check(v1)) { vec1 = (VectorObject *)v1; - if (BaseMath_ReadCallback(vec1) == -1) + if (BaseMath_ReadCallback(vec1) == -1) { return NULL; + } } if (VectorObject_Check(v2)) { vec2 = (VectorObject *)v2; - if (BaseMath_ReadCallback(vec2) == -1) + if (BaseMath_ReadCallback(vec2) == -1) { return NULL; + } } @@ -1774,17 +1829,20 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2) if (VectorObject_Check(v1)) { vec1 = (VectorObject *)v1; - if (BaseMath_ReadCallback(vec1) == -1) + if (BaseMath_ReadCallback(vec1) == -1) { return NULL; + } } if (VectorObject_Check(v2)) { vec2 = (VectorObject *)v2; - if (BaseMath_ReadCallback(vec2) == -1) + if (BaseMath_ReadCallback(vec2) == -1) { return NULL; + } } - if (BaseMath_ReadCallback_ForWrite(vec1) == -1) + if (BaseMath_ReadCallback_ForWrite(vec1) == -1) { return NULL; + } /* Intentionally don't support (Quaternion, Matrix) here, uses reverse order instead. */ @@ -1830,13 +1888,15 @@ static PyObject *Vector_matmul(PyObject *v1, PyObject *v2) if (VectorObject_Check(v1)) { vec1 = (VectorObject *)v1; - if (BaseMath_ReadCallback(vec1) == -1) + if (BaseMath_ReadCallback(vec1) == -1) { return NULL; + } } if (VectorObject_Check(v2)) { vec2 = (VectorObject *)v2; - if (BaseMath_ReadCallback(vec2) == -1) + if (BaseMath_ReadCallback(vec2) == -1) { return NULL; + } } @@ -1859,8 +1919,9 @@ static PyObject *Vector_matmul(PyObject *v1, PyObject *v2) /* VEC @ MATRIX */ float tvec[MAX_DIMENSIONS]; - if (BaseMath_ReadCallback((MatrixObject *)v2) == -1) + if (BaseMath_ReadCallback((MatrixObject *)v2) == -1) { return NULL; + } if (row_vector_multiplication(tvec, vec1, (MatrixObject *)v2) == -1) { return NULL; } @@ -1906,8 +1967,9 @@ static PyObject *Vector_div(PyObject *v1, PyObject *v2) } vec1 = (VectorObject *)v1; /* vector */ - if (BaseMath_ReadCallback(vec1) == -1) + if (BaseMath_ReadCallback(vec1) == -1) { return NULL; + } if ((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */ PyErr_SetString(PyExc_TypeError, @@ -1943,8 +2005,9 @@ static PyObject *Vector_idiv(PyObject *v1, PyObject *v2) float scalar; VectorObject *vec1 = (VectorObject *)v1; - if (BaseMath_ReadCallback_ForWrite(vec1) == -1) + if (BaseMath_ReadCallback_ForWrite(vec1) == -1) { return NULL; + } if ((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */ PyErr_SetString(PyExc_TypeError, @@ -1974,8 +2037,9 @@ static PyObject *Vector_neg(VectorObject *self) { float *tvec; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } tvec = PyMem_Malloc(self->size * sizeof(float)); negate_vn_vn(tvec, self->vec, self->size); @@ -2002,8 +2066,9 @@ static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa vecA = (VectorObject *)objectA; vecB = (VectorObject *)objectB; - if (BaseMath_ReadCallback(vecA) == -1 || BaseMath_ReadCallback(vecB) == -1) + if (BaseMath_ReadCallback(vecA) == -1 || BaseMath_ReadCallback(vecB) == -1) { return NULL; + } if (vecA->size != vecB->size) { if (comparison_type == Py_NE) { @@ -2069,11 +2134,13 @@ static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa static Py_hash_t Vector_hash(VectorObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return -1; + } - if (BaseMathObject_Prepare_ForHash(self) == -1) + if (BaseMathObject_Prepare_ForHash(self) == -1) { return -1; + } return mathutils_array_hash(self->vec, self->size); } @@ -2097,17 +2164,20 @@ static PyObject *Vector_subscript(VectorObject *self, PyObject *item) if (PyIndex_Check(item)) { Py_ssize_t i; i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return NULL; - if (i < 0) + } + if (i < 0) { i += self->size; + } return Vector_item(self, i); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, self->size, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, self->size, &start, &stop, &step, &slicelength) < 0) { return NULL; + } if (slicelength <= 0) { return PyTuple_New(0); @@ -2133,20 +2203,24 @@ static int Vector_ass_subscript(VectorObject *self, PyObject *item, PyObject *va { if (PyIndex_Check(item)) { Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) + if (i == -1 && PyErr_Occurred()) { return -1; - if (i < 0) + } + if (i < 0) { i += self->size; + } return Vector_ass_item(self, i, value); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; - if (PySlice_GetIndicesEx(item, self->size, &start, &stop, &step, &slicelength) < 0) + if (PySlice_GetIndicesEx(item, self->size, &start, &stop, &step, &slicelength) < 0) { return -1; + } - if (step == 1) + if (step == 1) { return Vector_ass_slice(self, start, stop, value); + } else { PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors"); @@ -2233,8 +2307,9 @@ PyDoc_STRVAR(Vector_length_doc, ); static PyObject *Vector_length_get(VectorObject *self, void *UNUSED(closure)) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } return PyFloat_FromDouble(sqrt(dot_vn_vn(self->vec, self->vec, self->size))); } @@ -2243,8 +2318,9 @@ static int Vector_length_set(VectorObject *self, PyObject *value) { double dot = 0.0f, param; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } if ((param = PyFloat_AsDouble(value)) == -1.0 && PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, @@ -2264,13 +2340,16 @@ static int Vector_length_set(VectorObject *self, PyObject *value) dot = dot_vn_vn(self->vec, self->vec, self->size); - if (!dot) /* cant sqrt zero */ + if (!dot) { + /* cant sqrt zero */ return 0; + } dot = sqrt(dot); - if (dot == param) + if (dot == param) { return 0; + } dot = dot / param; @@ -2287,8 +2366,9 @@ PyDoc_STRVAR(Vector_length_squared_doc, ); static PyObject *Vector_length_squared_get(VectorObject *self, void *UNUSED(closure)) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } return PyFloat_FromDouble(dot_vn_vn(self->vec, self->vec, self->size)); } @@ -2359,8 +2439,9 @@ static PyObject *Vector_swizzle_get(VectorObject *self, void *closure) float vec[MAX_DIMENSIONS]; unsigned int swizzleClosure; - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } /* Unpack the axes from the closure into an array. */ axis_to = 0; @@ -2406,8 +2487,9 @@ static int Vector_swizzle_set(VectorObject *self, PyObject *value, void *closure float tvec[MAX_DIMENSIONS]; float vec_assign[MAX_DIMENSIONS]; - if (BaseMath_ReadCallback_ForWrite(self) == -1) + if (BaseMath_ReadCallback_ForWrite(self) == -1) { return -1; + } /* Check that the closure can be used with this vector: even 2D vectors have * swizzles defined for axes z and w, but they would be invalid. */ @@ -2469,10 +2551,12 @@ static int Vector_swizzle_set(VectorObject *self, PyObject *value, void *closure memcpy(self->vec, tvec, self->size * sizeof(float)); /* continue with BaseMathObject_WriteCallback at the end */ - if (BaseMath_WriteCallback(self) == -1) + if (BaseMath_WriteCallback(self) == -1) { return -1; - else + } + else { return 0; + } } #define _SWIZZLE1(a) ((a) | SWIZZLE_VALID_AXIS) @@ -2876,8 +2960,9 @@ static int row_vector_multiplication(float r_vec[MAX_DIMENSIONS], VectorObject * } } - if (BaseMath_ReadCallback(vec) == -1 || BaseMath_ReadCallback(mat) == -1) + if (BaseMath_ReadCallback(vec) == -1 || BaseMath_ReadCallback(mat) == -1) { return -1; + } memcpy(vec_cpy, vec->vec, vec_size * sizeof(float)); @@ -2901,8 +2986,9 @@ PyDoc_STRVAR(Vector_negate_doc, ); static PyObject *Vector_negate(VectorObject *self) { - if (BaseMath_ReadCallback(self) == -1) + if (BaseMath_ReadCallback(self) == -1) { return NULL; + } negate_vn(self->vec, self->size); diff --git a/source/blender/python/mathutils/mathutils_bvhtree.c b/source/blender/python/mathutils/mathutils_bvhtree.c index 4ed4b0e3abb..b99b39ac998 100644 --- a/source/blender/python/mathutils/mathutils_bvhtree.c +++ b/source/blender/python/mathutils/mathutils_bvhtree.c @@ -924,10 +924,12 @@ static PyObject *C_BVHTree_FromPolygons(PyObject *UNUSED(cls), PyObject *args, P orig_index, orig_normal); } else { - if (coords) + if (coords) { MEM_freeN(coords); - if (tris) + } + if (tris) { MEM_freeN(tris); + } return NULL; } diff --git a/source/blender/python/mathutils/mathutils_geometry.c b/source/blender/python/mathutils/mathutils_geometry.c index 6106b01fd41..05ec57a004a 100644 --- a/source/blender/python/mathutils/mathutils_geometry.c +++ b/source/blender/python/mathutils/mathutils_geometry.c @@ -621,12 +621,12 @@ static PyObject *M_Geometry_intersect_line_sphere(PyObject *UNUSED(self), PyObje switch (isect_line_sphere_v3(line_a, line_b, sphere_co, sphere_radius, isect_a, isect_b)) { case 1: - if (!(!clip || (((lambda = line_point_factor_v3(isect_a, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) use_a = false; + if (!(!clip || (((lambda = line_point_factor_v3(isect_a, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) { use_a = false; } use_b = false; break; case 2: - if (!(!clip || (((lambda = line_point_factor_v3(isect_a, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) use_a = false; - if (!(!clip || (((lambda = line_point_factor_v3(isect_b, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) use_b = false; + if (!(!clip || (((lambda = line_point_factor_v3(isect_a, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) { use_a = false; } + if (!(!clip || (((lambda = line_point_factor_v3(isect_b, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) { use_b = false; } break; default: use_a = false; @@ -694,12 +694,12 @@ static PyObject *M_Geometry_intersect_line_sphere_2d(PyObject *UNUSED(self), PyO switch (isect_line_sphere_v2(line_a, line_b, sphere_co, sphere_radius, isect_a, isect_b)) { case 1: - if (!(!clip || (((lambda = line_point_factor_v2(isect_a, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) use_a = false; + if (!(!clip || (((lambda = line_point_factor_v2(isect_a, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) { use_a = false; } use_b = false; break; case 2: - if (!(!clip || (((lambda = line_point_factor_v2(isect_a, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) use_a = false; - if (!(!clip || (((lambda = line_point_factor_v2(isect_b, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) use_b = false; + if (!(!clip || (((lambda = line_point_factor_v2(isect_a, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) { use_a = false; } + if (!(!clip || (((lambda = line_point_factor_v2(isect_b, line_a, line_b)) >= 0.0f) && (lambda <= 1.0f)))) { use_b = false; } break; default: use_a = false; @@ -1225,15 +1225,19 @@ static PyObject *M_Geometry_tessellate_polygon(PyObject *UNUSED(self), PyObject polyVec = PySequence_GetItem(polyLine, index); if (VectorObject_Check(polyVec)) { - if (BaseMath_ReadCallback((VectorObject *)polyVec) == -1) + if (BaseMath_ReadCallback((VectorObject *)polyVec) == -1) { ls_error = 1; + } fp[0] = ((VectorObject *)polyVec)->vec[0]; fp[1] = ((VectorObject *)polyVec)->vec[1]; - if (((VectorObject *)polyVec)->size > 2) + if (((VectorObject *)polyVec)->size > 2) { fp[2] = ((VectorObject *)polyVec)->vec[2]; - else - fp[2] = 0.0f; /* if its a 2d vector then set the z to be zero */ + } + else { + /* if its a 2d vector then set the z to be zero */ + fp[2] = 0.0f; + } } else { ls_error = 1; diff --git a/source/blender/python/mathutils/mathutils_interpolate.c b/source/blender/python/mathutils/mathutils_interpolate.c index da2ed0ced7e..792f8b1f065 100644 --- a/source/blender/python/mathutils/mathutils_interpolate.c +++ b/source/blender/python/mathutils/mathutils_interpolate.c @@ -66,15 +66,19 @@ static PyObject *M_Interpolate_poly_3d_calc(PyObject *UNUSED(self), PyObject *ar return NULL; } - if (BaseMath_ReadCallback((VectorObject *)point) == -1) + if (BaseMath_ReadCallback((VectorObject *)point) == -1) { return NULL; + } fp[0] = ((VectorObject *)point)->vec[0]; fp[1] = ((VectorObject *)point)->vec[1]; - if (((VectorObject *)point)->size > 2) + if (((VectorObject *)point)->size > 2) { fp[2] = ((VectorObject *)point)->vec[2]; - else - fp[2] = 0.0f; /* if its a 2d vector then set the z to be zero */ + } + else { + /* if its a 2d vector then set the z to be zero */ + fp[2] = 0.0f; + } len = mathutils_array_parse_alloc_v(((float **)&vecs), 3, veclist, __func__); if (len == -1) { diff --git a/source/blender/python/mathutils/mathutils_kdtree.c b/source/blender/python/mathutils/mathutils_kdtree.c index f9cc99551bb..7228ac41bd6 100644 --- a/source/blender/python/mathutils/mathutils_kdtree.c +++ b/source/blender/python/mathutils/mathutils_kdtree.c @@ -148,8 +148,9 @@ static PyObject *py_kdtree_insert(PyKDTree *self, PyObject *args, PyObject *kwar return NULL; } - if (mathutils_array_parse(co, 3, 3, py_co, "insert: invalid 'co' arg") == -1) + if (mathutils_array_parse(co, 3, 3, py_co, "insert: invalid 'co' arg") == -1) { return NULL; + } if (index < 0) { PyErr_SetString(PyExc_ValueError, "negative index given"); @@ -238,8 +239,9 @@ static PyObject *py_kdtree_find(PyKDTree *self, PyObject *args, PyObject *kwargs return NULL; } - if (mathutils_array_parse(co, 3, 3, py_co, "find: invalid 'co' arg") == -1) + if (mathutils_array_parse(co, 3, 3, py_co, "find: invalid 'co' arg") == -1) { return NULL; + } if (self->count != self->count_balance) { PyErr_SetString(PyExc_RuntimeError, "KDTree must be balanced before calling find()"); @@ -299,8 +301,9 @@ static PyObject *py_kdtree_find_n(PyKDTree *self, PyObject *args, PyObject *kwar return NULL; } - if (mathutils_array_parse(co, 3, 3, py_co, "find_n: invalid 'co' arg") == -1) + if (mathutils_array_parse(co, 3, 3, py_co, "find_n: invalid 'co' arg") == -1) { return NULL; + } if (UINT_IS_NEG(n)) { PyErr_SetString(PyExc_RuntimeError, "negative 'n' given"); @@ -357,8 +360,9 @@ static PyObject *py_kdtree_find_range(PyKDTree *self, PyObject *args, PyObject * return NULL; } - if (mathutils_array_parse(co, 3, 3, py_co, "find_range: invalid 'co' arg") == -1) + if (mathutils_array_parse(co, 3, 3, py_co, "find_range: invalid 'co' arg") == -1) { return NULL; + } if (radius < 0.0f) { PyErr_SetString(PyExc_RuntimeError, "negative radius given"); diff --git a/source/blender/python/mathutils/mathutils_noise.c b/source/blender/python/mathutils/mathutils_noise.c index 364690c43eb..04cadb9b592 100644 --- a/source/blender/python/mathutils/mathutils_noise.c +++ b/source/blender/python/mathutils/mathutils_noise.c @@ -136,17 +136,20 @@ static void next_state(void) /* if init_genrand() has not been called, */ /* a default initial seed is used */ - if (initf == 0) + if (initf == 0) { init_genrand(5489UL); + } left = N; next = state; - for (j = N - M + 1; --j; p++) + for (j = N - M + 1; --j; p++) { *p = p[M] ^ TWIST(p[0], p[1]); + } - for (j = M; --j; p++) + for (j = M; --j; p++) { *p = p[M - N] ^ TWIST(p[0], p[1]); + } *p = p[M - N] ^ TWIST(p[0], state[0]); } @@ -155,10 +158,12 @@ static void next_state(void) static void setRndSeed(int seed) { - if (seed == 0) + if (seed == 0) { init_genrand(time(NULL)); - else + } + else { init_genrand(seed); + } } /* float number in range [0, 1) using the mersenne twister rng */ @@ -166,8 +171,9 @@ static float frand(void) { unsigned long y; - if (--left == 0) + if (--left == 0) { next_state(); + } y = *next++; /* Tempering */ @@ -253,16 +259,18 @@ static float turb( int i; amp = 1.f; out = (float)(2.0f * BLI_gNoise(1.f, x, y, z, 0, nb) - 1.0f); - if (hard) + if (hard) { out = fabsf(out); + } for (i = 1; i < oct; i++) { amp *= ampscale; x *= freqscale; y *= freqscale; z *= freqscale; t = (float)(amp * (2.0f * BLI_gNoise(1.f, x, y, z, 0, nb) - 1.0f)); - if (hard) + if (hard) { t = fabsf(t); + } out += t; } return out; @@ -406,8 +414,9 @@ PyDoc_STRVAR(M_Noise_seed_set_doc, static PyObject *M_Noise_seed_set(PyObject *UNUSED(self), PyObject *args) { int s; - if (!PyArg_ParseTuple(args, "i:seed_set", &s)) + if (!PyArg_ParseTuple(args, "i:seed_set", &s)) { return NULL; + } setRndSeed(s); Py_RETURN_NONE; } @@ -447,8 +456,9 @@ static PyObject *M_Noise_noise(PyObject *UNUSED(self), PyObject *args, PyObject return NULL; } - if (mathutils_array_parse(vec, 3, 3, value, "noise: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "noise: invalid 'position' arg") == -1) { return NULL; + } return PyFloat_FromDouble((2.0f * BLI_gNoise(1.0f, vec[0], vec[1], vec[2], 0, noise_basis_enum) - 1.0f)); } @@ -488,8 +498,9 @@ static PyObject *M_Noise_noise_vector(PyObject *UNUSED(self), PyObject *args, Py return NULL; } - if (mathutils_array_parse(vec, 3, 3, value, "noise_vector: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "noise_vector: invalid 'position' arg") == -1) { return NULL; + } noise_vector(vec[0], vec[1], vec[2], noise_basis_enum, r_vec); @@ -540,8 +551,9 @@ static PyObject *M_Noise_turbulence(PyObject *UNUSED(self), PyObject *args, PyOb return NULL; } - if (mathutils_array_parse(vec, 3, 3, value, "turbulence: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "turbulence: invalid 'position' arg") == -1) { return NULL; + } return PyFloat_FromDouble(turb(vec[0], vec[1], vec[2], oct, hd, noise_basis_enum, as, fs)); } @@ -590,8 +602,9 @@ static PyObject *M_Noise_turbulence_vector(PyObject *UNUSED(self), PyObject *arg return NULL; } - if (mathutils_array_parse(vec, 3, 3, value, "turbulence_vector: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "turbulence_vector: invalid 'position' arg") == -1) { return NULL; + } vTurb(vec[0], vec[1], vec[2], oct, hd, noise_basis_enum, as, fs, r_vec); @@ -641,8 +654,9 @@ static PyObject *M_Noise_fractal(PyObject *UNUSED(self), PyObject *args, PyObjec return NULL; } - if (mathutils_array_parse(vec, 3, 3, value, "fractal: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "fractal: invalid 'position' arg") == -1) { return NULL; + } return PyFloat_FromDouble(mg_fBm(vec[0], vec[1], vec[2], H, lac, oct, noise_basis_enum)); } @@ -689,8 +703,9 @@ static PyObject *M_Noise_multi_fractal(PyObject *UNUSED(self), PyObject *args, P return NULL; } - if (mathutils_array_parse(vec, 3, 3, value, "multi_fractal: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "multi_fractal: invalid 'position' arg") == -1) { return NULL; + } return PyFloat_FromDouble(mg_MultiFractal(vec[0], vec[1], vec[2], H, lac, oct, noise_basis_enum)); } @@ -749,8 +764,9 @@ static PyObject *M_Noise_variable_lacunarity(PyObject *UNUSED(self), PyObject *a return NULL; } - if (mathutils_array_parse(vec, 3, 3, value, "variable_lacunarity: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "variable_lacunarity: invalid 'position' arg") == -1) { return NULL; + } return PyFloat_FromDouble(mg_VLNoise(vec[0], vec[1], vec[2], d, noise_type1_enum, noise_type2_enum)); } @@ -799,8 +815,9 @@ static PyObject *M_Noise_hetero_terrain(PyObject *UNUSED(self), PyObject *args, return NULL; } - if (mathutils_array_parse(vec, 3, 3, value, "hetero_terrain: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "hetero_terrain: invalid 'position' arg") == -1) { return NULL; + } return PyFloat_FromDouble(mg_HeteroTerrain(vec[0], vec[1], vec[2], H, lac, oct, ofs, noise_basis_enum)); } @@ -851,8 +868,9 @@ static PyObject *M_Noise_hybrid_multi_fractal(PyObject *UNUSED(self), PyObject * return NULL; } - if (mathutils_array_parse(vec, 3, 3, value, "hybrid_multi_fractal: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "hybrid_multi_fractal: invalid 'position' arg") == -1) { return NULL; + } return PyFloat_FromDouble(mg_HybridMultiFractal(vec[0], vec[1], vec[2], H, lac, oct, ofs, gn, noise_basis_enum)); } @@ -903,8 +921,9 @@ static PyObject *M_Noise_ridged_multi_fractal(PyObject *UNUSED(self), PyObject * return NULL; } - if (mathutils_array_parse(vec, 3, 3, value, "ridged_multi_fractal: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "ridged_multi_fractal: invalid 'position' arg") == -1) { return NULL; + } return PyFloat_FromDouble(mg_RidgedMultiFractal(vec[0], vec[1], vec[2], H, lac, oct, ofs, gn, noise_basis_enum)); } @@ -952,8 +971,9 @@ static PyObject *M_Noise_voronoi(PyObject *UNUSED(self), PyObject *args, PyObjec return NULL; } - if (mathutils_array_parse(vec, 3, 3, value, "voronoi: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "voronoi: invalid 'position' arg") == -1) { return NULL; + } list = PyList_New(4); @@ -984,11 +1004,13 @@ static PyObject *M_Noise_cell(PyObject *UNUSED(self), PyObject *args) PyObject *value; float vec[3]; - if (!PyArg_ParseTuple(args, "O:cell", &value)) + if (!PyArg_ParseTuple(args, "O:cell", &value)) { return NULL; + } - if (mathutils_array_parse(vec, 3, 3, value, "cell: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "cell: invalid 'position' arg") == -1) { return NULL; + } return PyFloat_FromDouble(cellNoise(vec[0], vec[1], vec[2])); } @@ -1008,11 +1030,13 @@ static PyObject *M_Noise_cell_vector(PyObject *UNUSED(self), PyObject *args) PyObject *value; float vec[3], r_vec[3]; - if (!PyArg_ParseTuple(args, "O:cell_vector", &value)) + if (!PyArg_ParseTuple(args, "O:cell_vector", &value)) { return NULL; + } - if (mathutils_array_parse(vec, 3, 3, value, "cell_vector: invalid 'position' arg") == -1) + if (mathutils_array_parse(vec, 3, 3, value, "cell_vector: invalid 'position' arg") == -1) { return NULL; + } cellNoiseV(vec[0], vec[1], vec[2], r_vec); return Vector_CreatePyObject(r_vec, 3, NULL); -- cgit v1.2.3