From 4da4943b5ce9514e9fb3d9458f3e52d6b0d310ca Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Thu, 14 Jul 2011 01:25:05 +0000 Subject: [PATCH] formatting changes for python mathutils module. --- source/blender/python/generic/mathutils.c | 65 +++-- .../blender/python/generic/mathutils_Color.c | 83 ++++-- .../blender/python/generic/mathutils_Euler.c | 48 +++- .../blender/python/generic/mathutils_Matrix.c | 253 +++++++++++++----- .../python/generic/mathutils_Quaternion.c | 61 +++-- .../blender/python/generic/mathutils_Vector.c | 227 +++++++++++----- .../python/generic/mathutils_geometry.c | 70 +++-- 7 files changed, 587 insertions(+), 220 deletions(-) diff --git a/source/blender/python/generic/mathutils.c b/source/blender/python/generic/mathutils.c index 30f4e5b7ffe..bba08e312b7 100644 --- a/source/blender/python/generic/mathutils.c +++ b/source/blender/python/generic/mathutils.c @@ -57,8 +57,16 @@ static int mathutils_array_parse_fast(float *array, int array_min, int array_max size= PySequence_Fast_GET_SIZE(value_fast); if(size > array_max || size < array_min) { - if (array_max == array_min) PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max); - else PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max); + if (array_max == array_min) { + PyErr_Format(PyExc_ValueError, + "%.200s: sequence size is %d, expected %d", + error_prefix, size, array_max); + } + else { + PyErr_Format(PyExc_ValueError, + "%.200s: sequence size is %d, expected [%d - %d]", + error_prefix, size, array_min, array_max); + } Py_DECREF(value_fast); return -1; } @@ -67,7 +75,10 @@ static int mathutils_array_parse_fast(float *array, int array_min, int array_max do { i--; if(((array[i]= PyFloat_AsDouble((item= PySequence_Fast_GET_ITEM(value_fast, i)))) == -1.0f) && PyErr_Occurred()) { - PyErr_Format(PyExc_ValueError, "%.200s: sequence index %d expected a number, found '%.200s' type, ", error_prefix, i, Py_TYPE(item)->tp_name); + PyErr_Format(PyExc_ValueError, + "%.200s: sequence index %d expected a number, " + "found '%.200s' type, ", + error_prefix, i, Py_TYPE(item)->tp_name); Py_DECREF(value_fast); return -1; } @@ -93,8 +104,16 @@ int mathutils_array_parse(float *array, int array_min, int array_max, PyObject * } if(size > array_max || size < array_min) { - if (array_max == array_min) PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max); - else PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max); + if (array_max == array_min) { + PyErr_Format(PyExc_ValueError, + "%.200s: sequence size is %d, expected %d", + error_prefix, size, array_max); + } + else { + PyErr_Format(PyExc_ValueError, + "%.200s: sequence size is %d, expected [%d - %d]", + error_prefix, size, array_min, array_max); + } return -1; } @@ -135,7 +154,9 @@ int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error return -1; } else if(((MatrixObject *)value)->col_size < 3 || ((MatrixObject *)value)->row_size < 3) { - PyErr_Format(PyExc_ValueError, "%.200s: matrix must have minimum 3x3 dimensions", error_prefix); + PyErr_Format(PyExc_ValueError, + "%.200s: matrix must have minimum 3x3 dimensions", + error_prefix); return -1; } else { @@ -145,7 +166,9 @@ int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error } } else { - PyErr_Format(PyExc_TypeError, "%.200s: expected a Euler, Quaternion or Matrix type, found %.200s", error_prefix, Py_TYPE(value)->tp_name); + PyErr_Format(PyExc_TypeError, + "%.200s: expected a Euler, Quaternion or Matrix type, " + "found %.200s", error_prefix, Py_TYPE(value)->tp_name); return -1; } } @@ -213,8 +236,11 @@ int _BaseMathObject_ReadCallback(BaseMathObject *self) if(cb->get(self, self->cb_subtype) != -1) return 0; - if(!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "%s read, user has become invalid", Py_TYPE(self)->tp_name); + if(!PyErr_Occurred()) { + PyErr_Format(PyExc_RuntimeError, + "%s read, user has become invalid", + Py_TYPE(self)->tp_name); + } return -1; } @@ -224,8 +250,11 @@ int _BaseMathObject_WriteCallback(BaseMathObject *self) if(cb->set(self, self->cb_subtype) != -1) return 0; - if(!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "%s write, user has become invalid", Py_TYPE(self)->tp_name); + if(!PyErr_Occurred()) { + PyErr_Format(PyExc_RuntimeError, + "%s write, user has become invalid", + Py_TYPE(self)->tp_name); + } return -1; } @@ -235,8 +264,11 @@ int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index) if(cb->get_index(self, self->cb_subtype, index) != -1) return 0; - if(!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "%s read index, user has become invalid", Py_TYPE(self)->tp_name); + if(!PyErr_Occurred()) { + PyErr_Format(PyExc_RuntimeError, + "%s read index, user has become invalid", + Py_TYPE(self)->tp_name); + } return -1; } @@ -246,8 +278,11 @@ int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index) if(cb->set_index(self, self->cb_subtype, index) != -1) return 0; - if(!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "%s write index, user has become invalid", Py_TYPE(self)->tp_name); + if(!PyErr_Occurred()) { + PyErr_Format(PyExc_RuntimeError, + "%s write index, user has become invalid", + Py_TYPE(self)->tp_name); + } return -1; } diff --git a/source/blender/python/generic/mathutils_Color.c b/source/blender/python/generic/mathutils_Color.c index c59cb501d86..fd187fd92fd 100644 --- a/source/blender/python/generic/mathutils_Color.c +++ b/source/blender/python/generic/mathutils_Color.c @@ -43,7 +43,9 @@ static PyObject *Color_new(PyTypeObject *type, PyObject *args, PyObject *kwds) float col[3]= {0.0f, 0.0f, 0.0f}; if(kwds && PyDict_Size(kwds)) { - PyErr_SetString(PyExc_TypeError, "mathutils.Color(): takes no keyword args"); + PyErr_SetString(PyExc_TypeError, + "mathutils.Color(): " + "takes no keyword args"); return NULL; } @@ -55,7 +57,9 @@ static PyObject *Color_new(PyTypeObject *type, PyObject *args, PyObject *kwds) return NULL; break; default: - PyErr_SetString(PyExc_TypeError, "mathutils.Color(): more then a single arg given"); + PyErr_SetString(PyExc_TypeError, + "mathutils.Color(): " + "more then a single arg given"); return NULL; } return newColorObject(col, Py_NEW, type); @@ -174,7 +178,9 @@ static PyObject *Color_item(ColorObject * self, int i) if(i<0) i= COLOR_SIZE-i; if(i < 0 || i >= COLOR_SIZE) { - PyErr_SetString(PyExc_IndexError, "color[attribute]: array index out of range"); + PyErr_SetString(PyExc_IndexError, + "color[attribute]: " + "array index out of range"); return NULL; } @@ -191,14 +197,17 @@ static int Color_ass_item(ColorObject * self, int i, PyObject *value) float f = PyFloat_AsDouble(value); if(f == -1 && PyErr_Occurred()) { // parsed item not a number - PyErr_SetString(PyExc_TypeError, "color[attribute] = x: argument not a number"); + PyErr_SetString(PyExc_TypeError, + "color[attribute] = x: " + "argument not a number"); return -1; } if(i<0) i= COLOR_SIZE-i; if(i < 0 || i >= COLOR_SIZE){ - PyErr_SetString(PyExc_IndexError, "color[attribute] = x: array assignment index out of range"); + PyErr_SetString(PyExc_IndexError, "color[attribute] = x: " + "array assignment index out of range"); return -1; } @@ -250,7 +259,9 @@ static int Color_ass_slice(ColorObject *self, int begin, int end, PyObject *seq) return -1; if(size != (end - begin)){ - PyErr_SetString(PyExc_TypeError, "color[begin:end] = []: size mismatch in slice assignment"); + PyErr_SetString(PyExc_TypeError, + "color[begin:end] = []: " + "size mismatch in slice assignment"); return -1; } @@ -285,12 +296,15 @@ static PyObject *Color_subscript(ColorObject *self, PyObject *item) return Color_slice(self, start, stop); } else { - PyErr_SetString(PyExc_TypeError, "slice steps not supported with color"); + PyErr_SetString(PyExc_TypeError, + "slice steps not supported with color"); return NULL; } } else { - PyErr_Format(PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name); + PyErr_Format(PyExc_TypeError, + "color indices must be integers, not %.200s", + Py_TYPE(item)->tp_name); return NULL; } } @@ -314,12 +328,15 @@ static int Color_ass_subscript(ColorObject *self, PyObject *item, PyObject *valu if (step == 1) return Color_ass_slice(self, start, stop, value); else { - PyErr_SetString(PyExc_TypeError, "slice steps not supported with color"); + PyErr_SetString(PyExc_TypeError, + "slice steps not supported with color"); return -1; } } else { - PyErr_Format(PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name); + PyErr_Format(PyExc_TypeError, + "color indices must be integers, not %.200s", + Py_TYPE(item)->tp_name); return -1; } } @@ -354,7 +371,9 @@ static PyObject *Color_add(PyObject *v1, PyObject *v2) float col[COLOR_SIZE]; if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) { - PyErr_SetString(PyExc_AttributeError, "Color addition: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Color addition: " + "arguments not valid for this operation"); return NULL; } color1 = (ColorObject*)v1; @@ -374,7 +393,9 @@ static PyObject *Color_iadd(PyObject *v1, PyObject *v2) ColorObject *color1 = NULL, *color2 = NULL; if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) { - PyErr_SetString(PyExc_AttributeError, "Color addition: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Color addition: " + "arguments not valid for this operation"); return NULL; } color1 = (ColorObject*)v1; @@ -397,7 +418,9 @@ static PyObject *Color_sub(PyObject *v1, PyObject *v2) float col[COLOR_SIZE]; if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) { - PyErr_SetString(PyExc_AttributeError, "Color subtraction: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Color subtraction: " + "arguments not valid for this operation"); return NULL; } color1 = (ColorObject*)v1; @@ -417,7 +440,9 @@ static PyObject *Color_isub(PyObject *v1, PyObject *v2) ColorObject *color1= NULL, *color2= NULL; if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) { - PyErr_SetString(PyExc_AttributeError, "Color subtraction: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Color subtraction: " + "arguments not valid for this operation"); return NULL; } color1 = (ColorObject*)v1; @@ -476,7 +501,10 @@ static PyObject *Color_mul(PyObject *v1, PyObject *v2) BLI_assert(!"internal error"); } - PyErr_Format(PyExc_TypeError, "Color multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name); + PyErr_Format(PyExc_TypeError, + "Color multiplication: not supported between " + "'%.200s' and '%.200s' types", + Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name); return NULL; } @@ -491,20 +519,25 @@ static PyObject *Color_div(PyObject *v1, PyObject *v2) return NULL; } else { - PyErr_SetString(PyExc_TypeError, "Color division not supported in this order"); + PyErr_SetString(PyExc_TypeError, + "Color division not supported in this order"); return NULL; } /* make sure v1 is always the vector */ if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* COLOR * FLOAT */ if(scalar==0.0f) { - PyErr_SetString(PyExc_ZeroDivisionError, "Color division: divide by zero error"); + PyErr_SetString(PyExc_ZeroDivisionError, + "Color division: divide by zero error"); return NULL; } return color_mul_float(color1, 1.0f / scalar); } - PyErr_Format(PyExc_TypeError, "Color multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name); + PyErr_Format(PyExc_TypeError, + "Color multiplication: not supported between " + "'%.200s' and '%.200s' types", + Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name); return NULL; } @@ -543,14 +576,17 @@ static PyObject *Color_idiv(PyObject *v1, PyObject *v2) /* only support color /= float */ if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* COLOR /= FLOAT */ if(scalar==0.0f) { - PyErr_SetString(PyExc_ZeroDivisionError, "Color division: divide by zero error"); + PyErr_SetString(PyExc_ZeroDivisionError, + "Color division: divide by zero error"); return NULL; } mul_vn_fl(color->col, COLOR_SIZE, 1.0f / scalar); } else { - PyErr_SetString(PyExc_TypeError, "Color multiplication: arguments not acceptable for this operation"); + PyErr_SetString(PyExc_TypeError, + "Color multiplication: " + "arguments not acceptable for this operation"); return NULL; } @@ -642,7 +678,9 @@ static int Color_setChannelHSV(ColorObject * self, PyObject *value, void * type) float f = PyFloat_AsDouble(value); if(f == -1 && PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, "color.h/s/v = value: argument not a number"); + PyErr_SetString(PyExc_TypeError, + "color.h/s/v = value: " + "argument not a number"); return -1; } @@ -808,7 +846,8 @@ PyObject *newColorObject(float *col, int type, PyTypeObject *base_type) self->wrapped = Py_NEW; } else { - PyErr_SetString(PyExc_RuntimeError, "Color(): invalid type"); + PyErr_SetString(PyExc_RuntimeError, + "Color(): invalid type, internal error"); return NULL; } } diff --git a/source/blender/python/generic/mathutils_Euler.c b/source/blender/python/generic/mathutils_Euler.c index 4281c7bf6c5..2888b0667f1 100644 --- a/source/blender/python/generic/mathutils_Euler.c +++ b/source/blender/python/generic/mathutils_Euler.c @@ -55,7 +55,9 @@ static PyObject *Euler_new(PyTypeObject *type, PyObject *args, PyObject *kwds) short order= EULER_ORDER_XYZ; if(kwds && PyDict_Size(kwds)) { - PyErr_SetString(PyExc_TypeError, "mathutils.Euler(): takes no keyword args"); + PyErr_SetString(PyExc_TypeError, + "mathutils.Euler(): " + "takes no keyword args"); return NULL; } @@ -97,7 +99,9 @@ short euler_order_from_string(const char *str, const char *error_prefix) } } - PyErr_Format(PyExc_TypeError, "%s: invalid euler order '%s'", error_prefix, str); + PyErr_Format(PyExc_TypeError, + "%s: invalid euler order '%s'", + error_prefix, str); return -1; } @@ -199,11 +203,14 @@ static PyObject *Euler_rotate_axis(EulerObject * self, PyObject *args) const char *axis; if(!PyArg_ParseTuple(args, "sf:rotate", &axis, &angle)){ - PyErr_SetString(PyExc_TypeError, "euler.rotate(): expected angle (float) and axis (x, y, z)"); + PyErr_SetString(PyExc_TypeError, + "euler.rotate(): " + "expected angle (float) and axis (x, y, z)"); return NULL; } if(!(ELEM3(*axis, 'X', 'Y', 'Z') && axis[1]=='\0')){ - PyErr_SetString(PyExc_TypeError, "euler.rotate(): expected axis to be 'X', 'Y' or 'Z'"); + PyErr_SetString(PyExc_TypeError, "euler.rotate(): " + "expected axis to be 'X', 'Y' or 'Z'"); return NULL; } @@ -360,7 +367,9 @@ static PyObject *Euler_item(EulerObject * self, int i) if(i<0) i= EULER_SIZE-i; if(i < 0 || i >= EULER_SIZE) { - PyErr_SetString(PyExc_IndexError, "euler[attribute]: array index out of range"); + PyErr_SetString(PyExc_IndexError, + "euler[attribute]: " + "array index out of range"); return NULL; } @@ -377,14 +386,18 @@ static int Euler_ass_item(EulerObject * self, int i, PyObject *value) float f = PyFloat_AsDouble(value); if(f == -1 && PyErr_Occurred()) { // parsed item not a number - PyErr_SetString(PyExc_TypeError, "euler[attribute] = x: argument not a number"); + PyErr_SetString(PyExc_TypeError, + "euler[attribute] = x: " + "argument not a number"); return -1; } if(i<0) i= EULER_SIZE-i; if(i < 0 || i >= EULER_SIZE){ - PyErr_SetString(PyExc_IndexError, "euler[attribute] = x: array assignment index out of range"); + PyErr_SetString(PyExc_IndexError, + "euler[attribute] = x: " + "array assignment index out of range"); return -1; } @@ -436,7 +449,9 @@ static int Euler_ass_slice(EulerObject *self, int begin, int end, PyObject *seq) return -1; if(size != (end - begin)){ - PyErr_SetString(PyExc_TypeError, "euler[begin:end] = []: size mismatch in slice assignment"); + PyErr_SetString(PyExc_TypeError, + "euler[begin:end] = []: " + "size mismatch in slice assignment"); return -1; } @@ -471,12 +486,15 @@ static PyObject *Euler_subscript(EulerObject *self, PyObject *item) return Euler_slice(self, start, stop); } else { - PyErr_SetString(PyExc_TypeError, "slice steps not supported with eulers"); + PyErr_SetString(PyExc_TypeError, + "slice steps not supported with eulers"); return NULL; } } else { - PyErr_Format(PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name); + PyErr_Format(PyExc_TypeError, + "euler indices must be integers, not %.200s", + Py_TYPE(item)->tp_name); return NULL; } } @@ -501,12 +519,15 @@ static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *valu if (step == 1) return Euler_ass_slice(self, start, stop, value); else { - PyErr_SetString(PyExc_TypeError, "slice steps not supported with euler"); + PyErr_SetString(PyExc_TypeError, + "slice steps not supported with euler"); return -1; } } else { - PyErr_Format(PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name); + PyErr_Format(PyExc_TypeError, + "euler indices must be integers, not %.200s", + Py_TYPE(item)->tp_name); return -1; } } @@ -680,7 +701,8 @@ PyObject *newEulerObject(float *eul, short order, int type, PyTypeObject *base_t self->wrapped = Py_NEW; } else { - PyErr_SetString(PyExc_RuntimeError, "Euler(): invalid type"); + PyErr_SetString(PyExc_RuntimeError, + "Euler(): invalid type, internal error"); return NULL; } diff --git a/source/blender/python/generic/mathutils_Matrix.c b/source/blender/python/generic/mathutils_Matrix.c index bed7dd12f08..4343485bb3a 100644 --- a/source/blender/python/generic/mathutils_Matrix.c +++ b/source/blender/python/generic/mathutils_Matrix.c @@ -119,7 +119,9 @@ Mathutils_Callback mathutils_matrix_vector_cb = { static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { if(kwds && PyDict_Size(kwds)) { - PyErr_SetString(PyExc_TypeError, "mathutils.Matrix(): takes no keyword args"); + PyErr_SetString(PyExc_TypeError, + "mathutils.Matrix(): " + "takes no keyword args"); return NULL; } @@ -130,7 +132,8 @@ static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyObject *arg= PyTuple_GET_ITEM(args, 0); - const unsigned short row_size= PySequence_Size(arg); /* -1 is an error, size checks will accunt for this */ + /* -1 is an error, size checks will accunt for this */ + const unsigned short row_size= PySequence_Size(arg); if(row_size >= 2 && row_size <= 4) { PyObject *item= PySequence_GetItem(arg, 0); @@ -152,7 +155,9 @@ static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds) } /* will overwrite error */ - PyErr_SetString(PyExc_TypeError, "mathutils.Matrix(): expects no args or 2-4 numeric sequences"); + PyErr_SetString(PyExc_TypeError, + "mathutils.Matrix(): " + "expects no args or 2-4 numeric sequences"); return NULL; } @@ -211,14 +216,19 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args) 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; if(!PyArg_ParseTuple(args, "di|O", &angle, &matSize, &vec)) { - PyErr_SetString(PyExc_TypeError, "mathutils.RotationMatrix(angle, size, axis): expected float int and a string or vector"); + PyErr_SetString(PyExc_TypeError, + "mathutils.RotationMatrix(angle, size, axis): " + "expected float int and a string or vector"); return NULL; } if(vec && PyUnicode_Check(vec)) { axis= _PyUnicode_AsString((PyObject *)vec); if(axis==NULL || axis[0]=='\0' || axis[1]!='\0' || axis[0] < 'X' || axis[0] > 'Z') { - PyErr_SetString(PyExc_TypeError, "mathutils.RotationMatrix(): 3rd argument axis value must be a 3D vector or a string in 'X', 'Y', 'Z'"); + PyErr_SetString(PyExc_TypeError, + "mathutils.RotationMatrix(): " + "3rd argument axis value must be a 3D vector " + "or a string in 'X', 'Y', 'Z'"); return NULL; } else { @@ -230,15 +240,21 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args) angle= angle_wrap_rad(angle); if(matSize != 2 && matSize != 3 && matSize != 4) { - PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): can only return a 2x2 3x3 or 4x4 matrix"); + PyErr_SetString(PyExc_AttributeError, + "mathutils.RotationMatrix(): " + "can only return a 2x2 3x3 or 4x4 matrix"); return NULL; } if(matSize == 2 && (vec != NULL)) { - PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): cannot create a 2x2 rotation matrix around arbitrary axis"); + PyErr_SetString(PyExc_AttributeError, + "mathutils.RotationMatrix(): " + "cannot create a 2x2 rotation matrix around arbitrary axis"); return NULL; } if((matSize == 3 || matSize == 4) && (axis == NULL) && (vec == NULL)) { - PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): axis of rotation for 3d and 4d matrices is required"); + PyErr_SetString(PyExc_AttributeError, + "mathutils.RotationMatrix(): " + "axis of rotation for 3d and 4d matrices is required"); return NULL; } @@ -284,7 +300,8 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args) } else { /* should never get here */ - PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): unknown error"); + PyErr_SetString(PyExc_AttributeError, + "mathutils.RotationMatrix(): unknown error"); return NULL; } @@ -348,7 +365,9 @@ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args) return NULL; } if(matSize != 2 && matSize != 3 && matSize != 4) { - PyErr_SetString(PyExc_AttributeError, "Matrix.Scale(): can only return a 2x2 3x3 or 4x4 matrix"); + PyErr_SetString(PyExc_AttributeError, + "Matrix.Scale(): " + "can only return a 2x2 3x3 or 4x4 matrix"); return NULL; } if(vec) { @@ -361,7 +380,8 @@ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args) if(matSize == 2) { mat[0] = factor; mat[3] = factor; - } else { + } + else { mat[0] = factor; mat[4] = factor; mat[8] = factor; @@ -383,7 +403,8 @@ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args) mat[1] = ((factor - 1) *(tvec[0] * tvec[1])); mat[2] = ((factor - 1) *(tvec[0] * tvec[1])); mat[3] = 1 + ((factor - 1) *(tvec[1] * tvec[1])); - } else { + } + else { mat[0] = 1 + ((factor - 1) *(tvec[0] * tvec[0])); mat[1] = ((factor - 1) *(tvec[0] * tvec[1])); mat[2] = ((factor - 1) *(tvec[0] * tvec[2])); @@ -430,7 +451,9 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args) return NULL; } if(matSize != 2 && matSize != 3 && matSize != 4) { - PyErr_SetString(PyExc_AttributeError,"mathutils.Matrix.OrthoProjection(): can only return a 2x2 3x3 or 4x4 matrix"); + PyErr_SetString(PyExc_AttributeError, + "mathutils.Matrix.OrthoProjection(): " + "can only return a 2x2 3x3 or 4x4 matrix"); return NULL; } @@ -445,7 +468,10 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args) mat[3]= 1.0f; } else { - PyErr_Format(PyExc_ValueError, "mathutils.Matrix.OrthoProjection(): unknown plane, expected: X, Y, not '%.200s'", plane); + PyErr_Format(PyExc_ValueError, + "mathutils.Matrix.OrthoProjection(): " + "unknown plane, expected: X, Y, not '%.200s'", + plane); return NULL; } } @@ -463,7 +489,10 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args) mat[8]= 1.0f; } else { - PyErr_Format(PyExc_ValueError, "mathutils.Matrix.OrthoProjection(): unknown plane, expected: XY, XZ, YZ, not '%.200s'", plane); + PyErr_Format(PyExc_ValueError, + "mathutils.Matrix.OrthoProjection(): " + "unknown plane, expected: XY, XZ, YZ, not '%.200s'", + plane); return NULL; } } @@ -539,7 +568,9 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args) return NULL; } if(matSize != 2 && matSize != 3 && matSize != 4) { - PyErr_SetString(PyExc_AttributeError,"mathutils.Matrix.Shear(): can only return a 2x2 3x3 or 4x4 matrix"); + PyErr_SetString(PyExc_AttributeError, + "mathutils.Matrix.Shear(): " + "can only return a 2x2 3x3 or 4x4 matrix"); return NULL; } @@ -547,7 +578,9 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args) float const factor= PyFloat_AsDouble(fac); if(factor==-1.0f && PyErr_Occurred()) { - PyErr_SetString(PyExc_AttributeError, "mathutils.Matrix.Shear(): the factor to be a float"); + PyErr_SetString(PyExc_AttributeError, + "mathutils.Matrix.Shear(): " + "the factor to be a float"); return NULL; } @@ -562,7 +595,9 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args) mat[1] = factor; } else { - PyErr_SetString(PyExc_AttributeError, "Matrix.Shear(): expected: X, Y or wrong matrix size for shearing plane"); + PyErr_SetString(PyExc_AttributeError, + "Matrix.Shear(): " + "expected: X, Y or wrong matrix size for shearing plane"); return NULL; } } @@ -592,7 +627,9 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args) mat[2] = factor[1]; } else { - PyErr_SetString(PyExc_AttributeError, "mathutils.Matrix.Shear(): expected: X, Y, XY, XZ, YZ"); + PyErr_SetString(PyExc_AttributeError, + "mathutils.Matrix.Shear(): " + "expected: X, Y, XY, XZ, YZ"); return NULL; } } @@ -624,7 +661,8 @@ static float matrix_determinant_internal(MatrixObject *self) self->matrix[1][1], self->matrix[1][2], self->matrix[2][0], self->matrix[2][1], self->matrix[2][2]); - } else { + } + else { return determinant_m4((float (*)[4])self->contigPtr); } } @@ -648,7 +686,9 @@ static PyObject *Matrix_to_quaternion(MatrixObject *self) /*must be 3-4 cols, 3-4 rows, square matrix*/ if((self->col_size < 3) || (self->row_size < 3) || (self->col_size != self->row_size)) { - PyErr_SetString(PyExc_AttributeError, "Matrix.to_quat(): inappropriate matrix size - expects 3x3 or 4x4 matrix"); + PyErr_SetString(PyExc_AttributeError, + "matrix.to_quat(): " + "inappropriate matrix size - expects 3x3 or 4x4 matrix"); return NULL; } if(self->col_size == 3){ @@ -661,7 +701,7 @@ static PyObject *Matrix_to_quaternion(MatrixObject *self) return newQuaternionObject(quat, Py_NEW, NULL); } -/*---------------------------Matrix.toEuler() --------------------*/ +/*---------------------------matrix.toEuler() --------------------*/ PyDoc_STRVAR(Matrix_to_euler_doc, ".. method:: to_euler(order, euler_compat)\n" "\n" @@ -710,12 +750,14 @@ static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args) mat= tmat; } else { - PyErr_SetString(PyExc_AttributeError, "Matrix.to_euler(): inappropriate matrix size - expects 3x3 or 4x4 matrix"); + PyErr_SetString(PyExc_AttributeError, + "matrix.to_euler(): " + "inappropriate matrix size - expects 3x3 or 4x4 matrix"); return NULL; } if(order_str) { - order= euler_order_from_string(order_str, "Matrix.to_euler()"); + order= euler_order_from_string(order_str, "matrix.to_euler()"); if(order == -1) return NULL; @@ -743,17 +785,20 @@ static PyObject *Matrix_resize_4x4(MatrixObject *self) int x, first_row_elem, curr_pos, new_pos, blank_columns, blank_rows, index; if(self->wrapped==Py_WRAP){ - PyErr_SetString(PyExc_TypeError, "cannot resize wrapped data - make a copy and resize that"); + PyErr_SetString(PyExc_TypeError, + "cannot resize wrapped data - make a copy and resize that"); return NULL; } if(self->cb_user){ - PyErr_SetString(PyExc_TypeError, "cannot resize owned data - make a copy and resize that"); + PyErr_SetString(PyExc_TypeError, + "cannot resize owned data - make a copy and resize that"); return NULL; } self->contigPtr = PyMem_Realloc(self->contigPtr, (sizeof(float) * 16)); if(self->contigPtr == NULL) { - PyErr_SetString(PyExc_MemoryError, "matrix.resize_4x4(): problem allocating pointer space"); + PyErr_SetString(PyExc_MemoryError, + "matrix.resize_4x4(): problem allocating pointer space"); return NULL; } /*set row pointers*/ @@ -813,7 +858,8 @@ static PyObject *Matrix_to_4x4(MatrixObject *self) } /* TODO, 2x2 matrix */ - PyErr_SetString(PyExc_TypeError, "Matrix.to_4x4(): inappropriate matrix size"); + PyErr_SetString(PyExc_TypeError, + "matrix.to_4x4(): inappropriate matrix size"); return NULL; } @@ -833,7 +879,8 @@ static PyObject *Matrix_to_3x3(MatrixObject *self) return NULL; if((self->col_size < 3) || (self->row_size < 3)) { - PyErr_SetString(PyExc_AttributeError, "Matrix.to_3x3(): inappropriate matrix size"); + PyErr_SetString(PyExc_AttributeError, + "matrix.to_3x3(): inappropriate matrix size"); return NULL; } @@ -856,7 +903,9 @@ static PyObject *Matrix_to_translation(MatrixObject *self) return NULL; if((self->col_size < 3) || self->row_size < 4){ - PyErr_SetString(PyExc_AttributeError, "Matrix.to_translation(): inappropriate matrix size"); + PyErr_SetString(PyExc_AttributeError, + "matrix.to_translation(): " + "inappropriate matrix size"); return NULL; } @@ -884,7 +933,9 @@ static PyObject *Matrix_to_scale(MatrixObject *self) /*must be 3-4 cols, 3-4 rows, square matrix*/ if((self->col_size < 3) || (self->row_size < 3)) { - PyErr_SetString(PyExc_AttributeError, "Matrix.to_scale(): inappropriate matrix size, 3x3 minimum size"); + PyErr_SetString(PyExc_AttributeError, + "matrix.to_scale(): " + "inappropriate matrix size, 3x3 minimum size"); return NULL; } @@ -896,7 +947,7 @@ static PyObject *Matrix_to_scale(MatrixObject *self) return newVectorObject(size, 3, Py_NEW, NULL); } -/*---------------------------Matrix.invert() ---------------------*/ +/*---------------------------matrix.invert() ---------------------*/ PyDoc_STRVAR(Matrix_invert_doc, ".. method:: invert()\n" "\n" @@ -918,7 +969,9 @@ static PyObject *Matrix_invert(MatrixObject *self) return NULL; if(self->row_size != self->col_size){ - PyErr_SetString(PyExc_AttributeError, "Matrix.invert(ed): only square matrices are supported"); + PyErr_SetString(PyExc_AttributeError, + "matrix.invert(ed): " + "only square matrices are supported"); return NULL; } @@ -950,8 +1003,10 @@ static PyObject *Matrix_invert(MatrixObject *self) } /*transpose Matrix_transpose(self);*/ - } else { - PyErr_SetString(PyExc_ValueError, "matrix does not have an inverse"); + } + else { + PyErr_SetString(PyExc_ValueError, + "matrix does not have an inverse"); return NULL; } @@ -995,7 +1050,8 @@ static PyObject *Matrix_rotate(MatrixObject *self, PyObject *value) return NULL; if(self->col_size != 3 || self->row_size != 3) { - PyErr_SetString(PyExc_ValueError, "Matrix must have 3x3 dimensions"); + PyErr_SetString(PyExc_ValueError, + "Matrix must have 3x3 dimensions"); return NULL; } @@ -1008,7 +1064,7 @@ static PyObject *Matrix_rotate(MatrixObject *self, PyObject *value) Py_RETURN_NONE; } -/*---------------------------Matrix.decompose() ---------------------*/ +/*---------------------------matrix.decompose() ---------------------*/ PyDoc_STRVAR(Matrix_decompose_doc, ".. method:: decompose()\n" "\n" @@ -1026,7 +1082,9 @@ static PyObject *Matrix_decompose(MatrixObject *self) float size[3]; if(self->col_size != 4 || self->row_size != 4) { - PyErr_SetString(PyExc_AttributeError, "Matrix.decompose(): inappropriate matrix size - expects 4x4 matrix"); + PyErr_SetString(PyExc_AttributeError, + "matrix.decompose(): " + "inappropriate matrix size - expects 4x4 matrix"); return NULL; } @@ -1067,7 +1125,9 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args) return NULL; if(self->row_size != mat2->row_size || self->col_size != mat2->col_size) { - PyErr_SetString(PyExc_AttributeError, "matrix.lerp(): expects both matrix objects of the same dimensions"); + PyErr_SetString(PyExc_AttributeError, + "matrix.lerp(): " + "expects both matrix objects of the same dimensions"); return NULL; } @@ -1082,14 +1142,16 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args) blend_m3_m3m3((float (*)[3])mat, (float (*)[3])self->contigPtr, (float (*)[3])mat2->contigPtr, fac); } else { - PyErr_SetString(PyExc_AttributeError, "matrix.lerp(): only 3x3 and 4x4 matrices supported"); + PyErr_SetString(PyExc_AttributeError, + "matrix.lerp(): " + "only 3x3 and 4x4 matrices supported"); return NULL; } return (PyObject*)newMatrixObject(mat, self->row_size, self->col_size, Py_NEW, Py_TYPE(self)); } -/*---------------------------Matrix.determinant() ----------------*/ +/*---------------------------matrix.determinant() ----------------*/ PyDoc_STRVAR(Matrix_determinant_doc, ".. method:: determinant()\n" "\n" @@ -1106,13 +1168,15 @@ static PyObject *Matrix_determinant(MatrixObject *self) return NULL; if(self->row_size != self->col_size){ - PyErr_SetString(PyExc_AttributeError, "Matrix.determinant: only square matrices are supported"); + PyErr_SetString(PyExc_AttributeError, + "matrix.determinant: " + "only square matrices are supported"); return NULL; } return PyFloat_FromDouble((double)matrix_determinant_internal(self)); } -/*---------------------------Matrix.transpose() ------------------*/ +/*---------------------------matrix.transpose() ------------------*/ PyDoc_STRVAR(Matrix_transpose_doc, ".. method:: transpose()\n" "\n" @@ -1128,7 +1192,9 @@ static PyObject *Matrix_transpose(MatrixObject *self) return NULL; if(self->row_size != self->col_size){ - PyErr_SetString(PyExc_AttributeError, "Matrix.transpose(d): only square matrices are supported"); + PyErr_SetString(PyExc_AttributeError, + "matrix.transpose(d): " + "only square matrices are supported"); return NULL; } @@ -1138,7 +1204,8 @@ static PyObject *Matrix_transpose(MatrixObject *self) self->matrix[0][1] = t; } else if(self->row_size == 3) { transpose_m3((float (*)[3])self->contigPtr); - } else { + } + else { transpose_m4((float (*)[4])self->contigPtr); } @@ -1159,7 +1226,7 @@ static PyObject *Matrix_transposed(MatrixObject *self) return matrix__apply_to_copy((PyNoArgsFunction)Matrix_transpose, self); } -/*---------------------------Matrix.zero() -----------------------*/ +/*---------------------------matrix.zero() -----------------------*/ PyDoc_STRVAR(Matrix_zero_doc, ".. method:: zero()\n" "\n" @@ -1177,7 +1244,7 @@ static PyObject *Matrix_zero(MatrixObject *self) Py_RETURN_NONE; } -/*---------------------------Matrix.identity(() ------------------*/ +/*---------------------------matrix.identity(() ------------------*/ PyDoc_STRVAR(Matrix_identity_doc, ".. method:: identity()\n" "\n" @@ -1194,7 +1261,9 @@ static PyObject *Matrix_identity(MatrixObject *self) return NULL; if(self->row_size != self->col_size){ - PyErr_SetString(PyExc_AttributeError, "Matrix.identity: only square matrices are supported"); + PyErr_SetString(PyExc_AttributeError, + "matrix.identity: " + "only square matrices are supported"); return NULL; } @@ -1205,7 +1274,8 @@ static PyObject *Matrix_identity(MatrixObject *self) self->matrix[1][1] = 1.0f; } else if(self->row_size == 3) { unit_m3((float (*)[3])self->contigPtr); - } else { + } + else { unit_m4((float (*)[4])self->contigPtr); } @@ -1262,7 +1332,8 @@ static PyObject *Matrix_repr(MatrixObject *self) " %R)", rows[0], rows[1], rows[2], rows[3]); } - PyErr_SetString(PyExc_RuntimeError, "invalid matrix size"); + PyErr_SetString(PyExc_RuntimeError, + "internal error!"); return NULL; } @@ -1321,7 +1392,9 @@ static PyObject *Matrix_item(MatrixObject *self, int i) return NULL; if(i < 0 || i >= self->row_size) { - PyErr_SetString(PyExc_IndexError, "matrix[attribute]: array index out of range"); + PyErr_SetString(PyExc_IndexError, + "matrix[attribute]: " + "array index out of range"); return NULL; } return newVectorObject_cb((PyObject *)self, self->col_size, mathutils_matrix_vector_cb_index, i); @@ -1336,7 +1409,8 @@ static int Matrix_ass_item(MatrixObject *self, int i, PyObject *value) return -1; if(i >= self->row_size || i < 0){ - PyErr_SetString(PyExc_TypeError, "matrix[attribute] = x: bad column"); + PyErr_SetString(PyExc_TypeError, + "matrix[attribute] = x: bad column"); return -1; } @@ -1399,7 +1473,9 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va if(PySequence_Fast_GET_SIZE(value_fast) != size) { Py_DECREF(value_fast); - PyErr_SetString(PyExc_TypeError, "matrix[begin:end] = []: size mismatch in slice assignment"); + PyErr_SetString(PyExc_TypeError, + "matrix[begin:end] = []: " + "size mismatch in slice assignment"); return -1; } @@ -1433,7 +1509,9 @@ static PyObject *Matrix_add(PyObject *m1, PyObject *m2) mat2 = (MatrixObject*)m2; if(!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) { - PyErr_SetString(PyExc_AttributeError, "Matrix addition: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Matrix addition: " + "arguments not valid for this operation"); return NULL; } @@ -1441,7 +1519,9 @@ static PyObject *Matrix_add(PyObject *m1, PyObject *m2) return NULL; if(mat1->row_size != mat2->row_size || mat1->col_size != mat2->col_size){ - PyErr_SetString(PyExc_AttributeError, "Matrix addition: matrices must have the same dimensions for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Matrix addition: " + "matrices must have the same dimensions for this operation"); return NULL; } @@ -1460,7 +1540,9 @@ static PyObject *Matrix_sub(PyObject *m1, PyObject *m2) mat2 = (MatrixObject*)m2; if(!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) { - PyErr_SetString(PyExc_AttributeError, "Matrix addition: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Matrix addition: " + "arguments not valid for this operation"); return NULL; } @@ -1468,7 +1550,9 @@ static PyObject *Matrix_sub(PyObject *m1, PyObject *m2) return NULL; if(mat1->row_size != mat2->row_size || mat1->col_size != mat2->col_size){ - PyErr_SetString(PyExc_AttributeError, "Matrix addition: matrices must have the same dimensions for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Matrix addition: " + "matrices must have the same dimensions for this operation"); return NULL; } @@ -1502,9 +1586,12 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2) return NULL; } - if(mat1 && mat2) { /*MATRIX * MATRIX*/ + if(mat1 && mat2) { + /*MATRIX * MATRIX*/ if(mat1->row_size != mat2->col_size){ - PyErr_SetString(PyExc_AttributeError,"Matrix multiplication: matrix A rowsize must equal matrix B colsize"); + PyErr_SetString(PyExc_AttributeError, + "Matrix multiplication: " + "matrix A rowsize must equal matrix B colsize"); return NULL; } else { @@ -1529,12 +1616,14 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2) } } else if(mat2) { - if (((scalar= PyFloat_AsDouble(m1)) == -1.0f && PyErr_Occurred())==0) { /*FLOAT/INT * MATRIX */ + /*FLOAT/INT * MATRIX */ + if (((scalar= PyFloat_AsDouble(m1)) == -1.0f && PyErr_Occurred())==0) { return matrix_mul_float(mat2, scalar); } } else if(mat1) { - if (((scalar= PyFloat_AsDouble(m2)) == -1.0f && PyErr_Occurred())==0) { /*FLOAT/INT * MATRIX */ + /*FLOAT/INT * MATRIX */ + if (((scalar= PyFloat_AsDouble(m2)) == -1.0f && PyErr_Occurred())==0) { return matrix_mul_float(mat1, scalar); } } @@ -1542,7 +1631,10 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2) BLI_assert(!"internal error"); } - PyErr_Format(PyExc_TypeError, "Matrix multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(m1)->tp_name, Py_TYPE(m2)->tp_name); + PyErr_Format(PyExc_TypeError, + "Matrix multiplication: " + "not supported between '%.200s' and '%.200s' types", + Py_TYPE(m1)->tp_name, Py_TYPE(m2)->tp_name); return NULL; } static PyObject* Matrix_inv(MatrixObject *self) @@ -1591,12 +1683,15 @@ static PyObject *Matrix_subscript(MatrixObject* self, PyObject* item) return Matrix_slice(self, start, stop); } else { - PyErr_SetString(PyExc_TypeError, "slice steps not supported with matricies"); + PyErr_SetString(PyExc_TypeError, + "slice steps not supported with matricies"); return NULL; } } else { - PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name); + PyErr_Format(PyExc_TypeError, + "vector indices must be integers, not %.200s", + Py_TYPE(item)->tp_name); return NULL; } } @@ -1620,12 +1715,15 @@ static int Matrix_ass_subscript(MatrixObject* self, PyObject* item, PyObject* va if (step == 1) return Matrix_ass_slice(self, start, stop, value); else { - PyErr_SetString(PyExc_TypeError, "slice steps not supported with matricies"); + PyErr_SetString(PyExc_TypeError, + "slice steps not supported with matricies"); return -1; } } else { - PyErr_Format(PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name); + PyErr_Format(PyExc_TypeError, + "matrix indices must be integers, not %.200s", + Py_TYPE(item)->tp_name); return -1; } } @@ -1693,7 +1791,9 @@ static PyObject *Matrix_median_scale_get(MatrixObject *self, void *UNUSED(closur /*must be 3-4 cols, 3-4 rows, square matrix*/ if((self->col_size < 3) || (self->row_size < 3)) { - PyErr_SetString(PyExc_AttributeError, "Matrix.median_scale: inappropriate matrix size, 3x3 minimum"); + PyErr_SetString(PyExc_AttributeError, + "matrix.median_scale: " + "inappropriate matrix size, 3x3 minimum"); return NULL; } @@ -1713,7 +1813,9 @@ static PyObject *Matrix_is_negative_get(MatrixObject *self, void *UNUSED(closure else if(self->col_size == 3 && self->row_size == 3) return PyBool_FromLong(is_negative_m3((float (*)[3])self->contigPtr)); else { - PyErr_SetString(PyExc_AttributeError, "Matrix.is_negative: inappropriate matrix size - expects 3x3 or 4x4 matrix"); + PyErr_SetString(PyExc_AttributeError, + "matrix.is_negative: " + "inappropriate matrix size - expects 3x3 or 4x4 matrix"); return NULL; } } @@ -1729,7 +1831,9 @@ static PyObject *Matrix_is_orthogonal_get(MatrixObject *self, void *UNUSED(closu else if(self->col_size == 3 && self->row_size == 3) return PyBool_FromLong(is_orthogonal_m3((float (*)[3])self->contigPtr)); else { - PyErr_SetString(PyExc_AttributeError, "Matrix.is_orthogonal: inappropriate matrix size - expects 3x3 or 4x4 matrix"); + PyErr_SetString(PyExc_AttributeError, + "matrix.is_orthogonal: " + "inappropriate matrix size - expects 3x3 or 4x4 matrix"); return NULL; } } @@ -1865,7 +1969,9 @@ PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsign /*matrix objects can be any 2-4row x 2-4col matrix*/ if(rowSize < 2 || rowSize > 4 || colSize < 2 || colSize > 4) { - PyErr_SetString(PyExc_RuntimeError, "matrix(): row and column sizes must be between 2 and 4"); + PyErr_SetString(PyExc_RuntimeError, + "Matrix(): " + "row and column sizes must be between 2 and 4"); return NULL; } @@ -1891,7 +1997,9 @@ PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsign else if (type == Py_NEW){ self->contigPtr = PyMem_Malloc(rowSize * colSize * sizeof(float)); if(self->contigPtr == NULL) { /*allocation failure*/ - PyErr_SetString(PyExc_MemoryError, "matrix(): problem allocating pointer space"); + PyErr_SetString(PyExc_MemoryError, + "Matrix(): " + "problem allocating pointer space"); return NULL; } /*pointer array points to contigous memory*/ @@ -1913,7 +2021,8 @@ PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsign self->wrapped = Py_NEW; } else { - PyErr_SetString(PyExc_RuntimeError, "Matrix(): invalid type"); + PyErr_SetString(PyExc_RuntimeError, + "Matrix(): invalid type, internal error"); return NULL; } } diff --git a/source/blender/python/generic/mathutils_Quaternion.c b/source/blender/python/generic/mathutils_Quaternion.c index 90447e7093a..977ff7ccbc7 100644 --- a/source/blender/python/generic/mathutils_Quaternion.c +++ b/source/blender/python/generic/mathutils_Quaternion.c @@ -235,7 +235,9 @@ static PyObject *Quaternion_slerp(QuaternionObject *self, PyObject *args) float tquat[QUAT_SIZE], quat[QUAT_SIZE], fac; if(!PyArg_ParseTuple(args, "Of:slerp", &value, &fac)) { - PyErr_SetString(PyExc_TypeError, "quat.slerp(): expected Quaternion types and float"); + PyErr_SetString(PyExc_TypeError, + "quat.slerp(): " + "expected Quaternion types and float"); return NULL; } @@ -246,7 +248,9 @@ static PyObject *Quaternion_slerp(QuaternionObject *self, PyObject *args) return NULL; if(fac > 1.0f || fac < 0.0f) { - PyErr_SetString(PyExc_AttributeError, "quat.slerp(): interpolation factor must be between 0.0 and 1.0"); + PyErr_SetString(PyExc_AttributeError, + "quat.slerp(): " + "interpolation factor must be between 0.0 and 1.0"); return NULL; } @@ -498,7 +502,9 @@ static PyObject *Quaternion_item(QuaternionObject *self, int i) if(i<0) i= QUAT_SIZE-i; if(i < 0 || i >= QUAT_SIZE) { - PyErr_SetString(PyExc_IndexError, "quaternion[attribute]: array index out of range"); + PyErr_SetString(PyExc_IndexError, + "quaternion[attribute]: " + "array index out of range"); return NULL; } @@ -514,14 +520,18 @@ static int Quaternion_ass_item(QuaternionObject *self, int i, PyObject *ob) { float scalar= (float)PyFloat_AsDouble(ob); if(scalar==-1.0f && PyErr_Occurred()) { /* parsed item not a number */ - PyErr_SetString(PyExc_TypeError, "quaternion[index] = x: index argument not a number"); + PyErr_SetString(PyExc_TypeError, + "quaternion[index] = x: " + "index argument not a number"); return -1; } if(i<0) i= QUAT_SIZE-i; if(i < 0 || i >= QUAT_SIZE){ - PyErr_SetString(PyExc_IndexError, "quaternion[attribute] = x: array assignment index out of range"); + PyErr_SetString(PyExc_IndexError, + "quaternion[attribute] = x: " + "array assignment index out of range"); return -1; } self->quat[i] = scalar; @@ -572,7 +582,9 @@ static int Quaternion_ass_slice(QuaternionObject *self, int begin, int end, PyOb return -1; if(size != (end - begin)){ - PyErr_SetString(PyExc_TypeError, "quaternion[begin:end] = []: size mismatch in slice assignment"); + PyErr_SetString(PyExc_TypeError, + "quaternion[begin:end] = []: " + "size mismatch in slice assignment"); return -1; } @@ -608,12 +620,15 @@ static PyObject *Quaternion_subscript(QuaternionObject *self, PyObject *item) return Quaternion_slice(self, start, stop); } else { - PyErr_SetString(PyExc_TypeError, "slice steps not supported with quaternions"); + PyErr_SetString(PyExc_TypeError, + "slice steps not supported with quaternions"); return NULL; } } else { - PyErr_Format(PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name); + PyErr_Format(PyExc_TypeError, + "quaternion indices must be integers, not %.200s", + Py_TYPE(item)->tp_name); return NULL; } } @@ -638,12 +653,15 @@ static int Quaternion_ass_subscript(QuaternionObject *self, PyObject *item, PyOb if (step == 1) return Quaternion_ass_slice(self, start, stop, value); else { - PyErr_SetString(PyExc_TypeError, "slice steps not supported with quaternion"); + PyErr_SetString(PyExc_TypeError, + "slice steps not supported with quaternion"); return -1; } } else { - PyErr_Format(PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name); + PyErr_Format(PyExc_TypeError, + "quaternion indices must be integers, not %.200s", + Py_TYPE(item)->tp_name); return -1; } } @@ -657,7 +675,9 @@ static PyObject *Quaternion_add(PyObject *q1, PyObject *q2) QuaternionObject *quat1 = NULL, *quat2 = NULL; if(!QuaternionObject_Check(q1) || !QuaternionObject_Check(q2)) { - PyErr_SetString(PyExc_AttributeError, "Quaternion addition: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Quaternion addition: " + "arguments not valid for this operation"); return NULL; } quat1 = (QuaternionObject*)q1; @@ -678,7 +698,9 @@ static PyObject *Quaternion_sub(PyObject *q1, PyObject *q2) QuaternionObject *quat1 = NULL, *quat2 = NULL; if(!QuaternionObject_Check(q1) || !QuaternionObject_Check(q2)) { - PyErr_SetString(PyExc_AttributeError, "Quaternion addition: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Quaternion addition: " + "arguments not valid for this operation"); return NULL; } @@ -740,7 +762,10 @@ static PyObject *Quaternion_mul(PyObject *q1, PyObject *q2) BLI_assert(!"internal error"); } - PyErr_Format(PyExc_TypeError, "Quaternion multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(q1)->tp_name, Py_TYPE(q2)->tp_name); + PyErr_Format(PyExc_TypeError, + "Quaternion multiplication: " + "not supported between '%.200s' and '%.200s' types", + Py_TYPE(q1)->tp_name, Py_TYPE(q2)->tp_name); return NULL; } @@ -861,7 +886,8 @@ static int Quaternion_setAngle(QuaternionObject *self, PyObject *value, void *UN angle= PyFloat_AsDouble(value); if(angle==-1.0 && PyErr_Occurred()) { /* parsed item not a number */ - PyErr_SetString(PyExc_TypeError, "quaternion.angle = value: float expected"); + PyErr_SetString(PyExc_TypeError, + "quaternion.angle = value: float expected"); return -1; } @@ -942,7 +968,9 @@ static PyObject *Quaternion_new(PyTypeObject *type, PyObject *args, PyObject *kw float quat[QUAT_SIZE]= {0.0f, 0.0f, 0.0f, 0.0f}; if(kwds && PyDict_Size(kwds)) { - PyErr_SetString(PyExc_TypeError, "mathutils.Quaternion(): takes no keyword args"); + PyErr_SetString(PyExc_TypeError, + "mathutils.Quaternion(): " + "takes no keyword args"); return NULL; } @@ -1114,7 +1142,8 @@ PyObject *newQuaternionObject(float *quat, int type, PyTypeObject *base_type) self->wrapped = Py_NEW; } else { - PyErr_SetString(PyExc_RuntimeError, "Quaternion(): invalid type"); + PyErr_SetString(PyExc_RuntimeError, + "Quaternion(): invalid type, internal error"); return NULL; } } diff --git a/source/blender/python/generic/mathutils_Vector.c b/source/blender/python/generic/mathutils_Vector.c index e07b51c9e4b..b8fdc2f0890 100644 --- a/source/blender/python/generic/mathutils_Vector.c +++ b/source/blender/python/generic/mathutils_Vector.c @@ -66,7 +66,9 @@ static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *UNUSED return NULL; break; default: - PyErr_SetString(PyExc_TypeError, "mathutils.Vector(): more then a single arg given"); + PyErr_SetString(PyExc_TypeError, + "mathutils.Vector(): " + "more then a single arg given"); return NULL; } return newVectorObject(vec, size, Py_NEW, type); @@ -156,17 +158,23 @@ PyDoc_STRVAR(Vector_resize_2d_doc, static PyObject *Vector_resize_2d(VectorObject *self) { if(self->wrapped==Py_WRAP) { - PyErr_SetString(PyExc_TypeError, "vector.resize_2d(): cannot resize wrapped data - only python vectors"); + PyErr_SetString(PyExc_TypeError, + "vector.resize_2d(): " + "cannot resize wrapped data - only python vectors"); return NULL; } if(self->cb_user) { - PyErr_SetString(PyExc_TypeError, "vector.resize_2d(): cannot resize a vector that has an owner"); + PyErr_SetString(PyExc_TypeError, + "vector.resize_2d(): " + "cannot resize a vector that has an owner"); return NULL; } self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 2)); if(self->vec == NULL) { - PyErr_SetString(PyExc_MemoryError, "vector.resize_2d(): problem allocating pointer space"); + PyErr_SetString(PyExc_MemoryError, + "vector.resize_2d(): " + "problem allocating pointer space"); return NULL; } @@ -185,17 +193,23 @@ PyDoc_STRVAR(Vector_resize_3d_doc, static PyObject *Vector_resize_3d(VectorObject *self) { if (self->wrapped==Py_WRAP) { - PyErr_SetString(PyExc_TypeError, "vector.resize_3d(): cannot resize wrapped data - only python vectors"); + PyErr_SetString(PyExc_TypeError, + "vector.resize_3d(): " + "cannot resize wrapped data - only python vectors"); return NULL; } if(self->cb_user) { - PyErr_SetString(PyExc_TypeError, "vector.resize_3d(): cannot resize a vector that has an owner"); + PyErr_SetString(PyExc_TypeError, + "vector.resize_3d(): " + "cannot resize a vector that has an owner"); return NULL; } self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 3)); if(self->vec == NULL) { - PyErr_SetString(PyExc_MemoryError, "vector.resize_3d(): problem allocating pointer space"); + PyErr_SetString(PyExc_MemoryError, + "vector.resize_3d(): " + "problem allocating pointer space"); return NULL; } @@ -217,17 +231,23 @@ PyDoc_STRVAR(Vector_resize_4d_doc, static PyObject *Vector_resize_4d(VectorObject *self) { if(self->wrapped==Py_WRAP) { - PyErr_SetString(PyExc_TypeError, "vector.resize_4d(): cannot resize wrapped data - only python vectors"); + PyErr_SetString(PyExc_TypeError, + "vector.resize_4d(): " + "cannot resize wrapped data - only python vectors"); return NULL; } if(self->cb_user) { - PyErr_SetString(PyExc_TypeError, "vector.resize_4d(): cannot resize a vector that has an owner"); + PyErr_SetString(PyExc_TypeError, + "vector.resize_4d(): " + "cannot resize a vector that has an owner"); return NULL; } self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 4)); if(self->vec == NULL) { - PyErr_SetString(PyExc_MemoryError, "vector.resize_4d(): problem allocating pointer space"); + PyErr_SetString(PyExc_MemoryError, + "vector.resize_4d(): " + "problem allocating pointer space"); return NULL; } @@ -333,7 +353,9 @@ static PyObject *Vector_to_tuple(VectorObject *self, PyObject *args) return NULL; if(ndigits > 22 || ndigits < 0) { - PyErr_SetString(PyExc_ValueError, "vector.to_tuple(ndigits): ndigits must be between 0 and 21"); + PyErr_SetString(PyExc_ValueError, + "vector.to_tuple(ndigits): " + "ndigits must be between 0 and 21"); return NULL; } @@ -368,7 +390,9 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args) return NULL; if (self->size != 3) { - PyErr_SetString(PyExc_TypeError, "only for 3D vectors"); + PyErr_SetString(PyExc_TypeError, + "vector.to_track_quat(): " + "only for 3D vectors"); return NULL; } @@ -376,6 +400,8 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args) return NULL; if (strack) { + const char *axis_err_msg= "only X, -X, Y, -Y, Z or -Z for track axis"; + if (strlen(strack) == 2) { if (strack[0] == '-') { switch(strack[1]) { @@ -389,12 +415,12 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args) track = 5; break; default: - PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis"); + PyErr_SetString(PyExc_ValueError, axis_err_msg); return NULL; } } else { - PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis"); + PyErr_SetString(PyExc_ValueError, axis_err_msg); return NULL; } } @@ -411,17 +437,19 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args) track = 2; break; default: - PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis"); + PyErr_SetString(PyExc_ValueError, axis_err_msg); return NULL; } } else { - PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis"); + PyErr_SetString(PyExc_ValueError, + axis_err_msg); return NULL; } } if (sup) { + const char *axis_err_msg= "only X, Y or Z for up axis"; if (strlen(sup) == 1) { switch(*sup) { case 'X': @@ -434,18 +462,19 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args) up = 2; break; default: - PyErr_SetString(PyExc_ValueError, "only X, Y or Z for up axis"); + PyErr_SetString(PyExc_ValueError, axis_err_msg); return NULL; } } else { - PyErr_SetString(PyExc_ValueError, "only X, Y or Z for up axis"); + PyErr_SetString(PyExc_ValueError, axis_err_msg); return NULL; } } if (track == up) { - PyErr_SetString(PyExc_ValueError, "Can't have the same axis for track and up"); + PyErr_SetString(PyExc_ValueError, + "Can't have the same axis for track and up"); return NULL; } @@ -604,7 +633,9 @@ static PyObject *Vector_angle(VectorObject *self, PyObject *args) return fallback; } else { - PyErr_SetString(PyExc_ValueError, "vector.angle(other): zero length vectors have no valid angle"); + PyErr_SetString(PyExc_ValueError, + "vector.angle(other): " + "zero length vectors have no valid angle"); return NULL; } } @@ -636,7 +667,9 @@ static PyObject *Vector_rotation_difference(VectorObject *self, PyObject *value) float quat[4], vec_a[3], vec_b[3]; if(self->size < 3) { - PyErr_SetString(PyExc_AttributeError, "vec.difference(value): expects both vectors to be size 3 or 4"); + PyErr_SetString(PyExc_AttributeError, + "vec.difference(value): " + "expects both vectors to be size 3 or 4"); return NULL; } @@ -750,7 +783,8 @@ static PyObject *Vector_rotate(VectorObject *self, PyObject *value) return NULL; if(self->size < 3) { - PyErr_SetString(PyExc_ValueError, "Vector must be 3D or 4D"); + PyErr_SetString(PyExc_ValueError, + "Vector must be 3D or 4D"); return NULL; } @@ -804,8 +838,15 @@ static PyObject *vector_item_internal(VectorObject *self, int i, const int is_at if(i<0) i= self->size-i; if(i < 0 || i >= self->size) { - if(is_attr) PyErr_Format(PyExc_AttributeError,"vector.%c: unavailable on %dd vector", *(((char *)"xyzw") + i), self->size); - else PyErr_SetString(PyExc_IndexError,"vector[index]: out of range"); + if(is_attr) { + PyErr_Format(PyExc_AttributeError, + "vector.%c: unavailable on %dd vector", + *(((char *)"xyzw") + i), self->size); + } + else { + PyErr_SetString(PyExc_IndexError, + "vector[index]: out of range"); + } return NULL; } @@ -824,15 +865,25 @@ static int vector_ass_item_internal(VectorObject *self, int i, PyObject *value, { float scalar; if((scalar=PyFloat_AsDouble(value))==-1.0f && PyErr_Occurred()) { /* parsed item not a number */ - PyErr_SetString(PyExc_TypeError, "vector[index] = x: index argument not a number"); + PyErr_SetString(PyExc_TypeError, + "vector[index] = x: " + "index argument not a number"); return -1; } if(i<0) i= self->size-i; if(i < 0 || i >= self->size){ - if(is_attr) PyErr_Format(PyExc_AttributeError,"vector.%c = x: unavailable on %dd vector", *(((char *)"xyzw") + i), self->size); - else PyErr_SetString(PyExc_IndexError, "vector[index] = x: assignment index out of range"); + if(is_attr) { + PyErr_Format(PyExc_AttributeError, + "vector.%c = x: unavailable on %dd vector", + *(((char *)"xyzw") + i), self->size); + } + else { + PyErr_SetString(PyExc_IndexError, + "vector[index] = x: " + "assignment index out of range"); + } return -1; } self->vec[i] = scalar; @@ -904,7 +955,9 @@ static PyObject *Vector_add(PyObject *v1, PyObject *v2) float vec[MAX_DIMENSIONS]; if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) { - PyErr_SetString(PyExc_AttributeError, "Vector addition: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Vector addition: " + "arguments not valid for this operation"); return NULL; } vec1 = (VectorObject*)v1; @@ -915,7 +968,9 @@ static PyObject *Vector_add(PyObject *v1, PyObject *v2) /*VECTOR + VECTOR*/ if(vec1->size != vec2->size) { - PyErr_SetString(PyExc_AttributeError, "Vector addition: vectors must have the same dimensions for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Vector addition: " + "vectors must have the same dimensions for this operation"); return NULL; } @@ -930,14 +985,18 @@ static PyObject *Vector_iadd(PyObject *v1, PyObject *v2) VectorObject *vec1 = NULL, *vec2 = NULL; if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) { - PyErr_SetString(PyExc_AttributeError, "Vector addition: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Vector addition: " + "arguments not valid for this operation"); return NULL; } vec1 = (VectorObject*)v1; vec2 = (VectorObject*)v2; if(vec1->size != vec2->size) { - PyErr_SetString(PyExc_AttributeError, "Vector addition: vectors must have the same dimensions for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Vector addition: " + "vectors must have the same dimensions for this operation"); return NULL; } @@ -958,7 +1017,9 @@ static PyObject *Vector_sub(PyObject *v1, PyObject *v2) float vec[MAX_DIMENSIONS]; if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) { - PyErr_SetString(PyExc_AttributeError, "Vector subtraction: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Vector subtraction: " + "arguments not valid for this operation"); return NULL; } vec1 = (VectorObject*)v1; @@ -968,7 +1029,9 @@ static PyObject *Vector_sub(PyObject *v1, PyObject *v2) return NULL; if(vec1->size != vec2->size) { - PyErr_SetString(PyExc_AttributeError, "Vector subtraction: vectors must have the same dimensions for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Vector subtraction: " + "vectors must have the same dimensions for this operation"); return NULL; } @@ -983,14 +1046,18 @@ static PyObject *Vector_isub(PyObject *v1, PyObject *v2) VectorObject *vec1= NULL, *vec2= NULL; if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) { - PyErr_SetString(PyExc_AttributeError, "Vector subtraction: arguments not valid for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Vector subtraction: " + "arguments not valid for this operation"); return NULL; } vec1 = (VectorObject*)v1; vec2 = (VectorObject*)v2; if(vec1->size != vec2->size) { - PyErr_SetString(PyExc_AttributeError, "Vector subtraction: vectors must have the same dimensions for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Vector subtraction: " + "vectors must have the same dimensions for this operation"); return NULL; } @@ -1027,7 +1094,10 @@ static int column_vector_multiplication(float rvec[MAX_DIMENSIONS], VectorObject vec_cpy[3] = 1.0f; } else { - PyErr_SetString(PyExc_AttributeError, "matrix * vector: matrix.row_size and len(vector) must be the same, except for 3D vector * 4x4 matrix."); + PyErr_SetString(PyExc_AttributeError, + "matrix * vector: " + "matrix.row_size and len(vector) must be the same, " + "except for 3D vector * 4x4 matrix."); return -1; } } @@ -1077,7 +1147,9 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2) double dot = 0.0f; if(vec1->size != vec2->size) { - PyErr_SetString(PyExc_AttributeError, "Vector multiplication: vectors must have the same dimensions for this operation"); + PyErr_SetString(PyExc_AttributeError, + "Vector multiplication: " + "vectors must have the same dimensions for this operation"); return NULL; } @@ -1105,7 +1177,9 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2) float tvec[3]; if(vec1->size != 3) { - PyErr_SetString(PyExc_TypeError, "Vector multiplication: only 3D vector rotations (with quats) currently supported"); + PyErr_SetString(PyExc_TypeError, + "Vector multiplication: " + "only 3D vector rotations (with quats) currently supported"); return NULL; } if(BaseMath_ReadCallback(quat2) == -1) { @@ -1128,7 +1202,10 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2) BLI_assert(!"internal error"); } - PyErr_Format(PyExc_TypeError, "Vector multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name); + PyErr_Format(PyExc_TypeError, + "Vector multiplication: " + "not supported between '%.200s' and '%.200s' types", + Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name); return NULL; } @@ -1158,7 +1235,9 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2) QuaternionObject *quat2 = (QuaternionObject*)v2; if(vec->size != 3) { - PyErr_SetString(PyExc_TypeError, "Vector multiplication: only 3D vector rotations (with quats) currently supported"); + PyErr_SetString(PyExc_TypeError, + "Vector multiplication: " + "only 3D vector rotations (with quats) currently supported"); return NULL; } @@ -1171,7 +1250,9 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2) mul_vn_fl(vec->vec, vec->size, scalar); } else { - PyErr_SetString(PyExc_TypeError, "Vector multiplication: arguments not acceptable for this operation"); + PyErr_SetString(PyExc_TypeError, + "Vector multiplication: " + "arguments not acceptable for this operation"); return NULL; } @@ -1188,7 +1269,9 @@ static PyObject *Vector_div(PyObject *v1, PyObject *v2) VectorObject *vec1 = NULL; if(!VectorObject_Check(v1)) { /* not a vector */ - PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float"); + PyErr_SetString(PyExc_TypeError, + "Vector division: " + "Vector must be divided by a float"); return NULL; } vec1 = (VectorObject*)v1; /* vector */ @@ -1197,12 +1280,16 @@ static PyObject *Vector_div(PyObject *v1, PyObject *v2) return NULL; if((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */ - PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float"); + PyErr_SetString(PyExc_TypeError, + "Vector division: " + "Vector must be divided by a float"); return NULL; } if(scalar==0.0f) { - PyErr_SetString(PyExc_ZeroDivisionError, "Vector division: divide by zero error"); + PyErr_SetString(PyExc_ZeroDivisionError, + "Vector division: " + "divide by zero error"); return NULL; } @@ -1223,12 +1310,16 @@ static PyObject *Vector_idiv(PyObject *v1, PyObject *v2) return NULL; if((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */ - PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float"); + PyErr_SetString(PyExc_TypeError, + "Vector division: " + "Vector must be divided by a float"); return NULL; } if(scalar==0.0f) { - PyErr_SetString(PyExc_ZeroDivisionError, "Vector division: divide by zero error"); + PyErr_SetString(PyExc_ZeroDivisionError, + "Vector division: " + "divide by zero error"); return NULL; } for(i = 0; i < vec1->size; i++) { @@ -1394,12 +1485,15 @@ static PyObject *Vector_subscript(VectorObject* self, PyObject* item) return Vector_slice(self, start, stop); } else { - PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors"); + PyErr_SetString(PyExc_TypeError, + "slice steps not supported with vectors"); return NULL; } } else { - PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name); + PyErr_Format(PyExc_TypeError, + "vector indices must be integers, not %.200s", + Py_TYPE(item)->tp_name); return NULL; } } @@ -1423,12 +1517,15 @@ static int Vector_ass_subscript(VectorObject* self, PyObject* item, PyObject* va if (step == 1) return Vector_ass_slice(self, start, stop, value); else { - PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors"); + PyErr_SetString(PyExc_TypeError, + "slice steps not supported with vectors"); return -1; } } else { - PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name); + PyErr_Format(PyExc_TypeError, + "vector indices must be integers, not %.200s", + Py_TYPE(item)->tp_name); return -1; } } @@ -1517,12 +1614,14 @@ static int Vector_setLength(VectorObject *self, PyObject *value) return -1; if((param=PyFloat_AsDouble(value)) == -1.0 && PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, "length must be set to a number"); + PyErr_SetString(PyExc_TypeError, + "length must be set to a number"); return -1; } if (param < 0.0) { - PyErr_SetString(PyExc_TypeError, "cannot set a vectors length to a negative value"); + PyErr_SetString(PyExc_TypeError, + "cannot set a vectors length to a negative value"); return -1; } if (param == 0.0) { @@ -1573,7 +1672,9 @@ static PyObject *Vector_getSwizzle(VectorObject *self, void *closure) { axis_from = swizzleClosure & SWIZZLE_AXIS; if(axis_from >= self->size) { - PyErr_SetString(PyExc_AttributeError, "Error: vector does not have specified axis"); + PyErr_SetString(PyExc_AttributeError, + "Vector swizzle: " + "specified axis not present"); return NULL; } @@ -1615,12 +1716,13 @@ static int Vector_setSwizzle(VectorObject *self, PyObject *value, void *closure) swizzles defined for axes z and w, but they would be invalid. */ swizzleClosure = GET_INT_FROM_POINTER(closure); axis_from= 0; - while (swizzleClosure & SWIZZLE_VALID_AXIS) - { + while (swizzleClosure & SWIZZLE_VALID_AXIS) { axis_to = swizzleClosure & SWIZZLE_AXIS; if (axis_to >= self->size) { - PyErr_SetString(PyExc_AttributeError, "Error: vector does not have specified axis"); + PyErr_SetString(PyExc_AttributeError, + "Vector swizzle: " + "specified axis not present"); return -1; } swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS; @@ -1639,7 +1741,8 @@ static int Vector_setSwizzle(VectorObject *self, PyObject *value, void *closure) } if(axis_from != size_from) { - PyErr_SetString(PyExc_AttributeError, "Error: vector size does not match swizzle"); + PyErr_SetString(PyExc_AttributeError, + "Vector swizzle: size does not match swizzle"); return -1; } @@ -2071,7 +2174,9 @@ static int row_vector_multiplication(float rvec[4], VectorObject* vec, MatrixObj if(mat->colSize != vec_size){ if(mat->colSize == 4 && vec_size != 3){ - PyErr_SetString(PyExc_AttributeError, "vector * matrix: matrix column size and the vector size must be the same"); + PyErr_SetString(PyExc_AttributeError, + "vector * matrix: matrix column size " + "and the vector size must be the same"); return -1; } else { @@ -2252,7 +2357,8 @@ PyObject *newVectorObject(float *vec, const int size, const int type, PyTypeObje VectorObject *self; if(size > 4 || size < 2) { - PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid size"); + PyErr_SetString(PyExc_RuntimeError, + "Vector(): invalid size"); return NULL; } @@ -2284,7 +2390,8 @@ PyObject *newVectorObject(float *vec, const int size, const int type, PyTypeObje self->wrapped = Py_NEW; } else { - PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid type"); + PyErr_SetString(PyExc_RuntimeError, + "Vector(): invalid type, internal error"); return NULL; } } diff --git a/source/blender/python/generic/mathutils_geometry.c b/source/blender/python/generic/mathutils_geometry.c index 26844a5003d..601daf01d00 100644 --- a/source/blender/python/generic/mathutils_geometry.c +++ b/source/blender/python/generic/mathutils_geometry.c @@ -90,7 +90,8 @@ static PyObject *M_Geometry_intersect_ray_tri(PyObject *UNUSED(self), PyObject* return NULL; } if(vec1->size != 3 || vec2->size != 3 || vec3->size != 3 || ray->size != 3 || ray_off->size != 3) { - PyErr_SetString(PyExc_ValueError, "only 3D vectors for all parameters"); + PyErr_SetString(PyExc_ValueError, + "only 3D vectors for all parameters"); return NULL; } @@ -177,7 +178,8 @@ static PyObject *M_Geometry_intersect_line_line(PyObject *UNUSED(self), PyObject return NULL; } if(vec1->size != vec2->size || vec1->size != vec3->size || vec3->size != vec2->size) { - PyErr_SetString(PyExc_ValueError,"vectors must be of the same size"); + PyErr_SetString(PyExc_ValueError, + "vectors must be of the same size"); return NULL; } @@ -225,7 +227,8 @@ static PyObject *M_Geometry_intersect_line_line(PyObject *UNUSED(self), PyObject } } else { - PyErr_SetString(PyExc_ValueError, "2D/3D vectors only"); + PyErr_SetString(PyExc_ValueError, + "2D/3D vectors only"); return NULL; } } @@ -259,11 +262,13 @@ static PyObject *M_Geometry_normal(PyObject *UNUSED(self), PyObject* args) return NULL; } if(vec1->size != vec2->size || vec1->size != vec3->size) { - PyErr_SetString(PyExc_ValueError, "vectors must be of the same size"); + PyErr_SetString(PyExc_ValueError, + "vectors must be of the same size"); return NULL; } if(vec1->size < 3) { - PyErr_SetString(PyExc_ValueError, "2D vectors unsupported"); + PyErr_SetString(PyExc_ValueError, + "2D vectors unsupported"); return NULL; } @@ -277,11 +282,13 @@ static PyObject *M_Geometry_normal(PyObject *UNUSED(self), PyObject* args) return NULL; } if(vec1->size != vec2->size || vec1->size != vec3->size || vec1->size != vec4->size) { - PyErr_SetString(PyExc_ValueError,"vectors must be of the same size"); + PyErr_SetString(PyExc_ValueError, + "vectors must be of the same size"); return NULL; } if(vec1->size < 3) { - PyErr_SetString(PyExc_ValueError, "2D vectors unsupported"); + PyErr_SetString(PyExc_ValueError, + "2D vectors unsupported"); return NULL; } @@ -318,7 +325,8 @@ static PyObject *M_Geometry_area_tri(PyObject *UNUSED(self), PyObject* args) } if(vec1->size != vec2->size || vec1->size != vec3->size) { - PyErr_SetString(PyExc_ValueError, "vectors must be of the same size"); + PyErr_SetString(PyExc_ValueError, + "vectors must be of the same size"); return NULL; } @@ -332,7 +340,8 @@ static PyObject *M_Geometry_area_tri(PyObject *UNUSED(self), PyObject* args) return PyFloat_FromDouble(area_tri_v2(vec1->vec, vec2->vec, vec3->vec)); } else { - PyErr_SetString(PyExc_ValueError, "only 2D,3D vectors are supported"); + PyErr_SetString(PyExc_ValueError, + "only 2D,3D vectors are supported"); return NULL; } } @@ -360,7 +369,8 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject * int index, *dl_face, totpoints=0; if(!PySequence_Check(polyLineSeq)) { - PyErr_SetString(PyExc_TypeError, "expected a sequence of poly lines"); + PyErr_SetString(PyExc_TypeError, + "expected a sequence of poly lines"); return NULL; } @@ -371,7 +381,8 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject * if (!PySequence_Check(polyLine)) { freedisplist(&dispbase); Py_XDECREF(polyLine); /* may be null so use Py_XDECREF*/ - PyErr_SetString(PyExc_TypeError, "One or more of the polylines is not a sequence of mathutils.Vector's"); + PyErr_SetString(PyExc_TypeError, + "One or more of the polylines is not a sequence of mathutils.Vector's"); return NULL; } @@ -381,7 +392,8 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject * if (EXPP_check_sequence_consistency(polyLine, &vector_Type) != 1) { freedisplist(&dispbase); Py_DECREF(polyLine); - PyErr_SetString(PyExc_TypeError, "A point in one of the polylines is not a mathutils.Vector type"); + PyErr_SetString(PyExc_TypeError, + "A point in one of the polylines is not a mathutils.Vector type"); return NULL; } #endif @@ -422,7 +434,9 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject * if(ls_error) { freedisplist(&dispbase); /* possible some dl was allocated */ - PyErr_SetString(PyExc_TypeError, "A point in one of the polylines is not a mathutils.Vector type"); + PyErr_SetString(PyExc_TypeError, + "A point in one of the polylines " + "is not a mathutils.Vector type"); return NULL; } else if (totpoints) { @@ -436,7 +450,8 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject * tri_list= PyList_New(dl->parts); if(!tri_list) { freedisplist(&dispbase); - PyErr_SetString(PyExc_RuntimeError, "geometry.PolyFill failed to make a new list"); + PyErr_SetString(PyExc_RuntimeError, + "failed to make a new list"); return NULL; } @@ -541,7 +556,9 @@ static PyObject *M_Geometry_intersect_line_plane(PyObject *UNUSED(self), PyObjec } if(ELEM4(2, line_a->size, line_b->size, plane_co->size, plane_no->size)) { - PyErr_SetString(PyExc_RuntimeError, "geometry.intersect_line_plane(...) can't use 2D Vectors"); + PyErr_SetString(PyExc_RuntimeError, + "geometry.intersect_line_plane(...): " + " can't use 2D Vectors"); return NULL; } @@ -597,7 +614,9 @@ static PyObject *M_Geometry_intersect_line_sphere(PyObject *UNUSED(self), PyObje } if(ELEM3(2, line_a->size, line_b->size, sphere_co->size)) { - PyErr_SetString(PyExc_RuntimeError, "geometry.intersect_line_sphere(...) can't use 2D Vectors"); + PyErr_SetString(PyExc_RuntimeError, + "geometry.intersect_line_sphere(...): " + " can't use 2D Vectors"); return NULL; } else { @@ -834,7 +853,8 @@ static int boxPack_FromPyObject(PyObject *value, boxPack **boxarray) /* Error checking must already be done */ if(!PyList_Check(value)) { - PyErr_SetString(PyExc_TypeError, "can only back a list of [x, y, w, h]"); + PyErr_SetString(PyExc_TypeError, + "can only back a list of [x, y, w, h]"); return -1; } @@ -847,7 +867,8 @@ static int boxPack_FromPyObject(PyObject *value, boxPack **boxarray) list_item= PyList_GET_ITEM(value, i); if(!PyList_Check(list_item) || PyList_Size(list_item) < 4) { MEM_freeN(*boxarray); - PyErr_SetString(PyExc_TypeError, "can only pack a list of [x, y, w, h]"); + PyErr_SetString(PyExc_TypeError, + "can only pack a list of [x, y, w, h]"); return -1; } @@ -862,7 +883,9 @@ static int boxPack_FromPyObject(PyObject *value, boxPack **boxarray) if (box->w < 0.0f || box->h < 0.0f) { MEM_freeN(*boxarray); - PyErr_SetString(PyExc_TypeError, "error parsing width and height values from list: [x, y, w, h], not numbers or below zero"); + PyErr_SetString(PyExc_TypeError, + "error parsing width and height values from list: " + "[x, y, w, h], not numbers or below zero"); return -1; } @@ -906,7 +929,8 @@ static PyObject *M_Geometry_box_pack_2d(PyObject *UNUSED(self), PyObject *boxlis PyObject *ret; if(!PyList_Check(boxlist)) { - PyErr_SetString(PyExc_TypeError, "expected a list of boxes [[x, y, w, h], ... ]"); + PyErr_SetString(PyExc_TypeError, + "expected a list of boxes [[x, y, w, h], ... ]"); return NULL; } @@ -972,7 +996,8 @@ static PyObject *M_Geometry_interpolate_bezier(PyObject *UNUSED(self), PyObject* } if(resolu <= 1) { - PyErr_SetString(PyExc_ValueError, "resolution must be 2 or over"); + PyErr_SetString(PyExc_ValueError, + "resolution must be 2 or over"); return NULL; } @@ -1049,7 +1074,8 @@ static PyObject *M_Geometry_barycentric_transform(PyObject *UNUSED(self), PyObje vec_t2_tar->size != 3 || vec_t3_tar->size != 3) { - PyErr_SetString(PyExc_ValueError, "One of more of the vector arguments wasnt a 3D vector"); + PyErr_SetString(PyExc_ValueError, + "One of more of the vector arguments wasnt a 3D vector"); return NULL; }