src/GraphExecutor/DataFlowExecutor_PyDynInvoke.cxx

   1 //  SUPERV GraphExecutor : contains classes that permit execution of graphs and particularly the execution automaton
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  File   : DataFlowExecutor_PyDynInvoke.cxx
  23 //  Author : Jean Rahuel, CEA
  24 //  Module : SUPERV
  25
  26 using namespace std;
  27
  28 #include <stdarg.h>
  29 #include <map>
  30
  31 #include "DataFlowExecutor_InNode.hxx"
  32 #include "DataFlowExecutor_OutNode.hxx"
  33
  34 using namespace CORBA ;
  35
  36 extern GraphExecutor::FiniteStateMachine * theAutomaton ;
  37
  38 //static PyObject * MyPyObjSignal = NULL ;
  39 static PyObject * MyPyObjRef = NULL ;
  40 static PyObject * MyPyObjIor = NULL ;
  41 static PyObject * MyPyRunMethod = NULL ;
  42
  43 static PyMethodDef MethodPyRunMethod[] = {
  44   { "RunMethod", PyRunMethod, METH_VARARGS },
  45   { NULL,        NULL }
  46 };
  47
  48 bool GraphExecutor::InNode::InitPython() {
  49   cdebug_in << "InitPython" << endl ;
  50
  51   Automaton()->PyLock() ;
  52 //  PyObject * Module = Py_InitModule( "InitPyRunMethod" , MethodPyRunMethod ) ;
  53   if ( !Automaton()->PyInitModule() ) {
  54     Py_InitModule( "InitPyRunMethod" , MethodPyRunMethod ) ;
  55     // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL
  56     //_OutNode->SuperVisionContainer()->ActivatePythonExecution( "InitPyRunMethod" , MethodPyRunMethod ) ;
  57
  58     // PAL10310: patch on omniORB
  59     string aPyFunc;
  60     aPyFunc = "import omnipatch\n" ;
  61     if ( PyRun_SimpleString( (char *) aPyFunc.c_str() ) ) {
  62       cdebug << ThreadNo() << " " << Name() << " PyRun_SimpleString ERROR " << endl << aPyFunc << endl ;
  63       Automaton()->PyUnLock() ;
  64       return false ;
  65     }
  66   }
  67 //  PyObject * Dictionnary = PyModule_GetDict( Module ) ;
  68 //  InitPyDynInvokeError = PyErr_NewException( "InitPyDynInvokeError" , NULL , NULL ) ;
  69 //  PyDict_SetItemString( Dictionnary , InitPyDynInvokeError ) ;
  70   cdebug << ThreadNo() << "Py_Initialized() " << endl ;
  71
  72 #if 0
  73 //JR : Python documentation says that there is no sense to set a handler of synchronous
  74 // signals as SIGSEGV and SIGFPE !!!
  75   if ( Automaton()->PyFunction( "PyObjSignal" ) == NULL ) {
  76     string aPyFunc ;
  77     aPyFunc = "import signal\n" ;
  78     aPyFunc += "import InitPyRunMethod\n" ;
  79     aPyFunc += "import sys\n" ;
  80     aPyFunc += "import CORBA\n" ;
  81     aPyFunc += "import omniORB\n" ;
  82     aPyFunc += "def PySignalHandler( aSignal , aStackFrame ) :\n" ;
  83     aPyFunc += "    print 'PySignalHandler(aSignal =',aSignal,',aStackFrame= ',aStackFrame,')'\n" ;
  84     aPyFunc += "InitPyRunMethod.RunMethod( PySignalHandler )\n" ;
  85     aPyFunc += "PrevHandler = signal.signal( signal.SIGSEGV , PySignalHandler )\n" ;
  86     aPyFunc += "print 'PyObjSignal PrevHandler of SIGSEGV :', PrevHandler\n" ;
  87     aPyFunc += "print 'PyObjSignal actual handler of SIGSEGV :', signal.getsignal( signal.SIGSEGV  )\n" ;
  88 //    if ( PyRun_SimpleString( (char *) aPyFunc.c_str() ) ) {
  89     if ( PyRunSimpleString( (char *) aPyFunc.c_str() ) ) {
  90       cdebug << ThreadNo() << " " << Name() << " PyRun_SimpleString ERROR " << endl << aPyFunc << endl ;
  91       Automaton()->PyUnLock() ;
  92       return false ;
  93     }
  94     MyPyObjSignal = MyPyRunMethod ;
  95     Automaton()->PyFunction( "PyObjSignal" , MyPyObjSignal ) ;
  96   }
  97   else {
  98     MyPyObjSignal = Automaton()->PyFunction( "PyObjSignal" ) ;
  99   }
 100 #endif
 101
 102 // PyObjRef convert an IOR (string) to an Python ObjectReference
 103   if ( Automaton()->PyFunction( "PyObjRef" ) == NULL ) {
 104     string aPyFunc ;
 105     aPyFunc = "import InitPyRunMethod\n" ;
 106     aPyFunc += "import sys\n" ;
 107     aPyFunc += "import CORBA\n" ;
 108     aPyFunc += "import omniORB\n" ;
 109     aPyFunc += "orb = CORBA.ORB_init( sys.argv , CORBA.ORB_ID )\n" ;
 110     aPyFunc += "def PyObjRef( IORObjStr ) :\n" ;
 111     //    aPyFunc += "    orb = CORBA.ORB_init( sys.argv , CORBA.ORB_ID )\n" ;
 112     aPyFunc += "    objref = orb.string_to_object( IORObjStr )\n" ;
 113     aPyFunc += "    return objref\n" ;
 114     aPyFunc += "InitPyRunMethod.RunMethod( PyObjRef )\n" ;
 115     if ( PyRun_SimpleString( (char *) aPyFunc.c_str() ) ) {
 116     // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL
 117     //if ( PyRunSimpleString( (char *) aPyFunc.c_str() ) ) {
 118       cdebug << ThreadNo() << " " << Name() << " PyRun_SimpleString ERROR " << endl << aPyFunc << endl ;
 119       Automaton()->PyUnLock() ;
 120       return false ;
 121     }
 122     MyPyObjRef = MyPyRunMethod ;
 123     Automaton()->PyFunction( "PyObjRef" , MyPyObjRef ) ;
 124   }
 125   else {
 126     MyPyObjRef = Automaton()->PyFunction( "PyObjRef" ) ;
 127   }
 128
 129 // PyObjRef convert an Python ObjectReference to an IOR (string)
 130   if ( Automaton()->PyFunction( "PyObjIor" ) == NULL ) {
 131     string aPyFunc ;
 132     aPyFunc = "import InitPyRunMethod\n" ;
 133     aPyFunc += "import sys\n" ;
 134     aPyFunc += "import CORBA\n" ;
 135     aPyFunc += "import omniORB\n" ;
 136     aPyFunc += "orb = CORBA.ORB_init( sys.argv , CORBA.ORB_ID )\n" ;
 137     aPyFunc += "def PyObjIor( ObjRef ) :\n" ;
 138     //    aPyFunc += "    orb = CORBA.ORB_init( sys.argv , CORBA.ORB_ID )\n" ;
 139     aPyFunc += "    objIor = orb.object_to_string( ObjRef )\n" ;
 140     aPyFunc += "    return objIor\n" ;
 141     aPyFunc += "InitPyRunMethod.RunMethod( PyObjIor )\n" ;
 142     if ( PyRun_SimpleString( (char *) aPyFunc.c_str() ) ) {
 143     // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL
 144     //if ( PyRunSimpleString( (char *) aPyFunc.c_str() ) ) {
 145       cdebug << ThreadNo() << " " << Name() << " PyRun_SimpleString ERROR " << endl << aPyFunc << endl ;
 146       Automaton()->PyUnLock() ;
 147       return false ;
 148     }
 149     MyPyObjIor = MyPyRunMethod ;
 150     Automaton()->PyFunction( "PyObjIor" , MyPyObjIor ) ;
 151   }
 152   else {
 153     MyPyObjIor = Automaton()->PyFunction( "PyObjIor" ) ;
 154   }
 155   Automaton()->PyUnLock() ;
 156
 157   cdebug_out << "InitPython" << endl ;
 158
 159   return true ;
 160 }
 161
 162 void GraphExecutor::InNode::RemovePyDynInvoke( char * PyFuncName ) {
 163 //  Automaton()->PyLock() ; // Already done ...
 164   if ( Automaton()->ErasePyFunction( PyFuncName ) ) {
 165     cdebug << "InNode::RemovePyDynInvoke( " << PyFuncName << " ) success" << endl ;
 166   }
 167   else {
 168     cdebug << "InNode::RemovePyDynInvoke( " << PyFuncName << " ) ERROR failed" << endl ;
 169   }
 170 //  Automaton()->PyUnLock() ;
 171 }
 172
 173 PyObject * GraphExecutor::InNode::InitPyDynInvoke( char * PyFuncName ,
 174                                                    const SUPERV::ListOfStrings * aPythonFunction ,
 175                                                    bool & Err ) {
 176   bool RetVal = true ;
 177   Err = false ;
 178   string aPyFunc ;
 179   PyObject * thePyRunMethod = NULL ;
 180
 181   cdebug_in << "InitPyDynInvoke '" << PyFuncName << "' length " << (*aPythonFunction).length() << endl ;
 182
 183   if ( strlen( PyFuncName ) ) {
 184     Automaton()->PyLock() ;
 185     thePyRunMethod = Automaton()->PyFunction( PyFuncName ) ;
 186
 187     //thePyRunMethod = NULL;
 188     // asv 28.02.05 : VERY BAD fix of the following problem: after change of a function,
 189     // the changes are NOT taken into account by Automation - it returns PyObject of the OLD function.
 190     // so here we force re-automating the PyObject EVERY TIME, regardless if the function has changed or not.
 191     // Once again - it is a very bad solution, it fully discards the whole idea of automation,
 192     // here is it done as a quick fix for a bug.
 193     // A better solution (to be implemented): store the PyObject NOT in Automation map, but in
 194     // InLine node itself!  And if the method is changed - remove the PyObject and force to regenerate it.
 195     // But this means that PyObject must be stored in Editor's data model.
 196     // asv 01.03.05 : the fix is not needed, the described bug is not reproduced.  To investigate:
 197     // WHERE PyObject is removed from Automation map on function change.
 198
 199     if ( (*aPythonFunction).length() ) {
 200       if ( thePyRunMethod == NULL ) {
 201         unsigned int i ;
 202         aPyFunc += "import InitPyRunMethod\n" ;
 203         for ( i = 0 ; i < (*aPythonFunction).length() ; i++ ) {
 204           aPyFunc += (*aPythonFunction)[ i ] ;
 205           aPyFunc += "\n" ;
 206         }
 207         aPyFunc += "InitPyRunMethod.RunMethod( " ;
 208         aPyFunc += PyFuncName ;
 209         aPyFunc += " )\n" ;
 210         /*cdebug *///cout<< "InitPyDynInvoke PyRun_SimpleString " << endl << aPyFunc << endl ;
 211 //        if ( PyRun_SimpleString( (char *) aPyFunc.c_str() ) ) {
 212         if ( PyRunSimpleString( (char *) aPyFunc.c_str() ) ) {
 213           cdebug << ThreadNo() << " " << Name() << " PyRunSimpleString ERROR " << endl << aPyFunc << endl ;
 214           PyFuncRunned( false ) ;
 215           RetVal = false ;
 216           Err = true ;
 217         }
 218         else {
 219           PyFuncRunned( true ) ;
 220           thePyRunMethod = MyPyRunMethod ;
 221
 222           Automaton()->PyFunction( PyFuncName , thePyRunMethod ) ;
 223           cdebug << ThreadNo() << "PyRunSimpleString( " << (*aPythonFunction)[ 0 ] << " ) " << endl ;
 224         }
 225       }
 226       if ( RetVal ) {
 227         Automaton()->PyUnLock() ;
 228         cdebug_out << "InitPyDynInvoke '" << PyFuncName << "' thePyRunMethod " << thePyRunMethod << " "
 229                    << thePyRunMethod->ob_refcnt << endl ;
 230         return thePyRunMethod ;
 231       }
 232     }
 233     else if ( thePyRunMethod ) {
 234       Automaton()->PyUnLock() ;
 235       cdebug_out << "InitPyDynInvoke '" << PyFuncName << "' thePyRunMethod " << thePyRunMethod << " "
 236                  << thePyRunMethod->ob_refcnt << endl ;
 237       return thePyRunMethod ;
 238     }
 239     Automaton()->PyUnLock() ;
 240   }
 241
 242   cdebug_out << "InitPyDynInvoke '" << PyFuncName << "' thePyRunMethod Null Err " << Err << endl ;
 243
 244   return NULL ;
 245 }
 246
 247 extern "C" PyObject * PyRunMethod( PyObject * dummy , PyObject * Args ) {
 248   PyObject * Result = NULL ;
 249   PyObject * Temp = NULL ;
 250   if ( PyArg_ParseTuple( Args , "O:set_callback" , & Temp ) ) {
 251 //    cout << "PyArg_ParsedTuple" << endl ;
 252     if ( !PyCallable_Check( Temp ) ) {
 253 //      PyErr_SetString( PyExc_TypeError , "PyRunMethod must be callable" ) ;
 254 //      cout << "PyRunMethod must be callable" << endl ;
 255       return NULL ;
 256     }
 257     Py_XINCREF( Temp ) ;
 258     Py_XDECREF( MyPyRunMethod ) ;
 259     MyPyRunMethod = Temp ;
 260     Py_INCREF( Py_None ) ;
 261     Result = Py_None ;
 262   }
 263   return Result ;
 264 }
 265
 266 #define PyDynInvokeTrace 0
 267 bool GraphExecutor::InNode::PyDynInvoke( PyObject * MyPyRunMethod ,
 268                                          const char *method ,
 269                                          ServicesAnyData * InParametersList , int nInParams ,
 270                                          ServicesAnyData * OutParametersList , int nOutParams ) {
 271   int i ;
 272
 273   bool RetVal = true ;
 274
 275   const char * sname;
 276
 277 #if PyDynInvokeTrace
 278   cdebug_in << ThreadNo() << "GraphExecutor::InNode::PyDynInvoke Node " << Name()
 279             << " method " << method
 280             << " InParametersList " << InParametersList
 281             << " OutParametersList " << OutParametersList
 282             << " " << nInParams << " InArgs " << nOutParams
 283             << " OutArgs MyPyRunMethod " ;
 284 #endif
 285   if ( MyPyRunMethod ) {
 286 #if PyDynInvokeTrace
 287     cdebug << MyPyRunMethod << " " << MyPyRunMethod->ob_refcnt << endl ;
 288 #endif
 289   }
 290   else {
 291 #if PyDynInvokeTrace
 292     cdebug << " NULL" << endl ;
 293 #endif
 294     return false ;
 295   }
 296
 297   CORBA::Any data ;
 298
 299   PyObject * ArgsList = NULL ;
 300   PyObject * ArgValue = NULL ;
 301   PyObject * Result = NULL ;
 302   //PyObject * MyPyObjRefList = NULL ;
 303   PyObject * ResultObj = NULL ;
 304   //PyObject * MyPyObjIorList = NULL ;
 305   PyObject * ResultIor = NULL ;
 306
 307   CORBA::Object_ptr ObjRef ;
 308
 309   char * IORObjRef ;
 310
 311   if ( !PyCallable_Check( MyPyRunMethod ) ) {
 312     Result = NULL ;
 313     RetVal = false ;
 314   }
 315   else {
 316     ArgsList = PyTuple_New( nInParams ) ;
 317
 318     for ( i = 0 ; i < nInParams ; i++ ) {
 319       data = InParametersList[i].Value ;
 320       sname = InParametersList[i].Name.c_str() ;
 321       switch ( data.type()->kind() ) {
 322       case CORBA::tk_string : {
 323         const char * t ;
 324         data >>= t ;
 325         PyObject * ArgValue = Py_BuildValue( "s" , t ) ;
 326         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
 327 #if PyDynInvokeTrace
 328         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << t << " (string) "
 329                << " ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
 330                << ArgValue->ob_refcnt << endl ;
 331 #endif
 332         break ;
 333       }
 334       case CORBA::tk_boolean : {
 335         bool b ;
 336         data >>= (CORBA::Any::to_boolean ) b ;
 337         PyObject * ArgValue = Py_BuildValue( "b" , b ) ;
 338         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
 339 #if PyDynInvokeTrace
 340         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << b
 341                << " (boolean) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
 342                << ArgValue->ob_refcnt << endl ;
 343 #endif
 344         break ;
 345       }
 346       case CORBA::tk_char : {
 347         unsigned char c ;
 348         data >>= (CORBA::Any::to_char ) c ;
 349         PyObject * ArgValue = Py_BuildValue( "c" , c ) ;
 350         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
 351 #if PyDynInvokeTrace
 352         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << c
 353                << " (char) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
 354                << ArgValue->ob_refcnt << endl ;
 355 #endif
 356         break ;
 357       }
 358       case CORBA::tk_short : {
 359         CORBA::Short s ;
 360         data >>= s ;
 361         PyObject * ArgValue = Py_BuildValue( "h" , s ) ;
 362         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
 363 #if PyDynInvokeTrace
 364         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << s
 365                << " (short) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
 366                << ArgValue->ob_refcnt << endl ;
 367 #endif
 368         break ;
 369       }
 370       case CORBA::tk_long : {
 371         CORBA::Long l ;
 372         data >>= l ;
 373 //      epa - Porting to 64-bit Linux:CORBA::Long is incorrectly treated as unsigned
 374 //            integer by Py_BuildValue("l", val) in Python 2.4.1. Using Py_BuildValue("i",val)
 375 //            seemsto help
 376         PyObject * ArgValue = NULL;
 377         if ( SIZEOF_LONG == 4 )
 378            ArgValue = Py_BuildValue( "l" , l ) ;
 379         else
 380            ArgValue = Py_BuildValue( "i" , l ) ;
 381 #if PyDynInvokeTrace
 382         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << l
 383                << " ArgValue->ob_refcnt" << ArgValue->ob_refcnt << endl ;
 384 #endif
 385         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
 386 #if PyDynInvokeTrace
 387         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << l
 388                << " (CORBA::Long) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
 389                << ArgValue->ob_refcnt << endl ;
 390 #endif
 391         break ;
 392       }
 393       case CORBA::tk_float : {
 394         CORBA::Float f ;
 395         data >>= f ;
 396         PyObject * ArgValue = Py_BuildValue( "f" , f ) ;
 397         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
 398 #if PyDynInvokeTrace
 399         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << f
 400                << " (float) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
 401                << ArgValue->ob_refcnt << endl ;
 402 #endif
 403         break ;
 404       }
 405       case CORBA::tk_double : {
 406         CORBA::Double d ;
 407         data >>= d ;
 408         PyObject * ArgValue = Py_BuildValue( "d" , d ) ;
 409         PyTuple_SetItem( ArgsList , i , ArgValue ) ;
 410 #if PyDynInvokeTrace
 411         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value " << d
 412                << " (double) ArgsList->ob_refcnt" << ArgsList->ob_refcnt << " ArgValue->ob_refcnt"
 413                << ArgValue->ob_refcnt << endl ;
 414 #endif
 415         break ;
 416       }
 417       case CORBA::tk_objref : {
 418         //MyPyObjRefList = PyTuple_New( 1 ) ;
 419         //PyObject * ObjValue ;
 420 #if OMNIORB_VERSION >= 4
 421         data >>= (CORBA::Any::to_object ) ObjRef ;
 422 #else
 423         data >>= ObjRef ;
 424 #endif
 425         IORObjRef = ObjectToString( ObjRef ) ;
 426         //ObjValue = Py_BuildValue( "s" , IORObjRef ) ;
 427         //PyTuple_SetItem( MyPyObjRefList , 0 , ObjValue ) ;
 428 #if PyDynInvokeTrace
 429         cdebug << "ArgIn" << i << " : " << sname << " " << method << " " << " Value " << IORObjRef << " (objref) "<< endl ;
 430         //             << MyPyObjRef->ob_refcnt << "/" << MyPyObjRefList->ob_refcnt << endl ;
 431 #endif
 432 //        ResultObj = PyEval_CallObject( MyPyObjRef , MyPyObjRefList ) ;
 433           //ResultObj = PyEvalCallObject( "PyObjRef" , MyPyObjRef , MyPyObjRefList ) ;
 434 #if PyDynInvokeTrace
 435           //cdebug << "ObjValue->ob_refcnt" << ObjValue->ob_refcnt << endl ;
 436 #endif
 437           //ArgValue = Py_BuildValue( "O" , ResultObj ) ;
 438           //PyTuple_SetItem( ArgsList , i , ArgValue ) ;
 439 #if PyDynInvokeTrace
 440         if ( ArgValue )
 441           cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value  (objref) ArgsList->ob_refcnt"
 442                  << ArgsList->ob_refcnt << " ArgValue->ob_refcnt" << ArgValue->ob_refcnt << endl ;
 443         else
 444           cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value  (objref) ArgsList->ob_refcnt"
 445                  << ArgsList->ob_refcnt << " ArgValue is NULL" << endl ;
 446         //cdebug << "MyPyObjRefList->ob_refcnt " << MyPyObjRefList->ob_refcnt-1 << endl ;
 447 #endif
 448         ResultObj = PyObject_CallFunction( MyPyObjRef , "s",IORObjRef ) ;
 449         if(ResultObj == NULL){
 450           PyErr_Print();
 451           ResultObj=Py_None;
 452           Py_INCREF(ResultObj) ;
 453         }
 454         PyTuple_SetItem( ArgsList , i , ResultObj ) ;
 455         cdebug << "ArgIn" << i << " : " << sname << " " << method << " Value  (objref) ArgsList->ob_refcnt"
 456                << ArgsList->ob_refcnt << " ArgValue->ob_refcnt" << ResultObj->ob_refcnt << endl ;
 457 //       << ArgsList->ob_refcnt << " ArgValue->ob_refcnt" << ArgValue->ob_refcnt << endl ;
 458         //cdebug << "MyPyObjRefList->ob_refcnt " << MyPyObjRefList->ob_refcnt-1 << endl ;
 459         //Py_DECREF( MyPyObjRefList ) ;
 460         //if ( CORBA::is_nil( ObjRef ) ) {
 461         //  ResultObj = NULL ;
 462         //}
 463         //else {
 464         //#if PyDynInvokeTrace
 465         //if ( ResultObj )
 466         //cdebug << "ResultObj->ob_refcnt " << ResultObj->ob_refcnt-1 << endl ;
 467         //else
 468         //cdebug << "ResultObj is NULL" << endl ;
 469         //#endif
 470         //if ( ResultObj )
 471         //Py_DECREF( ResultObj ) ;
 472         //}
 473         break ;
 474       }
 475       default : {
 476         cdebug << "ArgIn" << i << " : " << sname << " Value " << "(other ERROR)" << endl ;
 477       }
 478       }
 479     }
 480
 481 //    Result = PyEval_CallObject( MyPyRunMethod , ArgsList ) ;
 482     Result = PyEvalCallObject( method , MyPyRunMethod , ArgsList ) ;
 483
 484 #if PyDynInvokeTrace
 485     cdebug << "ArgsList->ob_refcnt" << ArgsList->ob_refcnt << endl ;
 486 #endif
 487
 488     if ( Result == NULL ) {
 489       cdebug_out << "GraphExecutor::InNode::PyDynInvoke Node " << Name() << " " << method << " Error Result == NULL"
 490                  << endl ;
 491       PyErr_Print();
 492       RetVal = false ;
 493     }
 494     else {
 495       for ( i = 0 ; i < nOutParams ; i++ ) {
 496         data = OutParametersList[i].Value ;
 497         sname = OutParametersList[i].Name.c_str() ;
 498         switch ( data.type()->kind() ) {
 499         case CORBA::tk_string : {
 500           char * t = "" ;
 501           PyObject * ArgValue ;
 502           if ( PyTuple_Check( Result ) ) {
 503             ArgValue = PyTuple_GetItem( Result , i ) ;
 504           }
 505           else {
 506             ArgValue = Result ;
 507           }
 508           if ( !ArgValue || !PyString_Check( ArgValue ) ) {
 509             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (string)" << endl ;
 510             RetVal = false ;
 511           }
 512           else {
 513             t = PyString_AsString( ArgValue ) ;
 514           }
 515           data <<= t ;
 516 #if PyDynInvokeTrace
 517           if ( ArgValue )
 518             cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << t << " (string)"
 519                    << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
 520                    << ArgValue->ob_refcnt << endl ;
 521 #endif
 522           break ;
 523         }
 524         case CORBA::tk_boolean : {
 525           bool b = false ;
 526           PyObject * ArgValue ;
 527           if ( PyTuple_Check( Result ) ) {
 528             ArgValue = PyTuple_GetItem( Result , i ) ;
 529           }
 530           else {
 531             ArgValue = Result ;
 532           }
 533           if ( !ArgValue || !PyInt_Check( ArgValue ) ) {
 534             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (boolean)" << endl ;
 535             RetVal = false ;
 536           }
 537           else {
 538             b = PyInt_AsLong( ArgValue ) ;
 539           }
 540           data <<= (CORBA::Any::from_boolean ) b ;
 541 #if PyDynInvokeTrace
 542           if ( ArgValue )
 543             cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << b << " (boolean)"
 544                    << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
 545                    << ArgValue->ob_refcnt << endl ;
 546 #endif
 547           break ;
 548         }
 549         case CORBA::tk_char : {
 550           unsigned char c = 0 ;
 551           PyObject * ArgValue ;
 552           if ( PyTuple_Check( Result ) ) {
 553             ArgValue = PyTuple_GetItem( Result , i ) ;
 554           }
 555           else {
 556             ArgValue = Result ;
 557           }
 558 //JR 04.04.2005 Debug          if ( !PyInt_Check( ArgValue ) ) {
 559 //Difficult to understand that behavior ... Python char type is a string of length 1 !
 560 //                                          or type is int ...
 561           if ( !ArgValue || !PyString_Check( ArgValue ) && !PyInt_Check( ArgValue ) ) {
 562             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (char)" << endl ;
 563             RetVal = false ;
 564           }
 565           else {
 566             c = PyInt_AsLong( ArgValue ) ;
 567           }
 568           data <<= (CORBA::Any::from_char ) c ;
 569 #if PyDynInvokeTrace
 570           if ( ArgValue )
 571             cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << c << " (char)"
 572                    << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
 573                    << ArgValue->ob_refcnt << endl ;
 574 #endif
 575           break ;
 576         }
 577         case CORBA::tk_short : {
 578           short s = 0 ;
 579           PyObject * ArgValue ;
 580           if ( PyTuple_Check( Result ) ) {
 581             ArgValue = PyTuple_GetItem( Result , i ) ;
 582           }
 583           else {
 584             ArgValue = Result ;
 585           }
 586           if ( !ArgValue || !PyInt_Check( ArgValue ) ) {
 587             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (short)" << endl ;
 588             RetVal = false ;
 589           }
 590           else {
 591             s = PyInt_AsLong( ArgValue ) ;
 592           }
 593           data <<= s ;
 594 #if PyDynInvokeTrace
 595           if ( ArgValue )
 596             cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << s << " (short)"
 597                    << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
 598                    << ArgValue->ob_refcnt << endl ;
 599 #endif
 600           break ;
 601         }
 602         case CORBA::tk_long : {
 603           CORBA::Long l = 0 ;
 604           PyObject * ArgValue ;
 605           if ( PyTuple_Check( Result ) ) {
 606             ArgValue = PyTuple_GetItem( Result , i ) ;
 607           }
 608           else {
 609             ArgValue = Result ;
 610           }
 611           if ( ArgValue && PyLong_Check( ArgValue ) ) {
 612             l = PyLong_AsLong( ArgValue ) ;
 613           }
 614           else if ( ArgValue && PyInt_Check( ArgValue ) ) {
 615             l = PyInt_AsLong( ArgValue ) ;
 616           }
 617           else {
 618             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (CORBA::tk_long)" << endl ;
 619             RetVal = false ;
 620           }
 621           data <<= l ;
 622 #if PyDynInvokeTrace
 623           if ( ArgValue )
 624             cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << l << " (CORBA::Long)"
 625                    << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
 626                    << ArgValue->ob_refcnt << endl ;
 627 #endif
 628           break ;
 629         }
 630         case CORBA::tk_float : {
 631           float f = 0 ;
 632           PyObject * ArgValue ;
 633           if ( PyTuple_Check( Result ) ) {
 634             ArgValue = PyTuple_GetItem( Result , i ) ;
 635           }
 636           else {
 637             ArgValue = Result ;
 638           }
 639           if ( ArgValue ) {
 640             if ( !PyFloat_Check( ArgValue ) ) {
 641               // mkr : bug PAL12454
 642               if ( PyLong_Check( ArgValue ) ) {
 643                 cdebug << "ArgOut" << i << " : " << sname << " " << method << " OK (CORBA::Long)" << endl ;
 644                 CORBA::Long l = PyLong_AsLong( ArgValue );
 645                 f = (float) l;
 646               }
 647               else if ( PyInt_Check( ArgValue ) ) {
 648                 cdebug << "ArgOut" << i << " : " << sname << " " << method << " OK (int)" << endl ;
 649                 CORBA::Long l = PyInt_AsLong( ArgValue );
 650                 f = (float) l;
 651               }
 652               else {
 653                 cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (float)" << endl ;
 654                 RetVal = false ;
 655               }
 656             }
 657             else {
 658               f = PyFloat_AsDouble( ArgValue ) ;
 659             }
 660           }
 661           else {
 662             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (float)" << endl ;
 663             RetVal = false ;
 664           }
 665 #ifdef REDHAT // mkr : debug for PAL12255
 666           data <<= f ;
 667 #else
 668 //JR      data.replace(CORBA::TypeCode::PR_float_tc(), (void*)(&f));
 669           data <<= (CORBA::Float) f ;
 670 #endif
 671 #if PyDynInvokeTrace
 672           if ( ArgValue )
 673             cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << f << " (float)"
 674                    << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
 675                    << ArgValue->ob_refcnt << endl ;
 676 #endif
 677           break ;
 678         }
 679         case CORBA::tk_double : {
 680           double d = 0 ;
 681           PyObject * ArgValue ;
 682           if ( PyTuple_Check( Result ) ) {
 683             ArgValue = PyTuple_GetItem( Result , i ) ;
 684           }
 685           else {
 686             ArgValue = Result ;
 687           }
 688           if ( ArgValue ) {
 689             if ( !PyFloat_Check( ArgValue ) ) {
 690               // mkr : bug PAL12454
 691               if ( PyLong_Check( ArgValue ) ) {
 692                 cdebug << "ArgOut" << i << " : " << sname << " " << method << " OK (CORBA::Long)" << endl ;
 693                 CORBA::Long l = PyLong_AsLong( ArgValue );
 694                 d = (double) l;
 695               }
 696               else if ( PyInt_Check( ArgValue ) ) {
 697                 cdebug << "ArgOut" << i << " : " << sname << " " << method << " OK (int)" << endl ;
 698                 CORBA::Long l = PyInt_AsLong( ArgValue );
 699                 d = (double) l;
 700               }
 701               else {
 702                 cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (float)" << endl ;
 703                 RetVal = false ;
 704               }
 705             }
 706             else {
 707               d = PyFloat_AsDouble( ArgValue ) ;
 708             }
 709           }
 710           else {
 711             cdebug << "ArgOut" << i << " : " << sname << " " << method << " ERROR (float)" << endl ;
 712             RetVal = false ;
 713           }
 714 #ifdef REDHAT // mkr : debug for PAL12255
 715           data <<= d ;
 716 #else
 717 //JR      data.replace(CORBA::TypeCode::PR_double_tc(), (void*)(&d));
 718           data <<= (CORBA::Double) d ;
 719 #endif
 720 #if PyDynInvokeTrace
 721           if ( ArgValue )
 722             cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << d << " (double)"
 723                    << " Result->ob_refcnt" << Result->ob_refcnt << " ArgValue->ob_refcnt"
 724                    << ArgValue->ob_refcnt << endl ;
 725 #endif
 726           break ;
 727         }
 728         case CORBA::tk_objref : {
 729           PyObject * ObjIor ;
 730           //MyPyObjIorList = PyTuple_New( 1 ) ;
 731           if ( PyTuple_Check( Result ) ) {
 732             ObjIor = PyTuple_GetItem( Result , i ) ;
 733           }
 734           else {
 735             ObjIor = Result ;
 736           }
 737 #if PyDynInvokeTrace
 738           if ( ObjIor )
 739             cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << "(object reference) "
 740                    << " Result->ob_refcnt" << Result->ob_refcnt << " ObjIor->ob_refcnt"
 741                    << ObjIor->ob_refcnt << endl ;
 742 #endif
 743           //Py_INCREF( ObjIor ) ;
 744 //          PyObject_Print( ObjIor , stdout , 0 ) ;
 745           //PyTuple_SetItem( MyPyObjIorList , 0 , ObjIor ) ;
 746 //          ResultIor = PyEval_CallObject( MyPyObjIor , MyPyObjIorList ) ;
 747           //ResultIor = PyEvalCallObject( "PyObjIor" , MyPyObjIor , MyPyObjIorList ) ;
 748           ResultIor = PyObject_CallFunction( MyPyObjIor , "O",ObjIor ) ;
 749 #if PyDynInvokeTrace
 750           if ( ObjIor )
 751             cdebug << "ObjIor->ob_refcnt " << ObjIor->ob_refcnt-1 << endl ;
 752 #endif
 753           //Py_DECREF( ObjIor ) ;
 754 #if PyDynInvokeTrace
 755           //cdebug << "MyPyObjIorList->ob_refcnt " << MyPyObjIorList->ob_refcnt-1 << endl ;
 756 #endif
 757           //Py_DECREF( MyPyObjIorList ) ;
 758 #if PyDynInvokeTrace
 759           //cdebug << "MyPyObjIor->ob_refcnt " << MyPyObjIor->ob_refcnt << endl ;
 760 #endif
 761           if ( ResultIor ) {
 762             char * IOR = NULL ;
 763             IOR = PyString_AsString( ResultIor ) ;
 764             ObjRef = StringToObject( IOR ) ;
 765 //JR 05.08.2005 BUG OMNIORB4 ? : that line does run with SALOME_3 (OMNIOrb4) for
 766 //                               object references ... (It's Ok with OMNIOrb3)
 767 //                               IOR and ObjRef and IORObjRef are Ok
 768 //                               BUT data contains a nil reference !!!
 769 #if !omniORB_4_0_5
 770             data <<= ObjRef ;
 771 #else
 772             SUPERV::SuperG_var mySuperVisionComponent ;
 773             mySuperVisionComponent = theAutomaton->SuperVisionComponent() ;
 774             if ( CORBA::is_nil( mySuperVisionComponent ) ) {
 775               Engines::Container_var myContainer ;
 776               Engines::Component_var myObjComponent ;
 777               _OutNode->Graph()->StartComponent( ThreadNo() , "SuperVisionContainer" ,
 778                                                  "SUPERV" ,
 779                                                  myContainer , myObjComponent ) ;
 780               mySuperVisionComponent = SUPERV::SuperG::_narrow( myObjComponent ) ;
 781               theAutomaton->SuperVisionComponent( mySuperVisionComponent ) ;
 782             }
 783 //JR 24.08.2005 BUG OMNIORB4 ? : That does not run also ==> Comments
 784 //            CORBA::Object_ptr ObjRef1 ;
 785 //            ObjRef1 = mySuperVisionComponent->ToObject( ObjRef ) ;
 786 //            data <<= ObjRef1 ;
 787 //JR 24.08.2005 BUG OMNIORB4 ? : BUT THAT RUNS WITH THE "IDENTITY METHOD ToObject of SUPERV.idl :
 788 //                               Object ToObject( in Object anObject ) ;
 789 //CODE of that method !!! :
 790 //CORBA::Object_ptr SuperV_Impl::ToObject( CORBA::Object_ptr anObjectRef ) {
 791 //  beginService( "SuperV_Impl::ToObject" );
 792 //  CORBA::Object_ptr anObject ;
 793 //  anObject = CORBA::Object::_duplicate( anObjectRef ) ;
 794 //  endService( "SuperV_Impl::ToObject" );
 795 //  return anObject ;
 796 //}
 797 //BUT THAT RUNS ONLY IF WE USE Dynamic invocation of CORBA (DynInvoke)
 798             ServicesAnyData anInParametersList ;
 799             anInParametersList.Name = "anObjRef" ;
 800             anInParametersList.Value <<= ObjRef ;
 801             DynInvoke( mySuperVisionComponent , "ToObject" ,
 802                        &anInParametersList , 1 , &OutParametersList[i] , 1 ) ;
 803             data = OutParametersList[i].Value ;
 804 #endif
 805             IORObjRef = ObjectToString( ObjRef ) ;
 806 #if PyDynInvokeTrace
 807             cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value IORPy "
 808                    << IOR << " IORObjRef " << IORObjRef << " (objref) " << endl ;
 809 #endif
 810             if ( CORBA::is_nil( ObjRef ) ) {
 811 #if PyDynInvokeTrace
 812               cdebug << "ObjRef ERROR(nil reference) ResultIor->ob_refcnt "
 813                      << ResultIor->ob_refcnt-1 << endl ;
 814 #endif
 815               ResultIor = NULL ;
 816             }
 817             else {
 818 #if PyDynInvokeTrace
 819               cdebug << "ObjRef NOT(nil reference)ResultIor->ob_refcnt "
 820                      << ResultIor->ob_refcnt-1 << endl ;
 821 #endif
 822               Py_DECREF( ResultIor ) ;
 823             }
 824           }
 825           else {
 826             PyErr_Print();
 827             cdebug_out << "GraphExecutor::InNode::PyDynInvoke Error ResultIor == NULL Node "
 828                        << Name() << " method " << method << " " << endl ;
 829             RetVal = false ;
 830           }
 831           break ;
 832         }
 833         default : {
 834           cdebug << "ArgOut" << i << " : " << sname << " " << method << " Value " << "(other ERROR)" << endl ;
 835             RetVal = false ;
 836         }
 837         }
 838 //JR 05.08.2005 BUG OMNIORB4 ? : that line does run with SALOME_3 (OMNIOrb4) for
 839 //                               object references ...
 840         OutParametersList[i].Value = data ;
 841 //        if ( data.type()->kind() == CORBA::tk_objref ) {
 842 //          IORObjRef = ObjectToString( ObjRef ) ;
 843 //#if PyDynInvokeTrace
 844 //          cdebug << ThreadNo() << "GraphExecutor::InNode::PyDynInvoke Node " << Name()
 845 //                 << "ArgOut" << i << " : " << sname << " " << method << " ObjRef "
 846 //                 << IORObjRef << " (objref) " << endl ;
 847 //          Engines::Component_var theObjComponent ;
 848 //          theObjComponent = Engines::Component::_narrow( ObjRef ) ;
 849 //          DynInvoke( theObjComponent , "ping" , NULL , 0 , NULL , 0 ) ;
 850 //#endif
 851 //          Engines::Container_var myContainer ;
 852 //          Engines::Component_var myObjComponent ;
 853 //          _OutNode->Graph()->StartComponent( ThreadNo() , "SuperVisionContainer" ,
 854 //                                             "SUPERV" ,
 855 //                                              myContainer , myObjComponent ) ;
 856 //          SUPERV::SuperG_var mySuperVisionComponent ;
 857 //          mySuperVisionComponent = SUPERV::SuperG::_narrow( myObjComponent ) ;
 858 //          CORBA::Object_ptr ObjRef1 ;
 859 //          ObjRef1 = mySuperVisionComponent->ToObject( IORObjRef ) ;
 860 //#if PyDynInvokeTrace
 861 //          IORObjRef = ObjectToString( ObjRef1 ) ;
 862 //          cdebug << ThreadNo() << "GraphExecutor::InNode::PyDynInvoke Node " << Name()
 863 //                 << "ArgOut" << i << " : " << sname << " " << method << " ToObject "
 864 //                 << IORObjRef << " (objref) " << endl ;
 865 //#endif
 866
 867 //          ServicesAnyData anInParametersList ;
 868 //          anInParametersList.Name = "anIORObjRef" ;
 869 //          anInParametersList.Value <<= IORObjRef ;
 870 //          DynInvoke( mySuperVisionComponent , "ToObject" ,
 871 //                     &anInParametersList , 1 , &OutParametersList[i] , 1 ) ;
 872 //#if PyDynInvokeTrace
 873 //          OutParametersList[i].Value >>= ObjRef1 ;
 874 //          IORObjRef = ObjectToString( ObjRef1 ) ;
 875 //          cdebug << ThreadNo() << "GraphExecutor::InNode::PyDynInvoke Node " << Name()
 876 //                 << "ArgOut" << i << " : " << sname << " " << method
 877 //                 << " DynInvoke(ToObject) " << IORObjRef << " (objref) " << endl ;
 878 //#endif
 879 //        }
 880       }
 881
 882 #if PyDynInvokeTrace
 883       cdebug << "InNode::PyDynInvoke Result->ob_refcnt " << Result->ob_refcnt-1 << endl ;
 884 #endif
 885       Py_DECREF( Result ) ;
 886     }
 887
 888 #if PyDynInvokeTrace
 889     cdebug << "InNode::PyDynInvoke ArgsList->ob_refcnt " << ArgsList->ob_refcnt-1 << endl ;
 890 #endif
 891     Py_DECREF( ArgsList ) ;
 892   }
 893
 894   fflush(stdout);
 895   fflush(stderr);
 896
 897 #if 0
 898   {
 899     int i ;
 900     for ( i = 0 ; i < nInParams ; i++ ) { // Without Gates
 901       cdebug << "InParametersList[" << i << "] : "
 902              << InParametersList[i].Name << " "
 903              << AnyValue( InParametersList[i].Value ) << endl ;
 904     }
 905     for ( i = 0 ; i < nOutParams ; i++ ) { // Without Gates
 906       cdebug << "OutParametersList[" << i << "] : "
 907              << OutParametersList[i].Name << " "
 908              << AnyValue( OutParametersList[i].Value ) << endl ;
 909     }
 910   }
 911 #endif
 912
 913 #if PyDynInvokeTrace
 914   cdebug_out << "GraphExecutor::InNode::PyDynInvoke Node " << Name() << " method " << method << " " << RetVal
 915              << endl ;
 916 #endif
 917
 918   return RetVal ;
 919
 920 }
 921
 922 bool GraphExecutor::InNode::PyRunSimpleString( char* thePyString )
 923 {
 924   const bool ErrorValue = true;
 925   bool aRet;
 926   try {
 927 #if PyDynInvokeTrace
 928     MESSAGE( pthread_self() << "Python method beginning : " << thePyString );
 929     cdebug_in << pthread_self() << "Python method beginning : " << thePyString << endl ;
 930 #endif
 931     aRet = PyRun_SimpleString( thePyString );
 932     // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL
 933     //aRet = _OutNode->SuperVisionContainer()->ActivatePythonExecution( thePyString ) ;
 934 #if PyDynInvokeTrace
 935     MESSAGE( pthread_self() << "Python method finished." );
 936     cdebug_out << pthread_self() << "Python method finished." << endl ;
 937 #endif
 938   } catch( ... ) {
 939     MESSAGE( pthread_self() << "ERROR: Exception caught running Python method." );
 940     cdebug_out << pthread_self() << "ERROR: Exception caught running Python method."
 941                << endl ;
 942     MESSAGE( "       Python was reinitialized.  Previous Python definitions are lost" );
 943     // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL
 944     Py_Finalize();
 945     Py_Initialize();
 946     Py_InitModule( "InitPyRunMethod" , MethodPyRunMethod );
 947     _OutNode->PyInitialized( false );
 948     aRet = ErrorValue;
 949   }
 950   return aRet;
 951 }
 952
 953 PyObject * GraphExecutor::InNode::PyEvalCallObject( const char *method ,
 954                                                     PyObject * MyPyRunMethod ,
 955                                                     PyObject * ArgsList ) {
 956 //  cdebug_in << "Executor::InNode::PyEvalCallObject " << Name() << endl ;
 957   PyObject * Result = NULL ;
 958   try {
 959 //    MESSAGE( pthread_self() << "PyEval_CallObject " << Name() << " method beginning : " << method );
 960 //    cdebug << pthread_self() << "PyEval_CallObject " << Name() << " method beginning : " << method << endl ;
 961     Result = PyEval_CallObject( MyPyRunMethod , ArgsList ) ;
 962     // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL
 963     //Result = _OutNode->SuperVisionContainer()->ActivatePythonExecution( MyPyRunMethod , ArgsList ) ;
 964 //    MESSAGE( pthread_self() << "PyEval_CallObject method finished. Result " << Result );
 965 //    cdebug << pthread_self() << "PyEval_CallObject method finished. Result " << Result << endl ;
 966 //    cdebug_out << "Executor::InNode::PyEvalCallObject " << Name() << endl ;
 967   } catch( ... ) {
 968     MESSAGE( pthread_self() << "ERROR: Exception caught PyEval_CallObject " << Name()
 969              << " Python method " << method << ". Result "  << Result );
 970     cdebug << pthread_self() << "ERROR: Exception caught PyEval_CallObject " << Name()
 971            << " Python method " << method << ". Result " << Result << endl ;
 972     MESSAGE( "       Python was reinitialized.  Previous Python definitions are lost Py_IsInitialized " << Py_IsInitialized() );
 973 //JR ===> fatal error in python : no current thread
 974     // asv : 20.01.05 : changes involved with switching to old (HEAD) KERNEL
 975     Py_Finalize();
 976     Py_Initialize();
 977     Automaton()->PyInitModule( false ) ;
 978     Py_InitModule( "InitPyRunMethod" , MethodPyRunMethod );
 979     _OutNode->PyInitialized( false );
 980
 981     if ( Result == NULL ) {
 982       Kill() ; // Reset of _ThreadId
 983     }
 984 //    cdebug << "Executor::InNode::PyEvalCallObject ERROR catched " << Name()
 985 //           << " Py_IsInitialized " << Py_IsInitialized() << endl ;
 986   }
 987 //  cdebug_out << "Executor::InNode::PyEvalCallObject " << Name() << endl ;
 988   return Result ;
 989 }