Improvements in error handling at Python-C++ boundaries.

Also exported the Operators.chain() function.

1 files changed, 164 insertions, 72 deletions

diff --git a/source/blender/freestyle/intern/python/BPy_Operators.cpp b/source/blender/freestyle/intern/python/BPy_Operators.cpp
index c1b0b59daae..49bddcbf7c7 100644
--- a/source/blender/freestyle/intern/python/BPy_Operators.cpp
+++ b/source/blender/freestyle/intern/python/BPy_Operators.cpp
@@ -19,6 +19,7 @@ extern "C" {
 static void Operators___dealloc__(BPy_Operators *self);
 
 static PyObject * Operators_select(BPy_Operators* self, PyObject *args);
+static PyObject * Operators_chain(BPy_Operators* self, PyObject *args);
 static PyObject * Operators_bidirectionalChain(BPy_Operators* self, PyObject *args);
 static PyObject * Operators_sequentialSplit(BPy_Operators* self, PyObject *args);
 static PyObject * Operators_recursiveSplit(BPy_Operators* self, PyObject *args);
@@ -32,6 +33,8 @@ static PyObject * Operators_getStrokesSize( BPy_Operators* self);
 static PyMethodDef BPy_Operators_methods[] = {
 	{"select", ( PyCFunction ) Operators_select, METH_VARARGS | METH_STATIC, 
 	"select operator"},
+	{"chain", ( PyCFunction ) Operators_chain, METH_VARARGS | METH_STATIC,
+	 "chain operator"},
 	{"bidirectionalChain", ( PyCFunction ) Operators_bidirectionalChain, METH_VARARGS | METH_STATIC,
 	 "bidirectionalChain operator"},
 	{"sequentialSplit", ( PyCFunction ) Operators_sequentialSplit, METH_VARARGS | METH_STATIC,
@@ -157,13 +160,18 @@ PyObject * Operators_select(BPy_Operators* self, PyObject *args)
 {
 	PyObject *obj = 0;
 
-	if(!( 	PyArg_ParseTuple(args, "O", &obj) && 
-			BPy_UnaryPredicate1D_Check(obj) && ((BPy_UnaryPredicate1D *) obj)->up1D )) {
-		cout << "ERROR: Operators_select" << endl;
-		Py_RETURN_NONE;
+	if ( !PyArg_ParseTuple(args, "O!", &UnaryPredicate1D_Type, &obj) )
+		return NULL;
+	if ( !((BPy_UnaryPredicate1D *) obj)->up1D ) {
+		PyErr_SetString(PyExc_TypeError, "Operators.select(): 1st argument: invalid UnaryPredicate1D object");
+		return NULL;
 	}
 
-	Operators::select(*( ((BPy_UnaryPredicate1D *) obj)->up1D ));
+	if (Operators::select(*( ((BPy_UnaryPredicate1D *) obj)->up1D )) < 0) {
+		if (!PyErr_Occurred())
+			PyErr_SetString(PyExc_RuntimeError, "Operators.select() failed");
+		return NULL;
+	}
 
 	Py_RETURN_NONE;
 }
@@ -174,24 +182,41 @@ PyObject * Operators_chain(BPy_Operators* self, PyObject *args)
 {
 	PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0;
 
-	if(!( 	PyArg_ParseTuple(args, "OO|O", &obj1, &obj2, &obj3) && 
-			BPy_ChainingIterator_Check(obj1) && ((BPy_ChainingIterator *) obj1)->c_it &&
-			BPy_UnaryPredicate1D_Check(obj2) && ((BPy_UnaryPredicate1D *) obj2)->up1D )) {
-		cout << "ERROR: Operators_chain" << endl;
-		Py_RETURN_NONE;
+	if ( !PyArg_ParseTuple(args, "O!O!|O!", &ChainingIterator_Type, &obj1,
+										    &UnaryPredicate1D_Type, &obj2,
+										    &UnaryFunction1DVoid_Type, &obj3) )
+		return NULL;
+	if ( !((BPy_ChainingIterator *) obj1)->c_it ) {
+		PyErr_SetString(PyExc_TypeError, "Operators.chain(): 1st argument: invalid ChainingIterator object");
+		return NULL;
+	}
+	if ( !((BPy_UnaryPredicate1D *) obj2)->up1D ) {
+		PyErr_SetString(PyExc_TypeError, "Operators.chain(): 2nd argument: invalid UnaryPredicate1D object");
+		return NULL;
 	}
 
 	if( !obj3 ) {
 		
-		Operators::chain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ),
-							*( ((BPy_UnaryPredicate1D *) obj2)->up1D )  );
+		if (Operators::chain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ),
+								*( ((BPy_UnaryPredicate1D *) obj2)->up1D )  ) < 0) {
+			if (!PyErr_Occurred())
+				PyErr_SetString(PyExc_RuntimeError, "Operators.chain() failed");
+			return NULL;
+		}
 							
-	} else if( BPy_UnaryFunction1DVoid_Check(obj3) && ((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void ) {
-		
+	} else {
 		
-		Operators::chain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ),
-							*( ((BPy_UnaryPredicate1D *) obj2)->up1D ),
-							*( ((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void )  );
+		if ( !((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void ) {
+			PyErr_SetString(PyExc_TypeError, "Operators.chain(): 3rd argument: invalid UnaryFunction1DVoid object");
+			return NULL;
+		}
+		if (Operators::chain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ),
+								*( ((BPy_UnaryPredicate1D *) obj2)->up1D ),
+								*( ((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void )  ) < 0) {
+			if (!PyErr_Occurred())
+				PyErr_SetString(PyExc_RuntimeError, "Operators.chain() failed");
+			return NULL;
+		}
 		
 	}
 	
@@ -202,20 +227,33 @@ PyObject * Operators_bidirectionalChain(BPy_Operators* self, PyObject *args)
 {
 	PyObject *obj1 = 0, *obj2 = 0;
 
-	if(!( 	PyArg_ParseTuple(args, "O|O", &obj1, &obj2) && 
-			BPy_ChainingIterator_Check(obj1) && ((BPy_ChainingIterator *) obj1)->c_it )) {
-		cout << "ERROR: Operators_bidirectionalChain" << endl;
-		Py_RETURN_NONE;
+	if( !PyArg_ParseTuple(args, "O!|O!", &ChainingIterator_Type, &obj1, &UnaryPredicate1D_Type, &obj2) )
+		return NULL;
+	if ( !((BPy_ChainingIterator *) obj1)->c_it ) {
+		PyErr_SetString(PyExc_TypeError, "Operators.bidirectionalChain(): 1st argument: invalid ChainingIterator object");
+		return NULL;
 	}
-	
+
 	if( !obj2 ) {
 
-		Operators::bidirectionalChain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ) );
+		if (Operators::bidirectionalChain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ) ) < 0) {
+			if (!PyErr_Occurred())
+				PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectionalChain() failed");
+			return NULL;
+		}
 							
-	} else if( BPy_UnaryPredicate1D_Check(obj2) && ((BPy_UnaryPredicate1D *) obj2)->up1D ) {
-		
-		Operators::bidirectionalChain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ),
-										*( ((BPy_UnaryPredicate1D *) obj2)->up1D )  );
+	} else {
+
+		if ( !((BPy_UnaryPredicate1D *) obj2)->up1D ) {
+			PyErr_SetString(PyExc_TypeError, "Operators.bidirectionalChain(): 2nd argument: invalid UnaryPredicate1D object");
+			return NULL;
+		}
+		if (Operators::bidirectionalChain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ),
+											*( ((BPy_UnaryPredicate1D *) obj2)->up1D ) ) < 0) {
+			if (!PyErr_Occurred())
+				PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectionalChain() failed");
+			return NULL;
+		}
 		
 	}
 	
@@ -225,25 +263,43 @@ PyObject * Operators_bidirectionalChain(BPy_Operators* self, PyObject *args)
 PyObject * Operators_sequentialSplit(BPy_Operators* self, PyObject *args)
 {
 	PyObject *obj1 = 0, *obj2 = 0;
-	float f3 = 0.0;
+	float f = 0.0;
 
-	if(!( 	PyArg_ParseTuple(args, "O|Of", &obj1, &obj2, &f3) && 
-			BPy_UnaryPredicate0D_Check(obj1) && ((BPy_UnaryPredicate0D *) obj1)->up0D )) {
-		cout << "ERROR: Operators_sequentialSplit" << endl;
-		Py_RETURN_NONE;
+	if( !PyArg_ParseTuple(args, "O!|Of", &UnaryPredicate0D_Type, &obj1, &obj2, &f) )
+		return NULL;
+	if ( !((BPy_UnaryPredicate0D *) obj1)->up0D ) {
+		PyErr_SetString(PyExc_TypeError, "Operators.sequentialSplit(): 1st argument: invalid UnaryPredicate0D object");
+		return NULL;
 	}
-	
+
 	if( obj2 && BPy_UnaryPredicate0D_Check(obj2) ) {
 		
-		Operators::sequentialSplit( 	*( ((BPy_UnaryPredicate0D *) obj1)->up0D ),
+		if ( !((BPy_UnaryPredicate0D *) obj2)->up0D ) {
+			PyErr_SetString(PyExc_TypeError, "Operators.sequentialSplit(): 2nd argument: invalid UnaryPredicate0D object");
+			return NULL;
+		}
+		if (Operators::sequentialSplit(	*( ((BPy_UnaryPredicate0D *) obj1)->up0D ),
 										*( ((BPy_UnaryPredicate0D *) obj2)->up0D ),
-										f3 );
-			
+										f ) < 0) {
+			if (!PyErr_Occurred())
+				PyErr_SetString(PyExc_RuntimeError, "Operators.sequentialSplit() failed");
+			return NULL;
+		}
+
 	} else {
 		
-		float f = ( obj2 && PyFloat_Check(obj2) ) ? PyFloat_AsDouble(obj2) : 0.0;
-		
-		Operators::sequentialSplit( *( ((BPy_UnaryPredicate0D *) obj1)->up0D ), f );
+		if ( obj2 ) {
+			if ( !PyFloat_Check(obj2) ) {
+				PyErr_SetString(PyExc_TypeError, "Operators.sequentialSplit(): invalid 2nd argument");
+				return NULL;
+			}
+			f = PyFloat_AsDouble(obj2);
+		}
+		if (Operators::sequentialSplit( *( ((BPy_UnaryPredicate0D *) obj1)->up0D ), f ) < 0) {
+			if (!PyErr_Occurred())
+				PyErr_SetString(PyExc_RuntimeError, "Operators.sequentialSplit() failed");
+			return NULL;
+		}
 		
 	}
 	
@@ -253,29 +309,54 @@ PyObject * Operators_sequentialSplit(BPy_Operators* self, PyObject *args)
 PyObject * Operators_recursiveSplit(BPy_Operators* self, PyObject *args)
 {
 	PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0;
-	float f4 = 0.0;
+	float f = 0.0;
 
-	if(!( 	PyArg_ParseTuple(args, "OO|Of", &obj1, &obj2, &obj3, &f4) && 
-			BPy_UnaryFunction0DDouble_Check(obj1) && ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double )) {
-		cout << "ERROR: Operators_recursiveSplit" << endl;
-		Py_RETURN_NONE;
+	if ( !PyArg_ParseTuple(args, "O!O|Of", &UnaryFunction0DDouble_Type, &obj1, &obj2, &obj3, &f) )
+		return NULL;
+	if ( !((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ) {
+		PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): 1st argument: invalid UnaryFunction0DDouble object");
+		return NULL;
 	}
 	
-	if( BPy_UnaryPredicate1D_Check(obj2) && ((BPy_UnaryPredicate1D *) obj2)->up1D ) {
-		
-		float f = ( obj3 && PyFloat_Check(obj3) ) ? PyFloat_AsDouble(obj3) : 0.0;
-				
-		Operators::recursiveSplit( 	*( ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ),
-									*( ((BPy_UnaryPredicate1D *) obj2)->up1D ),
-									f );
+	if ( BPy_UnaryPredicate1D_Check(obj2) ) {
+
+		if ( !((BPy_UnaryPredicate1D *) obj2)->up1D ) {
+			PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): 2nd argument: invalid UnaryPredicate1D object");
+			return NULL;
+		}
+		if ( obj3 ) {
+			if ( !PyFloat_Check(obj3) ) {
+				PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): invalid 3rd argument");
+				return NULL;
+			}
+			f = PyFloat_AsDouble(obj3);
+		}
+		if (Operators::recursiveSplit( 	*( ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ),
+										*( ((BPy_UnaryPredicate1D *) obj2)->up1D ),
+										f ) < 0) {
+			if (!PyErr_Occurred())
+				PyErr_SetString(PyExc_RuntimeError, "Operators.recursiveSplit() failed");
+			return NULL;
+		}
 	
-	} else if(	BPy_UnaryPredicate0D_Check(obj2) && ((BPy_UnaryPredicate0D *) obj2)->up0D &&
-				BPy_UnaryPredicate1D_Check(obj3) && ((BPy_UnaryPredicate1D *) obj3)->up1D    ) {
-		
-		Operators::recursiveSplit( 	*( ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ),
-									*( ((BPy_UnaryPredicate0D *) obj2)->up0D ),
-									*( ((BPy_UnaryPredicate1D *) obj3)->up1D ),
-									f4 );
+	} else {
+
+		if ( !BPy_UnaryPredicate0D_Check(obj2) || !((BPy_UnaryPredicate0D *) obj2)->up0D ) {
+			PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): invalid 2nd argument");
+			return NULL;
+		}
+		if ( !BPy_UnaryPredicate1D_Check(obj3) || !((BPy_UnaryPredicate1D *) obj3)->up1D ) {
+			PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): invalid 3rd argument");
+			return NULL;
+		}
+		if (Operators::recursiveSplit( 	*( ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ),
+										*( ((BPy_UnaryPredicate0D *) obj2)->up0D ),
+										*( ((BPy_UnaryPredicate1D *) obj3)->up1D ),
+										f ) < 0) {
+			if (!PyErr_Occurred())
+				PyErr_SetString(PyExc_RuntimeError, "Operators.recursiveSplit() failed");
+			return NULL;
+		}
 
 	}
 	
@@ -286,14 +367,18 @@ PyObject * Operators_sort(BPy_Operators* self, PyObject *args)
 {
 	PyObject *obj = 0;
 
-	if(!( 	PyArg_ParseTuple(args, "O", &obj) && 
-			BPy_BinaryPredicate1D_Check(obj) && ((BPy_BinaryPredicate1D *) obj)->bp1D )) {
-		cout << "ERROR: Operators_sort" << endl;
-		Py_RETURN_NONE;
+	if ( !PyArg_ParseTuple(args, "O!", &BinaryPredicate1D_Type, &obj) )
+		return NULL;
+	if ( !((BPy_BinaryPredicate1D *) obj)->bp1D ) {
+		PyErr_SetString(PyExc_TypeError, "Operators.sort(): 1st argument: invalid BinaryPredicate1D object");
+		return NULL;
 	}
 
-	Operators::sort(*( ((BPy_BinaryPredicate1D *) obj)->bp1D ));
-
+	if (Operators::sort(*( ((BPy_BinaryPredicate1D *) obj)->bp1D )) < 0) {
+		if (!PyErr_Occurred())
+			PyErr_SetString(PyExc_RuntimeError, "Operators.sort() failed");
+		return NULL;
+	}
 	Py_RETURN_NONE;
 }
 
@@ -301,22 +386,29 @@ PyObject * Operators_create(BPy_Operators* self, PyObject *args)
 {
 	PyObject *obj1 = 0, *obj2 = 0;
 
-	if(!( 	PyArg_ParseTuple(args, "OO", &obj1, &obj2) && 
-			BPy_UnaryPredicate1D_Check(obj1) && ((BPy_UnaryPredicate1D *) obj1)->up1D &&
-			PyList_Check(obj2) && PyList_Size(obj2) > 0   )) {
-		cout << "ERROR: Operators_create" << endl;
-		Py_RETURN_NONE;
+	if ( !PyArg_ParseTuple(args, "O!O!", &UnaryPredicate1D_Type, &obj1, &PyList_Type, &obj2) )
+		return NULL;
+	if ( !((BPy_UnaryPredicate1D *) obj1)->up1D ) {
+		PyErr_SetString(PyExc_TypeError, "Operators.create(): 1st argument: invalid UnaryPredicate1D object");
+		return NULL;
 	}
 
 	vector<StrokeShader *> shaders;
 	for( int i = 0; i < PyList_Size(obj2); i++) {
 		PyObject *py_ss = PyList_GetItem(obj2,i);
 		
-		if( BPy_StrokeShader_Check(py_ss) )	
-			shaders.push_back( ((BPy_StrokeShader *) py_ss)->ss );
+		if ( !BPy_StrokeShader_Check(py_ss) ) {
+			PyErr_SetString(PyExc_TypeError, "Operators.create() 2nd argument must be a list of StrokeShader objects");
+			return NULL;
+		}
+		shaders.push_back( ((BPy_StrokeShader *) py_ss)->ss );
 	}
 	
-	Operators::create( *( ((BPy_UnaryPredicate1D *) obj1)->up1D ), shaders);
+	if (Operators::create( *( ((BPy_UnaryPredicate1D *) obj1)->up1D ), shaders) < 0) {
+		if (!PyErr_Occurred())
+			PyErr_SetString(PyExc_RuntimeError, "Operators.create() failed");
+		return NULL;
+	}
 
 	Py_RETURN_NONE;
 }