kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

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.

Browse Source
This commit is contained in:
Campbell Barton 2011-02-24 05:46:57 +00:00
parent b357033f5e
commit fbd9364944
8 changed files with 181 additions and 273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
source/blender/python/generic/mathutils.c
View File

@ -341,10 +341,7 @@ void BaseMathObject_dealloc(BaseMathObject *self)
{ {
/* only free non wrapped */ /* only free non wrapped */
if(self->wrapped != Py_WRAP) { if(self->wrapped != Py_WRAP) {
/* the ONLY time this should be NULL is when the value failed to initialize */ PyMem_Free(self->data);
if(self->data) {
PyMem_Free(self->data);
}
} }
BaseMathObject_clear(self); BaseMathObject_clear(self);

1
source/blender/python/generic/mathutils.h
View File

@ -58,7 +58,6 @@ typedef struct {
PyObject *BaseMathObject_getOwner( BaseMathObject * self, void * ); PyObject *BaseMathObject_getOwner( BaseMathObject * self, void * );
PyObject *BaseMathObject_getWrapped( BaseMathObject *self, void * ); PyObject *BaseMathObject_getWrapped( BaseMathObject *self, void * );
int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg); int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg);
int BaseMathObject_clear(BaseMathObject *self); int BaseMathObject_clear(BaseMathObject *self);
void BaseMathObject_dealloc(BaseMathObject * self); void BaseMathObject_dealloc(BaseMathObject * self);

72
source/blender/python/generic/mathutils_Color.c
View File

@ -509,31 +509,6 @@ PyTypeObject color_Type = {
(i.e. it was allocated elsewhere by MEM_mallocN()) (i.e. it was allocated elsewhere by MEM_mallocN())
pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
(i.e. it must be created here with PyMEM_malloc())*/ (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) PyObject *newColorObject(float *col, int type, PyTypeObject *base_type)
{ {
ColorObject *self; 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) : self= base_type ? (ColorObject *)base_type->tp_alloc(base_type, 0) :
(ColorObject *)PyObject_GC_New(ColorObject, &color_Type); (ColorObject *)PyObject_GC_New(ColorObject, &color_Type);
/* init callbacks as NULL */ if(self) {
self->cb_user= NULL; /* init callbacks as NULL */
self->cb_type= self->cb_subtype= 0; self->cb_user= NULL;
((BaseMathObject *)self)->data= NULL; /* incase of error */ self->cb_type= self->cb_subtype= 0;
if(newColorObject_init(self, col, type) == -1) { if(type == Py_WRAP){
Py_DECREF(self); self->col = col;
return NULL; 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; 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) PyObject *newColorObject_cb(PyObject *cb_user, int cb_type, int cb_subtype)
{ {
ColorObject *self; ColorObject *self= (ColorObject *)newColorObject(NULL, Py_NEW, NULL);
if(self) {
self= (ColorObject *)PyObject_GC_New(ColorObject, &color_Type); Py_INCREF(cb_user);
self->cb_user= cb_user;
Py_INCREF(cb_user); self->cb_type= (unsigned char)cb_type;
self->cb_user= cb_user; self->cb_subtype= (unsigned char)cb_subtype;
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;
} }
return (PyObject *)self; return (PyObject *)self;

77
source/blender/python/generic/mathutils_Euler.c
View File

@ -642,32 +642,6 @@ PyTypeObject euler_Type = {
(i.e. it was allocated elsewhere by MEM_mallocN()) (i.e. it was allocated elsewhere by MEM_mallocN())
pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
(i.e. it must be created here with PyMEM_malloc())*/ (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) PyObject *newEulerObject(float *eul, short order, int type, PyTypeObject *base_type)
{ {
EulerObject *self; 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) : self= base_type ? (EulerObject *)base_type->tp_alloc(base_type, 0) :
(EulerObject *)PyObject_GC_New(EulerObject, &euler_Type); (EulerObject *)PyObject_GC_New(EulerObject, &euler_Type);
/* init callbacks as NULL */ if(self) {
self->cb_user= NULL; /* init callbacks as NULL */
self->cb_type= self->cb_subtype= 0; self->cb_user= NULL;
((BaseMathObject *)self)->data= NULL; /* incase of error */ self->cb_type= self->cb_subtype= 0;
if(newEulerObject_init(self, eul, order, type) == -1) { if(type == Py_WRAP) {
Py_DECREF(self); self->eul = eul;
return NULL; 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; 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) PyObject *newEulerObject_cb(PyObject *cb_user, short order, int cb_type, int cb_subtype)
{ {
EulerObject *self; EulerObject *self= (EulerObject *)newEulerObject(NULL, order, Py_NEW, NULL);
if(self) {
self= (EulerObject *)PyObject_GC_New(VectorObject, &vector_Type); Py_INCREF(cb_user);
self->cb_user= cb_user;
Py_INCREF(cb_user); self->cb_type= (unsigned char)cb_type;
self->cb_user= cb_user; self->cb_subtype= (unsigned char)cb_subtype;
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;
} }
return (PyObject *)self; return (PyObject *)self;

126
source/blender/python/generic/mathutils_Matrix.c
View File

@ -1820,96 +1820,76 @@ self->matrix[1][1] = self->contigPtr[4] */
(i.e. it was allocated elsewhere by MEM_mallocN()) (i.e. it was allocated elsewhere by MEM_mallocN())
pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
(i.e. it must be created here with PyMEM_malloc())*/ (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; int x, row, col;
/*matrix objects can be any 2-4row x 2-4col matrix*/ /*matrix objects can be any 2-4row x 2-4col matrix*/
if(rowSize < 2 || rowSize > 4 || colSize < 2 || colSize > 4) { 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 -1; return NULL;
} }
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);
}
/*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 {
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) : self= base_type ? (MatrixObject *)base_type->tp_alloc(base_type, 0) :
(MatrixObject *)PyObject_GC_New(MatrixObject, &matrix_Type); (MatrixObject *)PyObject_GC_New(MatrixObject, &matrix_Type);
/* init callbacks as NULL */ if(self) {
self->cb_user= NULL; self->row_size = rowSize;
self->cb_type= self->cb_subtype= 0; self->col_size = colSize;
((BaseMathObject *)self)->data= NULL; /* incase of error */
if(newMatrixObject_init(self, mat, rowSize, colSize, type) == -1) { /* init callbacks as NULL */
Py_DECREF(self); self->cb_user= NULL;
return 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;
}
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 {
PyErr_SetString(PyExc_RuntimeError, "Matrix(): invalid type");
return NULL;
}
} }
return (PyObject *) self;
return (PyObject *)self;
} }
PyObject *newMatrixObject_cb(PyObject *cb_user, int rowSize, int colSize, int cb_type, int cb_subtype) PyObject *newMatrixObject_cb(PyObject *cb_user, int rowSize, int colSize, int cb_type, int cb_subtype)
{ {
MatrixObject *self; MatrixObject *self= (MatrixObject *)newMatrixObject(NULL, rowSize, colSize, Py_NEW, NULL);
if(self) {
self= PyObject_GC_New(MatrixObject, &matrix_Type); Py_INCREF(cb_user);
self->cb_user= cb_user;
Py_INCREF(cb_user); self->cb_type= (unsigned char)cb_type;
self->cb_user= cb_user; self->cb_subtype= (unsigned char)cb_subtype;
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;
} }
return (PyObject *) self; return (PyObject *) self;
} }

73
source/blender/python/generic/mathutils_Quaternion.c
View File

@ -1078,30 +1078,6 @@ PyTypeObject quaternion_Type = {
(i.e. it was allocated elsewhere by MEM_mallocN()) (i.e. it was allocated elsewhere by MEM_mallocN())
pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
(i.e. it must be created here with PyMEM_malloc())*/ (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) PyObject *newQuaternionObject(float *quat, int type, PyTypeObject *base_type)
{ {
QuaternionObject *self; 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) : self= base_type ? (QuaternionObject *)base_type->tp_alloc(base_type, 0) :
(QuaternionObject *)PyObject_GC_New(QuaternionObject, &quaternion_Type); (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 */ if(type == Py_WRAP){
self->cb_user= NULL; self->quat = quat;
self->cb_type= self->cb_subtype= 0; self->wrapped = Py_WRAP;
((BaseMathObject *)self)->data= NULL; /* incase of error */ }
else if (type == Py_NEW){
if(newQuaternionObject_init(self, quat, type) == -1) { self->quat = PyMem_Malloc(QUAT_SIZE * sizeof(float));
Py_DECREF(self); if(!quat) { //new empty
return NULL; 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; return (PyObject *) self;
} }
PyObject *newQuaternionObject_cb(PyObject *cb_user, int cb_type, int cb_subtype) PyObject *newQuaternionObject_cb(PyObject *cb_user, int cb_type, int cb_subtype)
{ {
QuaternionObject *self; QuaternionObject *self= (QuaternionObject *)newQuaternionObject(NULL, Py_NEW, NULL);
if(self) {
self= PyObject_GC_New(QuaternionObject, &quaternion_Type); Py_INCREF(cb_user);
self->cb_user= cb_user;
Py_INCREF(cb_user); self->cb_type= (unsigned char)cb_type;
self->cb_user= cb_user; self->cb_subtype= (unsigned char)cb_subtype;
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;
} }
return (PyObject *)self; return (PyObject *)self;

98
source/blender/python/generic/mathutils_Vector.c
View File

@ -2215,75 +2215,59 @@ PyTypeObject vector_Type = {
(i.e. it was allocated elsewhere by MEM_mallocN()) (i.e. it was allocated elsewhere by MEM_mallocN())
pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
(i.e. it must be created here with PyMEM_malloc())*/ (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;
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;
}
return 0;
}
PyObject *newVectorObject(float *vec, const int size, const short type, PyTypeObject *base_type)
{ {
VectorObject *self; VectorObject *self;
if(size > 4 || size < 2) {
PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid size");
return NULL;
}
self= base_type ? (VectorObject *)base_type->tp_alloc(base_type, 0) : self= base_type ? (VectorObject *)base_type->tp_alloc(base_type, 0) :
(VectorObject *)PyObject_GC_New(VectorObject, &vector_Type); (VectorObject *)PyObject_GC_New(VectorObject, &vector_Type);
self->cb_user= NULL; if(self) {
self->cb_type= self->cb_subtype= 0; self->size = size;
((BaseMathObject *)self)->data= NULL; /* incase of error */
if(newVectorObject_init(self, vec, size, type) == -1) { /* init callbacks as NULL */
Py_DECREF(self); self->cb_user= NULL;
return NULL; self->cb_type= self->cb_subtype= 0;
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;
return (PyObject *)self;
} }
PyObject *newVectorObject_cb(PyObject *cb_user, int size, int cb_type, int cb_subtype) PyObject *newVectorObject_cb(PyObject *cb_user, int size, int cb_type, int cb_subtype)
{ {
VectorObject *self; 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);
self= PyObject_GC_New(VectorObject, &vector_Type); if(self) {
Py_INCREF(cb_user);
Py_INCREF(cb_user); self->cb_user= cb_user;
self->cb_user= cb_user; self->cb_type= (unsigned char)cb_type;
self->cb_type= (unsigned char)cb_type; self->cb_subtype= (unsigned char)cb_subtype;
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;
} }
return (PyObject *)self; return (PyObject *)self;

2
source/blender/python/generic/mathutils_Vector.h
View File

@ -41,7 +41,7 @@ typedef struct {
} VectorObject; } VectorObject;
/*prototypes*/ /*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); PyObject *newVectorObject_cb(PyObject *user, int size, int callback_type, int subtype);
#endif /* MATHUTILS_VECTOR_H */ #endif /* MATHUTILS_VECTOR_H */