diff options
author | Tamito Kajiyama <rd6t-kjym@asahi-net.or.jp> | 2009-03-21 01:42:59 +0300 |
---|---|---|
committer | Tamito Kajiyama <rd6t-kjym@asahi-net.or.jp> | 2009-03-21 01:42:59 +0300 |
commit | 85291f0fea045beb4706d9a7b0174e2094c5b937 (patch) | |
tree | f7aa99293b44cdce02d907f92715eb2c0b8716d5 /source/blender/freestyle/intern/python | |
parent | 0c7e5323e891e5b32b4bfae58115137e805adfeb (diff) |
Improvements in error handling at Python-C++ boundaries.
Also exported the Operators.chain() function.
Diffstat (limited to 'source/blender/freestyle/intern/python')
-rw-r--r-- | source/blender/freestyle/intern/python/BPy_Operators.cpp | 236 |
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; } |