X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FGraphExecutor%2FDataFlowExecutor_PyDynInvoke.cxx;h=2c33cd87edd8040e6b2a1ee33cc2bd6c6fe4218a;hb=dad24b20fb0b0c18474caa7cb5b94652408b6743;hp=03fe20f43cec906a4eb7614d2ff8d994e70a3386;hpb=1cbaac50370d660382c7c00c94a1ec13741a4e3a;p=modules%2Fsuperv.git

diff --git a/src/GraphExecutor/DataFlowExecutor_PyDynInvoke.cxx b/src/GraphExecutor/DataFlowExecutor_PyDynInvoke.cxx
index 03fe20f..2c33cd8 100644
--- a/src/GraphExecutor/DataFlowExecutor_PyDynInvoke.cxx
+++ b/src/GraphExecutor/DataFlowExecutor_PyDynInvoke.cxx
@@ -15,9 +15,13 @@ using namespace std;
 #include <map>
 
 #include "DataFlowExecutor_InNode.hxx"
+#include "DataFlowExecutor_OutNode.hxx"
 
 using namespace CORBA ;
 
+extern GraphExecutor::FiniteStateMachine * theAutomaton ;
+
+//static PyObject * MyPyObjSignal = NULL ;
 static PyObject * MyPyObjRef = NULL ;
 static PyObject * MyPyObjIor = NULL ;
 static PyObject * MyPyRunMethod = NULL ;
@@ -34,32 +38,59 @@ bool GraphExecutor::InNode::InitPython() {
 //  PyObject * Module = Py_InitModule( "InitPyRunMethod" , MethodPyRunMethod ) ;
   if ( !Automaton()->PyInitModule() ) {
     Py_InitModule( "InitPyRunMethod" , MethodPyRunMethod ) ;
+    // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL    
+    //_OutNode->SuperVisionContainer()->ActivatePythonExecution( "InitPyRunMethod" , MethodPyRunMethod ) ;
   }
 //  PyObject * Dictionnary = PyModule_GetDict( Module ) ;
 //  InitPyDynInvokeError = PyErr_NewException( "InitPyDynInvokeError" , NULL , NULL ) ;
 //  PyDict_SetItemString( Dictionnary , InitPyDynInvokeError ) ;
   cdebug << ThreadNo() << "Py_Initialized() " << endl ;
 
+#if 0
+//JR : Python documentation says that there is no sense to set a handler of synchronous
+// signals as SIGSEGV and SIGFPE !!!
+  if ( Automaton()->PyFunction( "PyObjSignal" ) == NULL ) {
+    string aPyFunc ;
+    aPyFunc = "import signal\n" ;
+    aPyFunc += "import InitPyRunMethod\n" ;
+    aPyFunc += "import sys\n" ;
+    aPyFunc += "import CORBA\n" ;
+    aPyFunc += "import omniORB\n" ;
+    aPyFunc += "def PySignalHandler( aSignal , aStackFrame ) :\n" ;
+    aPyFunc += "    print 'PySignalHandler(aSignal =',aSignal,',aStackFrame= ',aStackFrame,')'\n" ;
+    aPyFunc += "InitPyRunMethod.RunMethod( PySignalHandler )\n" ;
+    aPyFunc += "PrevHandler = signal.signal( signal.SIGSEGV , PySignalHandler )\n" ;
+    aPyFunc += "print 'PyObjSignal PrevHandler of SIGSEGV :', PrevHandler\n" ;
+    aPyFunc += "print 'PyObjSignal actual handler of SIGSEGV :', signal.getsignal( signal.SIGSEGV  )\n" ;
+//    if ( PyRun_SimpleString( (char *) aPyFunc.c_str() ) ) {
+    if ( PyRunSimpleString( (char *) aPyFunc.c_str() ) ) {
+      cdebug << ThreadNo() << " " << Name() << " PyRun_SimpleString ERROR " << endl << aPyFunc << endl ;
+      Automaton()->PyUnLock() ;
+      return false ;
+    }
+    MyPyObjSignal = MyPyRunMethod ;
+    Automaton()->PyFunction( "PyObjSignal" , MyPyObjSignal ) ;
+  }
+  else {
+    MyPyObjSignal = Automaton()->PyFunction( "PyObjSignal" ) ;
+  }
+#endif
+
+// PyObjRef convert an IOR (string) to an Python ObjectReference
   if ( Automaton()->PyFunction( "PyObjRef" ) == NULL ) {
     string aPyFunc ;
-//    aPyFunc = "print 'InitPyRunMethod'\n" ;
     aPyFunc = "import InitPyRunMethod\n" ;
-//    aPyFunc += "print 'sys'\n" ;
     aPyFunc += "import sys\n" ;
-//    aPyFunc += "print 'CORBA'\n" ;
     aPyFunc += "import CORBA\n" ;
-//    aPyFunc += "print 'omniORB'\n" ;
     aPyFunc += "import omniORB\n" ;
-//    aPyFunc += "print 'PyObjRef'\n" ;
     aPyFunc += "def PyObjRef( IORObjStr ) :\n" ;
-//    aPyFunc += "    print 'PyObjRef',IORObjStr\n" ;
     aPyFunc += "    orb = CORBA.ORB_init( sys.argv , CORBA.ORB_ID )\n" ;
-//    aPyFunc += "    print 'PyObjRef orb',orb\n" ;
     aPyFunc += "    objref = orb.string_to_object( IORObjStr )\n" ;
-//    aPyFunc += "    print 'PyObjRef IORObjStr objref',IORObjStr,objref\n" ;
     aPyFunc += "    return objref\n" ;
     aPyFunc += "InitPyRunMethod.RunMethod( PyObjRef )\n" ;
     if ( PyRun_SimpleString( (char *) aPyFunc.c_str() ) ) {
+    // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL
+    //if ( PyRunSimpleString( (char *) aPyFunc.c_str() ) ) {
       cdebug << ThreadNo() << " " << Name() << " PyRun_SimpleString ERROR " << endl << aPyFunc << endl ;
       Automaton()->PyUnLock() ;
       return false ;
@@ -71,6 +102,7 @@ bool GraphExecutor::InNode::InitPython() {
     MyPyObjRef = Automaton()->PyFunction( "PyObjRef" ) ;
   }
 
+// PyObjRef convert an Python ObjectReference to an IOR (string)
   if ( Automaton()->PyFunction( "PyObjIor" ) == NULL ) {
     string aPyFunc ;
     aPyFunc = "import InitPyRunMethod\n" ;
@@ -78,14 +110,13 @@ bool GraphExecutor::InNode::InitPython() {
     aPyFunc += "import CORBA\n" ;
     aPyFunc += "import omniORB\n" ;
     aPyFunc += "def PyObjIor( ObjRef ) :\n" ;
-//    aPyFunc += "    print 'PyObjIor',ObjRef\n" ;
     aPyFunc += "    orb = CORBA.ORB_init( sys.argv , CORBA.ORB_ID )\n" ;
-//    aPyFunc += "    print 'PyObjIor orb',orb\n" ;
     aPyFunc += "    objIor = orb.object_to_string( ObjRef )\n" ;
-//    aPyFunc += "    print 'PyObjIor ObjRef objIor',ObjRef,objIor\n" ;
     aPyFunc += "    return objIor\n" ;
     aPyFunc += "InitPyRunMethod.RunMethod( PyObjIor )\n" ;
     if ( PyRun_SimpleString( (char *) aPyFunc.c_str() ) ) {
+    // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL
+    //if ( PyRunSimpleString( (char *) aPyFunc.c_str() ) ) {
       cdebug << ThreadNo() << " " << Name() << " PyRun_SimpleString ERROR " << endl << aPyFunc << endl ;
       Automaton()->PyUnLock() ;
       return false ;
@@ -103,9 +134,22 @@ bool GraphExecutor::InNode::InitPython() {
   return true ;
 }
 
+void GraphExecutor::InNode::RemovePyDynInvoke( char * PyFuncName ) {
+//  Automaton()->PyLock() ; // Already done ...
+  if ( Automaton()->ErasePyFunction( PyFuncName ) ) {
+    cdebug << "InNode::RemovePyDynInvoke( " << PyFuncName << " ) success" << endl ;
+  }
+  else {
+    cdebug << "InNode::RemovePyDynInvoke( " << PyFuncName << " ) ERROR failed" << endl ;
+  }
+//  Automaton()->PyUnLock() ;
+}
+
 PyObject * GraphExecutor::InNode::InitPyDynInvoke( char * PyFuncName ,
-                                                   const SUPERV::ListOfStrings * aPythonFunction ) {
+                                                   const SUPERV::ListOfStrings * aPythonFunction ,
+                                                   bool & Err ) {
   bool RetVal = true ;
+  Err = false ;
   string aPyFunc ;
   PyObject * thePyRunMethod = NULL ;
 
@@ -126,16 +170,19 @@ PyObject * GraphExecutor::InNode::InitPyDynInvoke( char * PyFuncName ,
         aPyFunc += PyFuncName ;
         aPyFunc += " )\n" ;
         /*cdebug *///cout<< "InitPyDynInvoke PyRun_SimpleString " << endl << aPyFunc << endl ;
-        if ( PyRun_SimpleString( (char *) aPyFunc.c_str() ) ) {
-          cdebug << ThreadNo() << " " << Name() << " PyRun_SimpleString ERROR " << endl << aPyFunc << endl ;
+//        if ( PyRun_SimpleString( (char *) aPyFunc.c_str() ) ) {
+        if ( PyRunSimpleString( (char *) aPyFunc.c_str() ) ) {
+          cdebug << ThreadNo() << " " << Name() << " PyRunSimpleString ERROR " << endl << aPyFunc << endl ;
+	  PyFuncRunned( false ) ;
           RetVal = false ;
+          Err = true ;
         }
         else {
 	  PyFuncRunned( true ) ;
           thePyRunMethod = MyPyRunMethod ;
 	  
           Automaton()->PyFunction( PyFuncName , thePyRunMethod ) ;
-          cdebug << ThreadNo() << "PyRun_SimpleString( " << (*aPythonFunction)[ 0 ] << " ) " << endl ;
+          cdebug << ThreadNo() << "PyRunSimpleString( " << (*aPythonFunction)[ 0 ] << " ) " << endl ;
         }
       }
       if ( RetVal ) {
@@ -154,7 +201,7 @@ PyObject * GraphExecutor::InNode::InitPyDynInvoke( char * PyFuncName ,
     Automaton()->PyUnLock() ;
   }
 
-  cdebug_out << "InitPyDynInvoke '" << PyFuncName << "' thePyRunMethod Null" << endl ;
+  cdebug_out << "InitPyDynInvoke '" << PyFuncName << "' thePyRunMethod Null Err " << Err << endl ;
   
   return NULL ;
 }
@@ -178,25 +225,34 @@ extern "C" PyObject * PyRunMethod( PyObject * dummy , PyObject * Args ) {
   return Result ;
 }
 
+#define PyDynInvokeTrace 1
 bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
 		                         const char *method , 
-		                         ServicesAnyData * inParams , int nInParams ,
-		                         ServicesAnyData * outParams , int nOutParams ) {
+		                         ServicesAnyData * InParametersList , int nInParams ,
+		                         ServicesAnyData * OutParametersList , int nOutParams ) {
   int i ;
 
   bool RetVal = true ;
 
-  int n_in  = nInParams ;
-  int n_out = nOutParams ;
   const char * sname;
 
-  cdebug_in << ThreadNo() << "GraphExecutor::InNode::PyDynInvoke Node " << Name() << " method " << method
-            << " " << n_in << " InArgs " << n_out << " OutArgs MyPyRunMethod " ;
+#if PyDynInvokeTrace
+  cdebug_in << ThreadNo() << "GraphExecutor::InNode::PyDynInvoke Node " << Name()
+            << " method " << method
+            << " InParametersList " << InParametersList
+            << " OutParametersList " << OutParametersList 
+            << " " << nInParams << " InArgs " << nOutParams
+            << " OutArgs MyPyRunMethod " ;
+#endif
   if ( MyPyRunMethod ) {
+#if PyDynInvokeTrace
     cdebug << MyPyRunMethod << " " << MyPyRunMethod->ob_refcnt << endl ;
+#endif
   }
   else {
+#if PyDynInvokeTrace
     cdebug << " NULL" << endl ;
+#endif
     return false ;
   }
 
@@ -211,6 +267,7 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
   PyObject * ResultIor = NULL ;
 
   CORBA::Object_ptr ObjRef ;
+
   char * IORObjRef ;
 
   if ( !PyCallable_Check( MyPyRunMethod ) ) {
@@ -218,80 +275,98 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
     RetVal = false ;
   }
   else {
-    ArgsList = PyTuple_New( n_in ) ;
+    ArgsList = PyTuple_New( nInParams ) ;
 
-    for ( i = 0 ; i < n_in ; i++ ) {
-      data = inParams[i].Value ;
-      sname = inParams[i].Name.c_str() ;
+    for ( i = 0 ; i < nInParams ; i++ ) {
+      data = InParametersList[i].Value ;
+      sname = InParametersList[i].Name.c_str() ;
       switch ( data.type()->kind() ) {
       case CORBA::tk_string : {
         char * t ;
         data >>= t ;
-        ArgValue = Py_BuildValue( "s" , t ) ;
+        PyObject * ArgValue = Py_BuildValue( "s" , t ) ;
         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
+#if PyDynInvokeTrace
         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << t << " (string) "
                << " ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
                << ArgValue->ob_refcnt << endl ;
+#endif
         break ;
       }
       case CORBA::tk_boolean : {
         bool b ;
         data >>= (CORBA::Any::to_boolean ) b ;
-        ArgValue = Py_BuildValue( "b" , b ) ;
+        PyObject * ArgValue = Py_BuildValue( "b" , b ) ;
         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
+#if PyDynInvokeTrace
         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << b
                << " (boolean) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
                << ArgValue->ob_refcnt << endl ;
+#endif
         break ;
       }
       case CORBA::tk_char : {
         unsigned char c ;
         data >>= (CORBA::Any::to_char ) c ;
-        ArgValue = Py_BuildValue( "c" , c ) ;
+        PyObject * ArgValue = Py_BuildValue( "c" , c ) ;
         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
+#if PyDynInvokeTrace
         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << c
                << " (char) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
                << ArgValue->ob_refcnt << endl ;
+#endif
         break ;
       }
       case CORBA::tk_short : {
         short s ;
         data >>= s ;
-        ArgValue = Py_BuildValue( "h" , s ) ;
+        PyObject * ArgValue = Py_BuildValue( "h" , s ) ;
         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
+#if PyDynInvokeTrace
         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << s
                << " (short) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
                << ArgValue->ob_refcnt << endl ;
+#endif
         break ;
       }
       case CORBA::tk_long : {
         long l ;
         data >>= l ;
-        ArgValue = Py_BuildValue( "l" , l ) ;
+        PyObject * ArgValue = Py_BuildValue( "l" , l ) ;
+#if PyDynInvokeTrace
+        cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << l
+               << " ArgValue->ob_refcnt" << ArgValue->ob_refcnt << endl ;
+#endif
         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
+#if PyDynInvokeTrace
         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << l
                << " (long) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
                << ArgValue->ob_refcnt << endl ;
+#endif
         break ;
       }
       case CORBA::tk_float : {
         float f ;
         data >>= f ;
-        ArgValue = Py_BuildValue( "f" , f ) ;
+        PyObject * ArgValue = Py_BuildValue( "f" , f ) ;
         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
+#if PyDynInvokeTrace
         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << f
                << " (float) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
                << ArgValue->ob_refcnt << endl ;
+#endif
         break ;
       }
       case CORBA::tk_double : {
         double d ;
         data >>= d ;
-        ArgValue = Py_BuildValue( "d" , d ) ;
+        PyObject * ArgValue = Py_BuildValue( "d" , d ) ;
         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
+#if PyDynInvokeTrace
         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << d
                << " (double) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
                << ArgValue->ob_refcnt << endl ;
+#endif
         break ;
       }
       case CORBA::tk_objref : {
@@ -301,21 +376,30 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
         IORObjRef = ObjectToString( ObjRef ) ;
         ObjValue = Py_BuildValue( "s" , IORObjRef ) ;
         PyTuple_SetItem( MyPyObjRefList , 0 , ObjValue ) ;
+#if PyDynInvokeTrace
         cdebug << "ArgIn" << i << " : " << sname << " " << method << " " << " Value " << IORObjRef << " (objref) "
                << MyPyObjRef->ob_refcnt << "/" << MyPyObjRefList->ob_refcnt << endl ;
-        ResultObj = PyEval_CallObject( MyPyObjRef , MyPyObjRefList ) ;
+#endif
+//        ResultObj = PyEval_CallObject( MyPyObjRef , MyPyObjRefList ) ;
+        ResultObj = PyEvalCallObject( "PyObjRef" , MyPyObjRef , MyPyObjRefList ) ;
+#if PyDynInvokeTrace
         cdebug << "ObjValue->ob_refcnt" << ObjValue->ob_refcnt << endl ;
+#endif
         ArgValue = Py_BuildValue( "O" , ResultObj ) ;
         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
+#if PyDynInvokeTrace
         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value  (objref) ArgsList->ob_refcnt"
                << ArgsList->ob_refcnt << " ArgValue->ob_refcnt" << ArgValue->ob_refcnt << endl ;
         cdebug << "MyPyObjRefList->ob_refcnt " << MyPyObjRefList->ob_refcnt-1 << endl ;
+#endif
         Py_DECREF( MyPyObjRefList ) ;
         if ( CORBA::is_nil( ObjRef ) ) {
           ResultObj = NULL ;
         }
         else {
+#if PyDynInvokeTrace
           cdebug << "ResultObj->ob_refcnt " << ResultObj->ob_refcnt-1 << endl ;
+#endif
           Py_DECREF( ResultObj ) ;
         }
         break ;
@@ -326,9 +410,12 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
       }
     }
 
-    Result = PyEval_CallObject( MyPyRunMethod , ArgsList ) ;
+//    Result = PyEval_CallObject( MyPyRunMethod , ArgsList ) ;
+    Result = PyEvalCallObject( method , MyPyRunMethod , ArgsList ) ;
 
+#if PyDynInvokeTrace
     cdebug << "ArgsList->ob_refcnt" << ArgsList->ob_refcnt << endl ;
+#endif
 
     if ( Result == NULL ) {
       cdebug_out << "GraphExecutor::InNode::PyDynInvoke Node " << Name() << " " << method << " Error Result == NULL"
@@ -336,12 +423,13 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
       RetVal = false ;
     }
     else {
-      for ( i = 0 ; i < n_out ; i++ ) {
-        data = outParams[i].Value ;
-        sname = outParams[i].Name.c_str() ;
+      for ( i = 0 ; i < nOutParams ; i++ ) {
+        data = OutParametersList[i].Value ;
+        sname = OutParametersList[i].Name.c_str() ;
         switch ( data.type()->kind() ) {
         case CORBA::tk_string : {
           char * t = "" ;
+          PyObject * ArgValue ;
           if ( PyTuple_Check( Result ) ) {
             ArgValue = PyTuple_GetItem( Result , i ) ;
     	  }
@@ -350,18 +438,22 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
   	  }
           if ( !PyString_Check( ArgValue ) ) {
             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (string)" << endl ;
+            RetVal = false ;
   	  }
           else {
             t = PyString_AsString( ArgValue ) ;
 	  }
           data <<= t ;
+#if PyDynInvokeTrace
           cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << t << " (string)"
-                 << " ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
+                 << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
                  << ArgValue->ob_refcnt << endl ;
+#endif
           break ;
         }
         case CORBA::tk_boolean : {
           bool b = false ;
+          PyObject * ArgValue ;
           if ( PyTuple_Check( Result ) ) {
             ArgValue = PyTuple_GetItem( Result , i ) ;
   	  }
@@ -370,38 +462,49 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
 	  }
           if ( !PyInt_Check( ArgValue ) ) {
             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (boolean)" << endl ;
+            RetVal = false ;
 	  }
           else {
             b = PyInt_AsLong( ArgValue ) ;
 	  }
           data <<= (CORBA::Any::from_boolean ) b ;
+#if PyDynInvokeTrace
           cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << b << " (boolean)"
-                 << " ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
+                 << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
                  << ArgValue->ob_refcnt << endl ;
+#endif
           break ;
         }
         case CORBA::tk_char : {
           unsigned char c = 0 ;
+          PyObject * ArgValue ;
           if ( PyTuple_Check( Result ) ) {
             ArgValue = PyTuple_GetItem( Result , i ) ;
   	  }
           else {
             ArgValue = Result ;
 	  }
-          if ( !PyInt_Check( ArgValue ) ) {
+//JR 04.04.2005 Debug          if ( !PyInt_Check( ArgValue ) ) {
+//Difficult to understand that behavior ... Python char type is a string of length 1 !
+//                                          or type is int ...
+          if ( !PyString_Check( ArgValue ) && !PyInt_Check( ArgValue ) ) {
             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (char)" << endl ;
+            RetVal = false ;
 	  }
           else {
             c = PyInt_AsLong( ArgValue ) ;
 	  }
           data <<= (CORBA::Any::from_char ) c ;
+#if PyDynInvokeTrace
           cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << c << " (char)"
-                 << " ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
+                 << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
                  << ArgValue->ob_refcnt << endl ;
+#endif
           break ;
         }
         case CORBA::tk_short : {
           short s = 0 ;
+          PyObject * ArgValue ;
           if ( PyTuple_Check( Result ) ) {
             ArgValue = PyTuple_GetItem( Result , i ) ;
   	  }
@@ -410,18 +513,22 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
 	  }
           if ( !PyInt_Check( ArgValue ) ) {
             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (short)" << endl ;
+            RetVal = false ;
 	  }
           else {
             s = PyInt_AsLong( ArgValue ) ;
 	  }
           data <<= s ;
+#if PyDynInvokeTrace
           cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << s << " (short)"
-                 << " ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
+                 << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
                  << ArgValue->ob_refcnt << endl ;
+#endif
           break ;
         }
         case CORBA::tk_long : {
           long l = 0 ;
+          PyObject * ArgValue ;
           if ( PyTuple_Check( Result ) ) {
             ArgValue = PyTuple_GetItem( Result , i ) ;
   	  }
@@ -436,15 +543,19 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
 	  }
           else {
             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (CORBA::tk_long)" << endl ;
+            RetVal = false ;
 	  }
           data <<= l ;
+#if PyDynInvokeTrace
           cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << l << " (long)"
-                 << " ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
+                 << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
                  << ArgValue->ob_refcnt << endl ;
+#endif
           break ;
         }
         case CORBA::tk_float : {
           float f = 0 ;
+          PyObject * ArgValue ;
           if ( PyTuple_Check( Result ) ) {
             ArgValue = PyTuple_GetItem( Result , i ) ;
 	  }
@@ -453,18 +564,22 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
 	  }
           if ( !PyFloat_Check( ArgValue ) ) {
             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (float)" << endl ;
+            RetVal = false ;
 	  }
           else {
             f = PyFloat_AsDouble( ArgValue ) ;
 	  }
           data <<= f ;
+#if PyDynInvokeTrace
           cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << f << " (float)"
-                 << " ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
+                 << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
                  << ArgValue->ob_refcnt << endl ;
+#endif
           break ;
         }
         case CORBA::tk_double : {
           double d = 0 ;
+          PyObject * ArgValue ;
           if ( PyTuple_Check( Result ) ) {
             ArgValue = PyTuple_GetItem( Result , i ) ;
 	  }
@@ -473,14 +588,17 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
 	  }
           if ( !PyFloat_Check( ArgValue ) ) {
             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (double)" << endl ;
+            RetVal = false ;
 	  }
           else {
             d = PyFloat_AsDouble( ArgValue ) ;
 	  }
           data <<= d ;
+#if PyDynInvokeTrace
           cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << d << " (double)"
-                 << " ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
+                 << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
                  << ArgValue->ob_refcnt << endl ;
+#endif
           break ;
         }
         case CORBA::tk_objref : {
@@ -492,31 +610,88 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
           else {
             ObjIor = Result ;
 	  }
+#if PyDynInvokeTrace
           cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << "(object reference) "
-                 << " ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ObjIor->ob_refcnt"
+                 << " Result->ob_refcnt" << Result->ob_refcnt << " ObjIor->ob_refcnt"
                  << ObjIor->ob_refcnt << endl ;
+#endif
           Py_INCREF( ObjIor ) ;
 //          PyObject_Print( ObjIor , stdout , 0 ) ;
           PyTuple_SetItem( MyPyObjIorList , 0 , ObjIor ) ;
-          ResultIor = PyEval_CallObject( MyPyObjIor , MyPyObjIorList ) ;
+//          ResultIor = PyEval_CallObject( MyPyObjIor , MyPyObjIorList ) ;
+          ResultIor = PyEvalCallObject( "PyObjIor" , MyPyObjIor , MyPyObjIorList ) ;
+#if PyDynInvokeTrace
           cdebug << "ObjIor->ob_refcnt " << ObjIor->ob_refcnt-1 << endl ;
+#endif
           Py_DECREF( ObjIor ) ;
+#if PyDynInvokeTrace
           cdebug << "MyPyObjIorList->ob_refcnt " << MyPyObjIorList->ob_refcnt-1 << endl ;
+#endif
           Py_DECREF( MyPyObjIorList ) ;
+#if PyDynInvokeTrace
           cdebug << "MyPyObjIor->ob_refcnt " << MyPyObjIor->ob_refcnt << endl ;
+#endif
           if ( ResultIor ) {
             char * IOR = NULL ;
             IOR = PyString_AsString( ResultIor ) ;
             ObjRef = StringToObject( IOR ) ;
+//JR 05.08.2005 BUG OMNIORB4 ? : that line does run with SALOME_3 (OMNIOrb4) for
+//                               object references ... (It's Ok with OMNIOrb3)
+//                               IOR and ObjRef and IORObjRef are Ok
+//                               BUT data contains a nil reference !!!
+#if !omniORB_4_0_5
             data <<= ObjRef ;
+#else
+            SUPERV::SuperG_var mySuperVisionComponent ;
+            mySuperVisionComponent = theAutomaton->SuperVisionComponent() ;
+            if ( CORBA::is_nil( mySuperVisionComponent ) ) {
+              Engines::Container_var myContainer ;
+              Engines::Component_var myObjComponent ;
+              _OutNode->Graph()->StartComponent( ThreadNo() , "SuperVisionContainer" ,
+                                                 "SUPERV" ,
+                                                 myContainer , myObjComponent ) ;
+              mySuperVisionComponent = SUPERV::SuperG::_narrow( myObjComponent ) ;
+              theAutomaton->SuperVisionComponent( mySuperVisionComponent ) ;
+            }
+//JR 24.08.2005 BUG OMNIORB4 ? : That does not run also ==> Comments
+//            CORBA::Object_ptr ObjRef1 ;
+//            ObjRef1 = mySuperVisionComponent->ToObject( ObjRef ) ;
+//            data <<= ObjRef1 ;
+//JR 24.08.2005 BUG OMNIORB4 ? : BUT THAT RUNS WITH THE "IDENTITY METHOD ToObject of SUPERV.idl :
+//                               Object ToObject( in Object anObject ) ;
+//CODE of that method !!! :
+//CORBA::Object_ptr SuperV_Impl::ToObject( CORBA::Object_ptr anObjectRef ) {
+//  beginService( "SuperV_Impl::ToObject" );
+//  CORBA::Object_ptr anObject ;
+//  anObject = CORBA::Object::_duplicate( anObjectRef ) ;
+//  endService( "SuperV_Impl::ToObject" );
+//  return anObject ;
+//}
+//BUT THAT RUNS ONLY IF WE USE Dynamic invocation of CORBA (DynInvoke)
+            ServicesAnyData anInParametersList ;
+            anInParametersList.Name = "anObjRef" ;
+            anInParametersList.Value <<= ObjRef ;
+            DynInvoke( mySuperVisionComponent , "ToObject" ,
+                       &anInParametersList , 1 , &OutParametersList[i] , 1 ) ;
+            data = OutParametersList[i].Value ;
+#endif
             IORObjRef = ObjectToString( ObjRef ) ;
-            cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << IORObjRef << " (objref) "
-                   << endl ;
+#if PyDynInvokeTrace
+            cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value IORPy "
+                   << IOR << " IORObjRef " << IORObjRef << " (objref) " << endl ;
+#endif
             if ( CORBA::is_nil( ObjRef ) ) {
+#if PyDynInvokeTrace
+              cdebug << "ObjRef ERROR(nil reference) ResultIor->ob_refcnt "
+                     << ResultIor->ob_refcnt-1 << endl ;
+#endif
               ResultIor = NULL ;
             }
             else {
-              cdebug << "ResultIor->ob_refcnt " << ResultIor->ob_refcnt-1 << endl ;
+#if PyDynInvokeTrace
+              cdebug << "ObjRef NOT(nil reference)ResultIor->ob_refcnt "
+                     << ResultIor->ob_refcnt-1 << endl ;
+#endif
               Py_DECREF( ResultIor ) ;
 	    }
 	  }
@@ -529,23 +704,155 @@ bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
         }
         default : {
           cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << "(other ERROR)" << endl ;
+            RetVal = false ;
         }
         }
-        outParams[i].Value = data ;
+//JR 05.08.2005 BUG OMNIORB4 ? : that line does run with SALOME_3 (OMNIOrb4) for
+//                               object references ...
+        OutParametersList[i].Value = data ;
+//        if ( data.type()->kind() == CORBA::tk_objref ) {
+//          IORObjRef = ObjectToString( ObjRef ) ;
+//#if PyDynInvokeTrace
+//          cdebug << ThreadNo() << "GraphExecutor::InNode::PyDynInvoke Node " << Name()
+//                 << "ArgOut" << i << " : " << sname << " " << method << " ObjRef "
+//                 << IORObjRef << " (objref) " << endl ;
+//          Engines::Component_var theObjComponent ;
+//          theObjComponent = Engines::Component::_narrow( ObjRef ) ;
+//          DynInvoke( theObjComponent , "ping" , NULL , 0 , NULL , 0 ) ;
+//#endif
+//          Engines::Container_var myContainer ;
+//          Engines::Component_var myObjComponent ;
+//          _OutNode->Graph()->StartComponent( ThreadNo() , "SuperVisionContainer" ,
+//                                             "SUPERV" ,
+//                                              myContainer , myObjComponent ) ;
+//          SUPERV::SuperG_var mySuperVisionComponent ;
+//          mySuperVisionComponent = SUPERV::SuperG::_narrow( myObjComponent ) ;
+//          CORBA::Object_ptr ObjRef1 ;
+//          ObjRef1 = mySuperVisionComponent->ToObject( IORObjRef ) ;
+//#if PyDynInvokeTrace
+//          IORObjRef = ObjectToString( ObjRef1 ) ;
+//          cdebug << ThreadNo() << "GraphExecutor::InNode::PyDynInvoke Node " << Name()
+//                 << "ArgOut" << i << " : " << sname << " " << method << " ToObject "
+//                 << IORObjRef << " (objref) " << endl ;
+//#endif
+
+//          ServicesAnyData anInParametersList ;
+//          anInParametersList.Name = "anIORObjRef" ;
+//          anInParametersList.Value <<= IORObjRef ;
+//          DynInvoke( mySuperVisionComponent , "ToObject" ,
+//                     &anInParametersList , 1 , &OutParametersList[i] , 1 ) ;
+//#if PyDynInvokeTrace
+//          OutParametersList[i].Value >>= ObjRef1 ;
+//          IORObjRef = ObjectToString( ObjRef1 ) ;
+//          cdebug << ThreadNo() << "GraphExecutor::InNode::PyDynInvoke Node " << Name()
+//                 << "ArgOut" << i << " : " << sname << " " << method
+//                 << " DynInvoke(ToObject) " << IORObjRef << " (objref) " << endl ;
+//#endif
+//        }
       }
 
-      cdebug << "Result->ob_refcnt" << Result->ob_refcnt-1 << endl ;
+#if PyDynInvokeTrace
+      cdebug << "InNode::PyDynInvoke Result->ob_refcnt " << Result->ob_refcnt-1 << endl ;
+#endif
       Py_DECREF( Result ) ;
     }
 
-    cdebug << "GraphExecutor::InNode::PyDynInvoke ArgsList->ob_refcnt"
-           << ArgsList->ob_refcnt-1 << endl ;
+#if PyDynInvokeTrace
+    cdebug << "InNode::PyDynInvoke ArgsList->ob_refcnt " << ArgsList->ob_refcnt-1 << endl ;
+#endif
     Py_DECREF( ArgsList ) ;
   }
 
+#if 0
+  {
+    int i ;
+    for ( i = 0 ; i < nInParams ; i++ ) { // Without Gates
+      cdebug << "InParametersList[" << i << "] : "
+             << InParametersList[i].Name << " "
+             << AnyValue( InParametersList[i].Value ) << endl ;
+    }
+    for ( i = 0 ; i < nOutParams ; i++ ) { // Without Gates
+      cdebug << "OutParametersList[" << i << "] : "
+             << OutParametersList[i].Name << " "
+             << AnyValue( OutParametersList[i].Value ) << endl ;
+    }
+  }
+#endif
+
+#if PyDynInvokeTrace
   cdebug_out << "GraphExecutor::InNode::PyDynInvoke Node " << Name() << " method " << method << " " << RetVal
              << endl ;
+#endif
 
   return RetVal ;
 
 }
+
+bool GraphExecutor::InNode::PyRunSimpleString( char* thePyString )
+{
+  const bool ErrorValue = true;
+  bool aRet;
+  try {
+#if PyDynInvokeTrace
+    MESSAGE( pthread_self() << "Python method beginning : " << thePyString );
+    cdebug_in << pthread_self() << "Python method beginning : " << thePyString << endl ;
+#endif
+    aRet = PyRun_SimpleString( thePyString );
+    // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL    
+    //aRet = _OutNode->SuperVisionContainer()->ActivatePythonExecution( thePyString ) ;
+#if PyDynInvokeTrace
+    MESSAGE( pthread_self() << "Python method finished." );
+    cdebug_out << pthread_self() << "Python method finished." << endl ;
+#endif
+  } catch( ... ) {
+    MESSAGE( pthread_self() << "ERROR: Exception caught running Python method." );
+    cdebug_out << pthread_self() << "ERROR: Exception caught running Python method."
+               << endl ;
+    MESSAGE( "       Python was reinitialized.  Previous Python definitions are lost" );
+    // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL    
+    Py_Finalize();
+    Py_Initialize();
+    Py_InitModule( "InitPyRunMethod" , MethodPyRunMethod );
+    _OutNode->PyInitialized( false );
+    aRet = ErrorValue;
+  }
+  return aRet;
+}
+
+PyObject * GraphExecutor::InNode::PyEvalCallObject( const char *method ,
+                                                    PyObject * MyPyRunMethod ,
+                                                    PyObject * ArgsList ) {
+//  cdebug_in << "Executor::InNode::PyEvalCallObject " << Name() << endl ;
+  PyObject * Result = NULL ;
+  try {
+//    MESSAGE( pthread_self() << "PyEval_CallObject " << Name() << " method beginning : " << method );
+//    cdebug << pthread_self() << "PyEval_CallObject " << Name() << " method beginning : " << method << endl ;
+    Result = PyEval_CallObject( MyPyRunMethod , ArgsList ) ;
+    // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL    
+    //Result = _OutNode->SuperVisionContainer()->ActivatePythonExecution( MyPyRunMethod , ArgsList ) ;
+//    MESSAGE( pthread_self() << "PyEval_CallObject method finished. Result " << Result );
+//    cdebug << pthread_self() << "PyEval_CallObject method finished. Result " << Result << endl ;
+//    cdebug_out << "Executor::InNode::PyEvalCallObject " << Name() << endl ;
+  } catch( ... ) {
+    MESSAGE( pthread_self() << "ERROR: Exception caught PyEval_CallObject " << Name()
+             << " Python method " << method << ". Result "  << Result );
+    cdebug << pthread_self() << "ERROR: Exception caught PyEval_CallObject " << Name()
+           << " Python method " << method << ". Result " << Result << endl ;
+    MESSAGE( "       Python was reinitialized.  Previous Python definitions are lost Py_IsInitialized " << Py_IsInitialized() );
+//JR ===> fatal error in python : no current thread
+    // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL    
+    Py_Finalize();
+    Py_Initialize();
+    Automaton()->PyInitModule( false ) ;
+    Py_InitModule( "InitPyRunMethod" , MethodPyRunMethod );
+    _OutNode->PyInitialized( false );
+
+    if ( Result == NULL ) {
+      Kill() ; // Reset of _ThreadId
+    }
+//    cdebug << "Executor::InNode::PyEvalCallObject ERROR catched " << Name()
+//           << " Py_IsInitialized " << Py_IsInitialized() << endl ;
+  }
+//  cdebug_out << "Executor::InNode::PyEvalCallObject " << Name() << endl ;
+  return Result ;
+}