revert part of own commit r35117 which modified mathutils initialization functions...
authorCampbell Barton <ideasman42@gmail.com>
Thu, 24 Feb 2011 05:46:57 +0000 (05:46 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Thu, 24 Feb 2011 05:46:57 +0000 (05:46 +0000)
source/blender/python/generic/mathutils.c
source/blender/python/generic/mathutils.h
source/blender/python/generic/mathutils_Color.c
source/blender/python/generic/mathutils_Euler.c
source/blender/python/generic/mathutils_Matrix.c
source/blender/python/generic/mathutils_Quaternion.c
source/blender/python/generic/mathutils_Vector.c
source/blender/python/generic/mathutils_Vector.h

index 7d56f1e09048cabe9a569a35d82040997f57d377..b925dfc0d3271cde67f652a917d3a36e50f107b1 100644 (file)
@@ -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);
index d55e1c6e454a39a12b3ea9f78d779d10a2203d6c..7d0644b3c762d88c65d759479561e1394d850ebe 100644 (file)
@@ -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);
index a67ef94f1a38adc14b35029deb9e676adafc7357..047bda1b2c50e7fa913d8f4287eaf367a42126c9 100644 (file)
@@ -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;
index 7dbc573fb83996932e371f30c3ecc8538c4c36f3..95e7483d7be514f89fd94c11bd12d4fed08ffd6b 100644 (file)
@@ -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;
index a7d79d00860b960d1886ce64d8b97f3ca7eef670..07d4dc880c2fcb5c060e22a1340bbe5b497126c2 100644 (file)
@@ -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;
 }
index 1a9e37776ca9ac3246aac5d2a1fbecd0d5282a6e..42c295c0d7e562af29af262e06e18fb6e5290649 100644 (file)
@@ -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;
index 8d88feab80d7b2b326990310b08ecbe8ebf5fd67..9408a61a36852b6ec458e165414f16dc7848917f 100644 (file)
@@ -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;
index db5dbcd4d9615f2faf85dd2e91d9d2f7aeb68b32..4013a392ff99f147efe02a1c111665afa5431e1f 100644 (file)
@@ -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 */