diff options
author | Campbell Barton <ideasman42@gmail.com> | 2011-02-24 08:46:57 +0300 |
---|---|---|
committer | Campbell Barton <ideasman42@gmail.com> | 2011-02-24 08:46:57 +0300 |
commit | fbd936494495d0de54eef24a97957e000306785f (patch) | |
tree | eb5dfa2bed0c96f98b0cf707569369ae96a6935a /source/blender | |
parent | b357033f5e7b0c39586f53512f47a3df23ba914e (diff) |
revert part of own commit r35117 which modified mathutils initialization functions, found this could be done in a better way which doesnt have to deal with partly initialize instances being freed.
Diffstat (limited to 'source/blender')
-rw-r--r-- | source/blender/python/generic/mathutils.c | 5 | ||||
-rw-r--r-- | source/blender/python/generic/mathutils.h | 1 | ||||
-rw-r--r-- | source/blender/python/generic/mathutils_Color.c | 72 | ||||
-rw-r--r-- | source/blender/python/generic/mathutils_Euler.c | 77 | ||||
-rw-r--r-- | source/blender/python/generic/mathutils_Matrix.c | 122 | ||||
-rw-r--r-- | source/blender/python/generic/mathutils_Quaternion.c | 73 | ||||
-rw-r--r-- | source/blender/python/generic/mathutils_Vector.c | 96 | ||||
-rw-r--r-- | source/blender/python/generic/mathutils_Vector.h | 2 |
8 files changed, 178 insertions, 270 deletions
diff --git a/source/blender/python/generic/mathutils.c b/source/blender/python/generic/mathutils.c index 7d56f1e0904..b925dfc0d32 100644 --- a/source/blender/python/generic/mathutils.c +++ b/source/blender/python/generic/mathutils.c @@ -341,10 +341,7 @@ void BaseMathObject_dealloc(BaseMathObject *self) { /* only free non wrapped */ if(self->wrapped != Py_WRAP) { - /* the ONLY time this should be NULL is when the value failed to initialize */ - if(self->data) { - PyMem_Free(self->data); - } + PyMem_Free(self->data); } BaseMathObject_clear(self); diff --git a/source/blender/python/generic/mathutils.h b/source/blender/python/generic/mathutils.h index d55e1c6e454..7d0644b3c76 100644 --- a/source/blender/python/generic/mathutils.h +++ b/source/blender/python/generic/mathutils.h @@ -58,7 +58,6 @@ typedef struct { PyObject *BaseMathObject_getOwner( BaseMathObject * self, void * ); PyObject *BaseMathObject_getWrapped( BaseMathObject *self, void * ); - int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg); int BaseMathObject_clear(BaseMathObject *self); void BaseMathObject_dealloc(BaseMathObject * self); diff --git a/source/blender/python/generic/mathutils_Color.c b/source/blender/python/generic/mathutils_Color.c index a67ef94f1a3..047bda1b2c5 100644 --- a/source/blender/python/generic/mathutils_Color.c +++ b/source/blender/python/generic/mathutils_Color.c @@ -509,31 +509,6 @@ PyTypeObject color_Type = { (i.e. it was allocated elsewhere by MEM_mallocN()) pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON (i.e. it must be created here with PyMEM_malloc())*/ -static int newColorObject_init(ColorObject *self, float *col, int type) -{ - if(type == Py_WRAP) { - self->col = col; - self->wrapped = Py_WRAP; - } - else if (type == Py_NEW) { - self->col = PyMem_Malloc(COLOR_SIZE * sizeof(float)); - if(col) { - copy_v3_v3(self->col, col); - } - else { - zero_v3(self->col); - } - - self->wrapped = Py_NEW; - } - else { - return -1; - } - - return 0; -} - - PyObject *newColorObject(float *col, int type, PyTypeObject *base_type) { ColorObject *self; @@ -541,14 +516,28 @@ PyObject *newColorObject(float *col, int type, PyTypeObject *base_type) self= base_type ? (ColorObject *)base_type->tp_alloc(base_type, 0) : (ColorObject *)PyObject_GC_New(ColorObject, &color_Type); - /* init callbacks as NULL */ - self->cb_user= NULL; - self->cb_type= self->cb_subtype= 0; - ((BaseMathObject *)self)->data= NULL; /* incase of error */ + if(self) { + /* init callbacks as NULL */ + self->cb_user= NULL; + self->cb_type= self->cb_subtype= 0; - if(newColorObject_init(self, col, type) == -1) { - Py_DECREF(self); - return NULL; + if(type == Py_WRAP){ + self->col = col; + self->wrapped = Py_WRAP; + } + else if (type == Py_NEW){ + self->col = PyMem_Malloc(COLOR_SIZE * sizeof(float)); + if(col) + copy_v3_v3(self->col, col); + else + zero_v3(self->col); + + self->wrapped = Py_NEW; + } + else { + PyErr_SetString(PyExc_RuntimeError, "Color(): invalid type"); + return NULL; + } } return (PyObject *)self; @@ -556,19 +545,12 @@ PyObject *newColorObject(float *col, int type, PyTypeObject *base_type) PyObject *newColorObject_cb(PyObject *cb_user, int cb_type, int cb_subtype) { - ColorObject *self; - - self= (ColorObject *)PyObject_GC_New(ColorObject, &color_Type); - - Py_INCREF(cb_user); - self->cb_user= cb_user; - self->cb_type= (unsigned char)cb_type; - self->cb_subtype= (unsigned char)cb_subtype; - ((BaseMathObject *)self)->data= NULL; /* incase of error */ - - if(newColorObject_init(self, NULL, Py_NEW) == -1) { - Py_DECREF(self); - return NULL; + ColorObject *self= (ColorObject *)newColorObject(NULL, Py_NEW, NULL); + if(self) { + Py_INCREF(cb_user); + self->cb_user= cb_user; + self->cb_type= (unsigned char)cb_type; + self->cb_subtype= (unsigned char)cb_subtype; } return (PyObject *)self; diff --git a/source/blender/python/generic/mathutils_Euler.c b/source/blender/python/generic/mathutils_Euler.c index 7dbc573fb83..95e7483d7be 100644 --- a/source/blender/python/generic/mathutils_Euler.c +++ b/source/blender/python/generic/mathutils_Euler.c @@ -642,32 +642,6 @@ PyTypeObject euler_Type = { (i.e. it was allocated elsewhere by MEM_mallocN()) pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON (i.e. it must be created here with PyMEM_malloc())*/ -static int newEulerObject_init(EulerObject *self, float *eul, short order, int type) -{ - if(type == Py_WRAP) { - self->eul = eul; - self->wrapped = Py_WRAP; - } - else if (type == Py_NEW){ - self->eul = PyMem_Malloc(EULER_SIZE * sizeof(float)); - if(eul) { - copy_v3_v3(self->eul, eul); - } - else { - zero_v3(self->eul); - } - self->wrapped = Py_NEW; - } - else{ - PyErr_SetString(PyExc_RuntimeError, "invalid type"); - return -1; - } - - self->order= order; - - return 0; -} - PyObject *newEulerObject(float *eul, short order, int type, PyTypeObject *base_type) { EulerObject *self; @@ -675,14 +649,32 @@ PyObject *newEulerObject(float *eul, short order, int type, PyTypeObject *base_t self= base_type ? (EulerObject *)base_type->tp_alloc(base_type, 0) : (EulerObject *)PyObject_GC_New(EulerObject, &euler_Type); - /* init callbacks as NULL */ - self->cb_user= NULL; - self->cb_type= self->cb_subtype= 0; - ((BaseMathObject *)self)->data= NULL; /* incase of error */ + if(self) { + /* init callbacks as NULL */ + self->cb_user= NULL; + self->cb_type= self->cb_subtype= 0; - if(newEulerObject_init(self, eul, order, type) == -1) { - Py_DECREF(self); - return NULL; + if(type == Py_WRAP) { + self->eul = eul; + self->wrapped = Py_WRAP; + } + else if (type == Py_NEW) { + self->eul = PyMem_Malloc(EULER_SIZE * sizeof(float)); + if(eul) { + copy_v3_v3(self->eul, eul); + } + else { + zero_v3(self->eul); + } + + self->wrapped = Py_NEW; + } + else { + PyErr_SetString(PyExc_RuntimeError, "Euler(): invalid type"); + return NULL; + } + + self->order= order; } return (PyObject *)self; @@ -690,19 +682,12 @@ PyObject *newEulerObject(float *eul, short order, int type, PyTypeObject *base_t PyObject *newEulerObject_cb(PyObject *cb_user, short order, int cb_type, int cb_subtype) { - EulerObject *self; - - self= (EulerObject *)PyObject_GC_New(VectorObject, &vector_Type); - - Py_INCREF(cb_user); - self->cb_user= cb_user; - self->cb_type= (unsigned char)cb_type; - self->cb_subtype= (unsigned char)cb_subtype; - ((BaseMathObject *)self)->data= NULL; /* incase of error */ - - if(newEulerObject_init(self, NULL, order, Py_NEW) == -1) { - Py_DECREF(self); - return NULL; + EulerObject *self= (EulerObject *)newEulerObject(NULL, order, Py_NEW, NULL); + if(self) { + Py_INCREF(cb_user); + self->cb_user= cb_user; + self->cb_type= (unsigned char)cb_type; + self->cb_subtype= (unsigned char)cb_subtype; } return (PyObject *)self; diff --git a/source/blender/python/generic/mathutils_Matrix.c b/source/blender/python/generic/mathutils_Matrix.c index a7d79d00860..07d4dc880c2 100644 --- a/source/blender/python/generic/mathutils_Matrix.c +++ b/source/blender/python/generic/mathutils_Matrix.c @@ -1820,96 +1820,76 @@ self->matrix[1][1] = self->contigPtr[4] */ (i.e. it was allocated elsewhere by MEM_mallocN()) pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON (i.e. it must be created here with PyMEM_malloc())*/ -static int newMatrixObject_init(MatrixObject *self, float *mat, const unsigned short rowSize, const unsigned short colSize, int type) +PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsigned short colSize, int type, PyTypeObject *base_type) { + MatrixObject *self; int x, row, col; /*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"); - return -1; + return NULL; } - self->row_size = rowSize; - self->col_size = colSize; + self= base_type ? (MatrixObject *)base_type->tp_alloc(base_type, 0) : + (MatrixObject *)PyObject_GC_New(MatrixObject, &matrix_Type); + + if(self) { + self->row_size = rowSize; + self->col_size = colSize; - if(type == Py_WRAP){ - self->contigPtr = mat; - /*pointer array points to contigous memory*/ - for(x = 0; x < rowSize; x++) { - self->matrix[x] = self->contigPtr + (x * colSize); - } - self->wrapped = Py_WRAP; - } - 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"); - return -1; - } - /*pointer array points to contigous memory*/ - for(x = 0; x < rowSize; x++) { - self->matrix[x] = self->contigPtr + (x * colSize); + /* init callbacks as NULL */ + self->cb_user= NULL; + self->cb_type= self->cb_subtype= 0; + + if(type == Py_WRAP){ + self->contigPtr = mat; + /*pointer array points to contigous memory*/ + for(x = 0; x < rowSize; x++) { + self->matrix[x] = self->contigPtr + (x * colSize); + } + self->wrapped = Py_WRAP; } - /*parse*/ - if(mat) { /*if a float array passed*/ - for(row = 0; row < rowSize; row++) { - for(col = 0; col < colSize; col++) { - self->matrix[row][col] = mat[(row * colSize) + col]; + 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"); + return NULL; + } + /*pointer array points to contigous memory*/ + for(x = 0; x < rowSize; x++) { + self->matrix[x] = self->contigPtr + (x * colSize); + } + /*parse*/ + if(mat) { /*if a float array passed*/ + for(row = 0; row < rowSize; row++) { + for(col = 0; col < colSize; col++) { + self->matrix[row][col] = mat[(row * colSize) + col]; + } } } + else if (rowSize == colSize ) { /*or if no arguments are passed return identity matrix for square matrices */ + PyObject *ret_dummy= Matrix_identity(self); + Py_DECREF(ret_dummy); + } + self->wrapped = Py_NEW; } - else if (rowSize == colSize ) { /*or if no arguments are passed return identity matrix for square matrices */ - PyObject *ret_dummy= Matrix_identity(self); - Py_DECREF(ret_dummy); + else { + PyErr_SetString(PyExc_RuntimeError, "Matrix(): invalid type"); + return NULL; } - self->wrapped = Py_NEW; - } - else { - PyErr_SetString(PyExc_RuntimeError, "invalid type"); - return -1; } - - return 0; -} - - -PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsigned short colSize, int type, PyTypeObject *base_type) -{ - MatrixObject *self; - - self= base_type ? (MatrixObject *)base_type->tp_alloc(base_type, 0) : - (MatrixObject *)PyObject_GC_New(MatrixObject, &matrix_Type); - - /* init callbacks as NULL */ - self->cb_user= NULL; - self->cb_type= self->cb_subtype= 0; - ((BaseMathObject *)self)->data= NULL; /* incase of error */ - - if(newMatrixObject_init(self, mat, rowSize, colSize, type) == -1) { - Py_DECREF(self); - return NULL; - } - - return (PyObject *)self; + return (PyObject *) self; } PyObject *newMatrixObject_cb(PyObject *cb_user, int rowSize, int colSize, int cb_type, int cb_subtype) { - MatrixObject *self; - - self= PyObject_GC_New(MatrixObject, &matrix_Type); - - Py_INCREF(cb_user); - self->cb_user= cb_user; - self->cb_type= (unsigned char)cb_type; - self->cb_subtype= (unsigned char)cb_subtype; - ((BaseMathObject *)self)->data= NULL; /* incase of error */ - - if(newMatrixObject_init(self, NULL, rowSize, colSize, Py_NEW) == -1) { - Py_DECREF(self); - return NULL; + MatrixObject *self= (MatrixObject *)newMatrixObject(NULL, rowSize, colSize, Py_NEW, NULL); + if(self) { + Py_INCREF(cb_user); + self->cb_user= cb_user; + self->cb_type= (unsigned char)cb_type; + self->cb_subtype= (unsigned char)cb_subtype; } - return (PyObject *) self; } diff --git a/source/blender/python/generic/mathutils_Quaternion.c b/source/blender/python/generic/mathutils_Quaternion.c index 1a9e37776ca..42c295c0d7e 100644 --- a/source/blender/python/generic/mathutils_Quaternion.c +++ b/source/blender/python/generic/mathutils_Quaternion.c @@ -1078,30 +1078,6 @@ PyTypeObject quaternion_Type = { (i.e. it was allocated elsewhere by MEM_mallocN()) pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON (i.e. it must be created here with PyMEM_malloc())*/ -static int newQuaternionObject_init(QuaternionObject *self, float *quat, int type) -{ - if(type == Py_WRAP){ - self->quat = quat; - self->wrapped = Py_WRAP; - } - else if (type == Py_NEW){ - self->quat = PyMem_Malloc(QUAT_SIZE * sizeof(float)); - if(quat) { - QUATCOPY(self->quat, quat); - } - else { - unit_qt(self->quat); - } - self->wrapped = Py_NEW; - } - else { - PyErr_SetString(PyExc_RuntimeError, "invalid type"); - return -1; - } - - return 0; -} - PyObject *newQuaternionObject(float *quat, int type, PyTypeObject *base_type) { QuaternionObject *self; @@ -1109,35 +1085,40 @@ PyObject *newQuaternionObject(float *quat, int type, PyTypeObject *base_type) self= base_type ? (QuaternionObject *)base_type->tp_alloc(base_type, 0) : (QuaternionObject *)PyObject_GC_New(QuaternionObject, &quaternion_Type); + if(self) { + /* init callbacks as NULL */ + self->cb_user= NULL; + self->cb_type= self->cb_subtype= 0; - /* init callbacks as NULL */ - self->cb_user= NULL; - self->cb_type= self->cb_subtype= 0; - ((BaseMathObject *)self)->data= NULL; /* incase of error */ - - if(newQuaternionObject_init(self, quat, type) == -1) { - Py_DECREF(self); - return NULL; + if(type == Py_WRAP){ + self->quat = quat; + self->wrapped = Py_WRAP; + } + else if (type == Py_NEW){ + self->quat = PyMem_Malloc(QUAT_SIZE * sizeof(float)); + if(!quat) { //new empty + unit_qt(self->quat); + }else{ + QUATCOPY(self->quat, quat); + } + self->wrapped = Py_NEW; + } + else{ + PyErr_SetString(PyExc_RuntimeError, "Quaternion(): invalid type"); + return NULL; + } } - return (PyObject *) self; } PyObject *newQuaternionObject_cb(PyObject *cb_user, int cb_type, int cb_subtype) { - QuaternionObject *self; - - self= PyObject_GC_New(QuaternionObject, &quaternion_Type); - - Py_INCREF(cb_user); - self->cb_user= cb_user; - self->cb_type= (unsigned char)cb_type; - self->cb_subtype= (unsigned char)cb_subtype; - ((BaseMathObject *)self)->data= NULL; /* incase of error */ - - if(newQuaternionObject_init(self, NULL, Py_NEW) == -1) { - Py_DECREF(self); - return NULL; + QuaternionObject *self= (QuaternionObject *)newQuaternionObject(NULL, Py_NEW, NULL); + if(self) { + Py_INCREF(cb_user); + self->cb_user= cb_user; + self->cb_type= (unsigned char)cb_type; + self->cb_subtype= (unsigned char)cb_subtype; } return (PyObject *)self; diff --git a/source/blender/python/generic/mathutils_Vector.c b/source/blender/python/generic/mathutils_Vector.c index 8d88feab80d..9408a61a368 100644 --- a/source/blender/python/generic/mathutils_Vector.c +++ b/source/blender/python/generic/mathutils_Vector.c @@ -2215,75 +2215,59 @@ PyTypeObject vector_Type = { (i.e. it was allocated elsewhere by MEM_mallocN()) pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON (i.e. it must be created here with PyMEM_malloc())*/ -static int newVectorObject_init(VectorObject *self, float *vec, const int size, const short type) +PyObject *newVectorObject(float *vec, const int size, const int type, PyTypeObject *base_type) { - if(size > 4 || size < 2) { - PyErr_SetString(PyExc_RuntimeError, "invalid size"); - return -1; - } - - self->size = size; + VectorObject *self; - if(type == Py_WRAP) { - self->vec = vec; - self->wrapped = Py_WRAP; - } - else if (type == Py_NEW) { - self->vec= PyMem_Malloc(size * sizeof(float)); - if(vec) { - memcpy(self->vec, vec, size * sizeof(float)); - } - else { /* new empty */ - fill_vn(self->vec, size, 0.0f); - if(size == 4) { /* do the homogenous thing */ - self->vec[3] = 1.0f; - } - } - self->wrapped = Py_NEW; - } - else { - PyErr_SetString(PyExc_RuntimeError, "invalid type"); - return -1; + if(size > 4 || size < 2) { + PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid size"); + return NULL; } - return 0; -} - - -PyObject *newVectorObject(float *vec, const int size, const short type, PyTypeObject *base_type) -{ - VectorObject *self; - self= base_type ? (VectorObject *)base_type->tp_alloc(base_type, 0) : (VectorObject *)PyObject_GC_New(VectorObject, &vector_Type); - self->cb_user= NULL; - self->cb_type= self->cb_subtype= 0; - ((BaseMathObject *)self)->data= NULL; /* incase of error */ + if(self) { + self->size = size; - if(newVectorObject_init(self, vec, size, type) == -1) { - Py_DECREF(self); - return NULL; - } + /* init callbacks as NULL */ + self->cb_user= NULL; + self->cb_type= self->cb_subtype= 0; - return (PyObject *)self; + if(type == Py_WRAP) { + self->vec = vec; + self->wrapped = Py_WRAP; + } + else if (type == Py_NEW) { + self->vec= PyMem_Malloc(size * sizeof(float)); + if(vec) { + memcpy(self->vec, vec, size * sizeof(float)); + } + else { /* new empty */ + fill_vn(self->vec, size, 0.0f); + if(size == 4) { /* do the homogenous thing */ + self->vec[3] = 1.0f; + } + } + self->wrapped = Py_NEW; + } + else { + PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid type"); + return NULL; + } + } + return (PyObject *) self; } PyObject *newVectorObject_cb(PyObject *cb_user, int size, int cb_type, int cb_subtype) { - VectorObject *self; - - self= PyObject_GC_New(VectorObject, &vector_Type); - - Py_INCREF(cb_user); - self->cb_user= cb_user; - self->cb_type= (unsigned char)cb_type; - self->cb_subtype= (unsigned char)cb_subtype; - ((BaseMathObject *)self)->data= NULL; /* incase of error */ - - if(newVectorObject_init(self, NULL, size, Py_NEW) == -1) { - Py_DECREF(self); - return NULL; + float dummy[4] = {0.0, 0.0, 0.0, 0.0}; /* dummy init vector, callbacks will be used on access */ + VectorObject *self= (VectorObject *)newVectorObject(dummy, size, Py_NEW, NULL); + if(self) { + Py_INCREF(cb_user); + self->cb_user= cb_user; + self->cb_type= (unsigned char)cb_type; + self->cb_subtype= (unsigned char)cb_subtype; } return (PyObject *)self; diff --git a/source/blender/python/generic/mathutils_Vector.h b/source/blender/python/generic/mathutils_Vector.h index db5dbcd4d96..4013a392ff9 100644 --- a/source/blender/python/generic/mathutils_Vector.h +++ b/source/blender/python/generic/mathutils_Vector.h @@ -41,7 +41,7 @@ typedef struct { } VectorObject; /*prototypes*/ -PyObject *newVectorObject(float *vec, const int size, const short type, PyTypeObject *base_type); +PyObject *newVectorObject(float *vec, const int size, const int type, PyTypeObject *base_type); PyObject *newVectorObject_cb(PyObject *user, int size, int callback_type, int subtype); #endif /* MATHUTILS_VECTOR_H */ |