support pythons cyclic garbage collector for mathutils types.

8 files changed, 261 insertions, 124 deletions

diff --git a/source/blender/python/generic/mathutils.c b/source/blender/python/generic/mathutils.c
index 1f802edcdea..7d56f1e0904 100644
--- a/source/blender/python/generic/mathutils.c
+++ b/source/blender/python/generic/mathutils.c
@@ -325,13 +325,30 @@ PyObject *BaseMathObject_getWrapped(BaseMathObject *self, void *UNUSED(closure))
 	return PyBool_FromLong((self->wrapped == Py_WRAP) ? 1:0);
 }
 
-void BaseMathObject_dealloc(BaseMathObject * self)
+int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg)
+{
+	Py_VISIT(self->cb_user);
+	return 0;
+}
+
+int BaseMathObject_clear(BaseMathObject *self)
+{
+	Py_CLEAR(self->cb_user);
+	return 0;
+}
+
+void BaseMathObject_dealloc(BaseMathObject *self)
 {
 	/* only free non wrapped */
-	if(self->wrapped != Py_WRAP)
-		PyMem_Free(self->data);
+	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);
+		}
+	}
+
+	BaseMathObject_clear(self);
 
-	Py_XDECREF(self->cb_user);
 	Py_TYPE(self)->tp_free(self); // PyObject_DEL(self); // breaks subtypes
 }
 
diff --git a/source/blender/python/generic/mathutils.h b/source/blender/python/generic/mathutils.h
index 8442b66a1db..d55e1c6e454 100644
--- a/source/blender/python/generic/mathutils.h
+++ b/source/blender/python/generic/mathutils.h
@@ -57,6 +57,10 @@ 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);
 
 PyMODINIT_FUNC BPyInit_mathutils(void);
diff --git a/source/blender/python/generic/mathutils_Color.c b/source/blender/python/generic/mathutils_Color.c
index 1c870ead438..a67ef94f1a3 100644
--- a/source/blender/python/generic/mathutils_Color.c
+++ b/source/blender/python/generic/mathutils_Color.c
@@ -475,10 +475,10 @@ PyTypeObject color_Type = {
 	NULL,							//tp_getattro
 	NULL,							//tp_setattro
 	NULL,							//tp_as_buffer
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, //tp_flags
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, //tp_flags
 	color_doc, //tp_doc
-	NULL,							//tp_traverse
-	NULL,							//tp_clear
+	(traverseproc)BaseMathObject_traverse,	//tp_traverse
+	(inquiry)BaseMathObject_clear,	//tp_clear
 	(richcmpfunc)Color_richcmpr,	//tp_richcompare
 	0,								//tp_weaklistoffset
 	NULL,							//tp_iter
@@ -509,31 +509,45 @@ 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())*/
-PyObject *newColorObject(float *col, int type, PyTypeObject *base_type)
+static int newColorObject_init(ColorObject *self, float *col, int type)
 {
-	ColorObject *self;
-
-	if(base_type)	self = (ColorObject *)base_type->tp_alloc(base_type, 0);
-	else			self = PyObject_NEW(ColorObject, &color_Type);
-
-	/* init callbacks as NULL */
-	self->cb_user= NULL;
-	self->cb_type= self->cb_subtype= 0;
-
-	if(type == Py_WRAP){
+	if(type == Py_WRAP) {
 		self->col = col;
 		self->wrapped = Py_WRAP;
 	}
-	else if (type == Py_NEW){
+	else if (type == Py_NEW) {
 		self->col = PyMem_Malloc(COLOR_SIZE * sizeof(float));
-		if(col)
+		if(col) {
 			copy_v3_v3(self->col, col);
-		else
+		}
+		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;
+
+	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(newColorObject_init(self, col, type) == -1) {
+		Py_DECREF(self);
 		return NULL;
 	}
 
@@ -542,12 +556,19 @@ PyObject *newColorObject(float *col, int type, PyTypeObject *base_type)
 
 PyObject *newColorObject_cb(PyObject *cb_user, int cb_type, int cb_subtype)
 {
-	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;
+	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;
 	}
 
 	return (PyObject *)self;
diff --git a/source/blender/python/generic/mathutils_Euler.c b/source/blender/python/generic/mathutils_Euler.c
index dd48df63e25..7dbc573fb83 100644
--- a/source/blender/python/generic/mathutils_Euler.c
+++ b/source/blender/python/generic/mathutils_Euler.c
@@ -608,10 +608,10 @@ PyTypeObject euler_Type = {
 	NULL,							//tp_getattro
 	NULL,							//tp_setattro
 	NULL,							//tp_as_buffer
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, //tp_flags
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, //tp_flags
 	euler_doc, //tp_doc
-	NULL,							//tp_traverse
-	NULL,							//tp_clear
+	(traverseproc)BaseMathObject_traverse,	//tp_traverse
+	(inquiry)BaseMathObject_clear,	//tp_clear
 	(richcmpfunc)Euler_richcmpr,	//tp_richcompare
 	0,								//tp_weaklistoffset
 	NULL,							//tp_iter
@@ -642,46 +642,67 @@ 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())*/
-PyObject *newEulerObject(float *eul, short order, int type, PyTypeObject *base_type)
+static int newEulerObject_init(EulerObject *self, float *eul, short order, int type)
 {
-	EulerObject *self;
-
-	if(base_type)	self = (EulerObject *)base_type->tp_alloc(base_type, 0);
-	else			self = PyObject_NEW(EulerObject, &euler_Type);
-
-	/* init callbacks as NULL */
-	self->cb_user= NULL;
-	self->cb_type= self->cb_subtype= 0;
-
 	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)
+		if(eul) {
 			copy_v3_v3(self->eul, eul);
-		else
+		}
+		else {
 			zero_v3(self->eul);
-
+		}
 		self->wrapped = Py_NEW;
 	}
 	else{
-		return NULL;
+		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;
+
+	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(newEulerObject_init(self, eul, order, type) == -1) {
+		Py_DECREF(self);
+		return NULL;
+	}
+
 	return (PyObject *)self;
 }
 
 PyObject *newEulerObject_cb(PyObject *cb_user, short order, int cb_type, int cb_subtype)
 {
-	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;
+	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;
 	}
 
 	return (PyObject *)self;
diff --git a/source/blender/python/generic/mathutils_Matrix.c b/source/blender/python/generic/mathutils_Matrix.c
index 87979af61b7..a7d79d00860 100644
--- a/source/blender/python/generic/mathutils_Matrix.c
+++ b/source/blender/python/generic/mathutils_Matrix.c
@@ -1775,10 +1775,10 @@ PyTypeObject matrix_Type = {
 	NULL,								/*tp_getattro*/
 	NULL,								/*tp_setattro*/
 	NULL,								/*tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
 	matrix_doc,							/*tp_doc*/
-	NULL,								/*tp_traverse*/
-	NULL,								/*tp_clear*/
+	(traverseproc)BaseMathObject_traverse,	//tp_traverse
+	(inquiry)BaseMathObject_clear,	//tp_clear
 	(richcmpfunc)Matrix_richcmpr,		/*tp_richcompare*/
 	0,									/*tp_weaklistoffset*/
 	NULL,								/*tp_iter*/
@@ -1820,27 +1820,19 @@ 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())*/
-PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsigned short colSize, int type, PyTypeObject *base_type)
+static int newMatrixObject_init(MatrixObject *self, float *mat, const unsigned short rowSize, const unsigned short colSize, int 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){
+	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 NULL;
+		return -1;
 	}
 
-	if(base_type)	self = (MatrixObject *)base_type->tp_alloc(base_type, 0);
-	else			self = PyObject_NEW(MatrixObject, &matrix_Type);
-
 	self->row_size = rowSize;
 	self->col_size = 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*/
@@ -1848,11 +1840,12 @@ PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsign
 			self->matrix[x] = self->contigPtr + (x * colSize);
 		}
 		self->wrapped = Py_WRAP;
-	}else if (type == Py_NEW){
+	}
+	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;
+			return -1;
 		}
 		/*pointer array points to contigous memory*/
 		for(x = 0; x < rowSize; x++) {
@@ -1865,25 +1858,58 @@ PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsign
 					self->matrix[row][col] = mat[(row * colSize) + col];
 				}
 			}
-		} else if (rowSize == colSize ) { /*or if no arguments are passed return identity matrix for square matrices */
+		}
+		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{ /*bad type*/
+	}
+	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= (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;
+	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;
 	}
+
 	return (PyObject *) self;
 }
diff --git a/source/blender/python/generic/mathutils_Quaternion.c b/source/blender/python/generic/mathutils_Quaternion.c
index 08b813ade16..1a9e37776ca 100644
--- a/source/blender/python/generic/mathutils_Quaternion.c
+++ b/source/blender/python/generic/mathutils_Quaternion.c
@@ -1044,10 +1044,10 @@ PyTypeObject quaternion_Type = {
 	NULL,								//tp_getattro
 	NULL,								//tp_setattro
 	NULL,								//tp_as_buffer
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, //tp_flags
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, //tp_flags
 	quaternion_doc, //tp_doc
-	NULL,								//tp_traverse
-	NULL,								//tp_clear
+	(traverseproc)BaseMathObject_traverse,	//tp_traverse
+	(inquiry)BaseMathObject_clear,	//tp_clear
 	(richcmpfunc)Quaternion_richcmpr,	//tp_richcompare
 	0,								//tp_weaklistoffset
 	NULL,								//tp_iter
@@ -1078,42 +1078,66 @@ 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;
 
-	if(base_type)	self = (QuaternionObject *)base_type->tp_alloc(base_type, 0);
-	else			self = PyObject_NEW(QuaternionObject, &quaternion_Type);
+	self= base_type ?	(QuaternionObject *)base_type->tp_alloc(base_type, 0) :
+						(QuaternionObject *)PyObject_GC_New(QuaternionObject, &quaternion_Type);
+
 
 	/* init callbacks as NULL */
 	self->cb_user= NULL;
 	self->cb_type= self->cb_subtype= 0;
+	((BaseMathObject *)self)->data= NULL; /* incase of error */
 
-	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{ //bad type
+	if(newQuaternionObject_init(self, quat, type) == -1) {
+		Py_DECREF(self);
 		return NULL;
 	}
+
 	return (PyObject *) self;
 }
 
 PyObject *newQuaternionObject_cb(PyObject *cb_user, int cb_type, int cb_subtype)
 {
-	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;
+	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;
 	}
 
 	return (PyObject *)self;
diff --git a/source/blender/python/generic/mathutils_Vector.c b/source/blender/python/generic/mathutils_Vector.c
index 0efd805697f..8d88feab80d 100644
--- a/source/blender/python/generic/mathutils_Vector.c
+++ b/source/blender/python/generic/mathutils_Vector.c
@@ -2162,14 +2162,15 @@ PyTypeObject vector_Type = {
 	NULL,                       /* PyBufferProcs *tp_as_buffer; */
 
   /*** Flags to define presence of optional/expanded features ***/
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, 
 	vector_doc,                       /*  char *tp_doc;  Documentation string */
   /*** Assigned meaning in release 2.0 ***/
+
 	/* call function for all accessible objects */
-	NULL,                       /* traverseproc tp_traverse; */
+	(traverseproc)BaseMathObject_traverse,	//tp_traverse
 
 	/* delete references to contained objects */
-	NULL,                       /* inquiry tp_clear; */
+	(inquiry)BaseMathObject_clear,	//tp_clear
 
   /***  Assigned meaning in release 2.1 ***/
   /*** rich comparisons ***/
@@ -2214,26 +2215,20 @@ 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())*/
-PyObject *newVectorObject(float *vec, const int size, const int type, PyTypeObject *base_type)
+static int newVectorObject_init(VectorObject *self, float *vec, const int size, const short type)
 {
-	VectorObject *self;
-
-	if(size > 4 || size < 2)
-		return NULL;
-
-	if(base_type)	self = (VectorObject *)base_type->tp_alloc(base_type, 0);
-	else			self = PyObject_NEW(VectorObject, &vector_Type);
+	if(size > 4 || size < 2) {
+		PyErr_SetString(PyExc_RuntimeError, "invalid size");
+		return -1;
+	}
 
 	self->size = size;
-	
-	/* init callbacks as NULL */
-	self->cb_user= NULL;
-	self->cb_type= self->cb_subtype= 0;
 
 	if(type == Py_WRAP) {
 		self->vec = vec;
 		self->wrapped = Py_WRAP;
-	} else if (type == Py_NEW) {
+	}
+	else if (type == Py_NEW) {
 		self->vec= PyMem_Malloc(size * sizeof(float));
 		if(vec) {
 			memcpy(self->vec, vec, size * sizeof(float));
@@ -2245,21 +2240,50 @@ PyObject *newVectorObject(float *vec, const int size, const int type, PyTypeObje
 			}
 		}
 		self->wrapped = Py_NEW;
-	}else{ /*bad type*/
+	}
+	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;
+
+	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(newVectorObject_init(self, vec, size, type) == -1) {
+		Py_DECREF(self);
 		return NULL;
 	}
-	return (PyObject *) self;
+
+	return (PyObject *)self;
 }
 
 PyObject *newVectorObject_cb(PyObject *cb_user, int size, int cb_type, int cb_subtype)
 {
-	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;
+	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;
 	}
 
 	return (PyObject *)self;
diff --git a/source/blender/python/generic/mathutils_Vector.h b/source/blender/python/generic/mathutils_Vector.h
index 4013a392ff9..db5dbcd4d96 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 int type, PyTypeObject *base_type);
+PyObject *newVectorObject(float *vec, const int size, const short type, PyTypeObject *base_type);
 PyObject *newVectorObject_cb(PyObject *user, int size, int callback_type, int subtype);
 
 #endif				/* MATHUTILS_VECTOR_H */