[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [19339] branches/soc-2008-mxcurioni/source /blender/freestyle/intern/python/BPy_Operators.cpp: Improvements in error handling at Python-C++ boundaries.
Tamito Kajiyama
rd6t-kjym at asahi-net.or.jp
Fri Mar 20 23:42:59 CET 2009
Revision: 19339
http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=19339
Author: kjym3
Date: 2009-03-20 23:42:59 +0100 (Fri, 20 Mar 2009)
Log Message:
-----------
Improvements in error handling at Python-C++ boundaries.
Also exported the Operators.chain() function.
Modified Paths:
--------------
branches/soc-2008-mxcurioni/source/blender/freestyle/intern/python/BPy_Operators.cpp
Modified: branches/soc-2008-mxcurioni/source/blender/freestyle/intern/python/BPy_Operators.cpp
===================================================================
--- branches/soc-2008-mxcurioni/source/blender/freestyle/intern/python/BPy_Operators.cpp 2009-03-20 22:41:27 UTC (rev 19338)
+++ branches/soc-2008-mxcurioni/source/blender/freestyle/intern/python/BPy_Operators.cpp 2009-03-20 22:42:59 UTC (rev 19339)
@@ -19,6 +19,7 @@
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 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 *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,25 +182,42 @@
{
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 {
+ 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;
+ }
- Operators::chain( *( ((BPy_ChainingIterator *) obj1)->c_it ),
- *( ((BPy_UnaryPredicate1D *) obj2)->up1D ),
- *( ((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void ) );
-
}
Py_RETURN_NONE;
@@ -202,21 +227,34 @@
{
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 ) {
+ } 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;
+ }
- Operators::bidirectionalChain( *( ((BPy_ChainingIterator *) obj1)->c_it ),
- *( ((BPy_UnaryPredicate1D *) obj2)->up1D ) );
-
}
Py_RETURN_NONE;
@@ -225,26 +263,44 @@
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;
+ 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;
+ }
- Operators::sequentialSplit( *( ((BPy_UnaryPredicate0D *) obj1)->up0D ), f );
-
}
Py_RETURN_NONE;
@@ -253,30 +309,55 @@
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;
+ }
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list