X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2FRuntimeSALOME.cxx;h=99f57715231a2a5b4b84e12db0a0226586217b13;hb=a56cc6bd1a9d98794979c2b9910d278e06400756;hp=da74e14ca31396bc5da1f979dabe445071f8007b;hpb=d50ee7194808ecd640e806fdf9012ff64af452ab;p=modules%2Fyacs.git

diff --git a/src/runtime/RuntimeSALOME.cxx b/src/runtime/RuntimeSALOME.cxx
index da74e14ca..99f577152 100644
--- a/src/runtime/RuntimeSALOME.cxx
+++ b/src/runtime/RuntimeSALOME.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2006-2014  CEA/DEN, EDF R&D
+// Copyright (C) 2006-2021  CEA/DEN, EDF R&D
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
@@ -35,6 +35,7 @@
 #include "TypeCode.hxx"
 #include "WhileLoop.hxx"
 #include "ForLoop.hxx"
+#include "ForEachLoop.hxx"
 #include "SalomeOptimizerLoop.hxx"
 #include "Bloc.hxx"
 #include "InputPort.hxx"
@@ -42,6 +43,7 @@
 #include "PresetPorts.hxx"
 #include "InputDataStreamPort.hxx"
 #include "OutputDataStreamPort.hxx"
+#include "Switch.hxx"
 #include "SalomeProc.hxx"
 #include "PyStdout.hxx"
 //Catalog Loaders
@@ -50,11 +52,13 @@
 //Components
 #include "CORBAComponent.hxx"
 #include "SalomeComponent.hxx"
+#include "SalomeHPComponent.hxx"
 #include "SalomePythonComponent.hxx"
 #include "CppComponent.hxx"
 
 #include "SalomeContainer.hxx"
 #include "CppContainer.hxx"
+#include "SalomeHPContainer.hxx"
 
 //Nodes
 #include "PythonNode.hxx"
@@ -108,6 +112,12 @@
 #ifdef SALOME_KERNEL
 #include "SALOME_NamingService.hxx"
 #include "SALOME_LifeCycleCORBA.hxx"
+#include "SALOME_NamingService.hxx"
+#include "SALOME_ResourcesManager.hxx"
+#include "SALOME_ContainerManager.hxx"
+#include "SALOMEconfig.h"
+#include CORBA_CLIENT_HEADER(SALOME_ContainerManager)
+
 #endif
   
 #include <libxml/parser.h>
@@ -135,8 +145,8 @@ void RuntimeSALOME::setRuntime(long flags, int argc, char* argv[]) // singleton
 
 RuntimeSALOME* YACS::ENGINE::getSALOMERuntime()
 {
-  YASSERT(Runtime::_singleton);
-  return dynamic_cast< RuntimeSALOME* >(Runtime::_singleton);
+  YASSERT(RuntimeSALOME::getSingleton());
+  return dynamic_cast< RuntimeSALOME* >(RuntimeSALOME::getSingleton());
 }
 
 /**
@@ -177,6 +187,16 @@ void RuntimeSALOME::initBuiltins()
   typeMap["seqboolvec"]= createSequenceTc("seqboolvec","seqboolvec",typeMap["boolvec"]);
   std::list<TypeCodeObjref *> ltc;
   typeMap["pyobj"]= createInterfaceTc("python:obj:1.0","pyobj",ltc);
+  typeMap["seqpyobj"]= createSequenceTc("seqpyobj","seqpyobj",typeMap["pyobj"]);
+  composednodeMap["Bloc"]=createBloc("Bloc");
+  composednodeMap["Switch"]=createSwitch("Switch");
+  composednodeMap["WhileLoop"]=createWhileLoop("WhileLoop");
+  composednodeMap["ForLoop"]=createForLoop("ForLoop");
+  composednodeMap["ForEachLoop_double"]=createForEachLoop("ForEachLoop_double",Runtime::_tc_double);
+  composednodeMap["ForEachLoop_string"]=createForEachLoop("ForEachLoop_string",Runtime::_tc_string);
+  composednodeMap["ForEachLoop_int"]=createForEachLoop("ForEachLoop_int",Runtime::_tc_int);
+  composednodeMap["ForEachLoop_bool"]=createForEachLoop("ForEachLoop_bool",Runtime::_tc_bool);
+  composednodeMap["ForEachLoop_pyobj"]=createForEachLoop("ForEachLoop_pyobj",typeMap["pyobj"]);;
   ENGINE::TypeCodeStruct *t = createStructTc("","Engines/dataref");
   t->addMember("ref",_tc_string);
   typeMap["dataref"]= t;
@@ -273,16 +293,30 @@ void RuntimeSALOME::init(long flags, int argc, char* argv[])
           Py_InitializeEx(0); // do not install signal handlers
 #endif
           if (argc > 0 && argv != NULL)
-            PySys_SetArgv(argc, argv);
+            {
+              wchar_t **changed_argv = new wchar_t*[argc];
+              for (int i = 0; i < argc; i++)
+              {
+                changed_argv[i] = Py_DecodeLocale(argv[i], NULL);
+              }
+              PySys_SetArgv(argc, changed_argv);
+            } 
           else
             {
               int pyArgc = 1;
               char* pyArgv[1];
               char defaultName[] = "SALOME_YACS_RUNTIME";
+              wchar_t **changed_pyArgv = new wchar_t*[pyArgc];
               pyArgv[0] = defaultName;
-              PySys_SetArgv(pyArgc, pyArgv);
+              for (int i = 0; i < pyArgc; i++)
+              {
+                changed_pyArgv[i] = Py_DecodeLocale(pyArgv[i], NULL);
+              }
+              PySys_SetArgv(pyArgc, changed_pyArgv);
             }
+#if PY_VERSION_HEX < 0x03070000
           PyEval_InitThreads(); /* Create (and acquire) the interpreter lock (for threads)*/
+#endif
           PyEval_SaveThread(); /* Release the thread state */
           //here we do not have the Global Interpreter Lock
         }
@@ -298,7 +332,7 @@ void RuntimeSALOME::init(long flags, int argc, char* argv[])
   
       if (PyDict_GetItemString(globals, "__builtins__") == NULL) 
         {
-          PyObject *bimod = PyImport_ImportModule("__builtin__");
+          PyObject *bimod = PyImport_ImportModule("builtins");
           if (bimod == NULL || PyDict_SetItemString(globals, "__builtins__", bimod) != 0)
             Py_FatalError("can't add __builtins__ to __main__");
           Py_DECREF(bimod);
@@ -322,7 +356,7 @@ void RuntimeSALOME::init(long flags, int argc, char* argv[])
             {
               goto out;
             }
-          _api = (omniORBpyAPI*)PyCObject_AsVoidPtr(pyapi);
+          _api = (omniORBpyAPI*)PyCapsule_GetPointer(pyapi,"_omnipy.API");
           Py_DECREF(pyapi);
 
           res=PyRun_String("\n"
@@ -332,7 +366,7 @@ void RuntimeSALOME::init(long flags, int argc, char* argv[])
                            "from omniORB import CORBA\n"
                            "from omniORB import any\n"
                            "orb = CORBA.ORB_init([], CORBA.ORB_ID)\n"
-                           "#print sys.getrefcount(orb)\n"
+                           "#print(sys.getrefcount(orb))\n"
                            "try:\n"
                            "  import SALOME\n"
                            "except:\n"
@@ -414,6 +448,64 @@ void RuntimeSALOME::fini()
     }
 }
 
+std::vector< std::pair<std::string,int> > RuntimeSALOME::getCatalogOfComputeNodes() const
+{
+  CORBA::ORB_ptr orb(getOrb());
+  SALOME_NamingService namingService;
+  try
+  {
+    namingService.init_orb(orb);
+  }
+  catch(SALOME_Exception& e)
+  {
+    throw Exception("RuntimeSALOME::getCatalogOfComputeNodes : Unable to contact the SALOME Naming Service");
+  }
+  CORBA::Object_var obj(namingService.Resolve(SALOME_ResourcesManager::_ResourcesManagerNameInNS));
+  if(CORBA::is_nil(obj))
+    throw Exception("RuntimeSALOME::getCatalogOfComputeNodes : Unable to access to the resource manager !");
+  Engines::ResourcesManager_var resManager(Engines::ResourcesManager::_narrow(obj));
+  if(CORBA::is_nil(resManager))
+    throw Exception("RuntimeSALOME::getCatalogOfComputeNodes : Internal error ! The entry attached to the res manager in NS does not have right type !");
+  std::vector< std::pair<std::string,int> > ret;
+  Engines::ResourceParameters params;
+  params.name = "";
+  params.hostname = "";
+  params.OS = "";
+  params.nb_proc = 0;
+  params.mem_mb = 0;
+  params.cpu_clock = 0;
+  params.nb_node = 0;
+  params.nb_proc_per_node = 0;
+  params.policy = "";
+  params.can_launch_batch_jobs = false;
+  params.can_run_containers = true;
+  params.componentList.length(0);
+  try
+  {
+    Engines::ResourceList_var resourceList;
+    resourceList = resManager->GetFittingResources(params);
+    ret.reserve(resourceList->length());
+    for(int i = 0; i<resourceList->length(); i++)
+    {
+      const char* resource_name = resourceList[i];
+      std::string std_resource_name = resource_name;
+      Engines::ResourceDefinition_var resource_definition
+                              = resManager->GetResourceDefinition(resource_name);
+      int nb_cores = resource_definition->nb_node *
+                     resource_definition->nb_proc_per_node;
+      ret.push_back(std::pair<std::string,int>(resource_name, nb_cores));
+    }
+  }
+  catch(SALOME::SALOME_Exception& e)
+  {
+    std::string message;
+    message=e.details.text.in();
+    throw Exception(message);
+  }
+
+  return ret;
+}
+
 std::string RuntimeSALOME::getVersion() const
 {
 #ifdef YACS_DEVELOPMENT
@@ -587,15 +679,19 @@ ComponentInstance* RuntimeSALOME::createComponentInstance(const std::string& nam
     return new SalomePythonComponent(name);
   else if (kind == CppComponent::KIND)
     return new CppComponent(name);
+  else if (kind == SalomeHPComponent::KIND)
+    return new SalomeHPComponent(name);
   std::string msg="Component Instance kind ("+kind+") unknown";
   throw Exception(msg);
 }
 
 Container *RuntimeSALOME::createContainer(const std::string& kind)
 {
-  if(kind == "" || kind == SalomeComponent::KIND)
+  if(kind == "" || kind == SalomeContainer::KIND)
     return new SalomeContainer;
-  else if (kind == CppComponent::KIND)
+  if(kind==SalomeHPContainer::KIND)
+    return new SalomeHPContainer;
+  else if (kind == CppContainer::KIND)
     return new CppContainer;
   std::string msg="Container kind ("+kind+") unknown";
   throw Exception(msg);
@@ -626,7 +722,7 @@ InputPort * RuntimeSALOME::createInputPort(const std::string& name,
     {
       stringstream msg;
       msg << "Cannot create " << impl << " InputPort" ;
-      msg << " ("__FILE__ << ":" << __LINE__ << ")";
+      msg << " (" << __FILE__ << ":" << __LINE__ << ")";
       throw Exception(msg.str());
     }
 }
@@ -656,7 +752,7 @@ OutputPort * RuntimeSALOME::createOutputPort(const std::string& name,
     {
       stringstream msg;
       msg << "Cannot create " << impl << " OutputPort" ;
-      msg << " ("__FILE__ << ":" << __LINE__ << ")";
+      msg << " (" << __FILE__ << ":" << __LINE__ << ")";
       throw Exception(msg.str());
     }
 }
@@ -700,7 +796,7 @@ OutputDataStreamPort* RuntimeSALOME::createOutputDataStreamPort(const std::strin
  */
 InputPort* RuntimeSALOME::adapt(InputPort* source,
                                 const std::string& impl,
-                                TypeCode * type,bool init) throw (ConversionException)
+                                TypeCode * type,bool init)
 {
   string imp_source=source->getNode()->getImplementation();
   if(imp_source == PythonNode::IMPL_NAME)
@@ -727,7 +823,7 @@ InputPort* RuntimeSALOME::adapt(InputPort* source,
     {
       stringstream msg;
       msg << "Cannot adapt " << imp_source << " InputPort to " << impl;
-      msg << " ("__FILE__ << ":" << __LINE__ << ")";
+      msg << " (" << __FILE__ << ":" << __LINE__ << ")";
       throw ConversionException(msg.str());
     }
 }
@@ -743,7 +839,7 @@ InputPort* RuntimeSALOME::adapt(InputPort* source,
  */
 InputPort* RuntimeSALOME::adapt(InPropertyPort* source,
                                 const std::string& impl,
-                                TypeCode * type,bool init) throw (ConversionException)
+                                TypeCode * type,bool init)
 {
   return adaptNeutral((InputPort *)source,impl,type,init);
 }
@@ -755,7 +851,7 @@ InputPort* RuntimeSALOME::adapt(InPropertyPort* source,
  *   \return an adaptated input port of type InputCorbaPort
  */
 InputPort* RuntimeSALOME::adaptNeutralToCorba(InputPort* inport,
-                      TypeCode * type) throw (ConversionException)
+                      TypeCode * type)
 {
   // BEWARE : using the generic check
   if(inport->edGetType()->isAdaptable(type))
@@ -780,7 +876,7 @@ InputPort* RuntimeSALOME::adaptNeutralToCorba(InputPort* inport,
  *   \return an adaptated input port of type InputPyPort
  */
 InputPort* RuntimeSALOME::adaptNeutralToPython(InputPort* inport,
-                      TypeCode * type) throw (ConversionException)
+                      TypeCode * type)
 {
   // BEWARE : using the generic check
   if(inport->edGetType()->isAdaptable(type))
@@ -788,6 +884,11 @@ InputPort* RuntimeSALOME::adaptNeutralToPython(InputPort* inport,
       //convertible type
       return new PyNeutral(inport);
     }
+  //last chance : an py output that is seq[objref] can be connected to a neutral input objref (P13268)
+  else if(type->kind()==Sequence && type->contentType()->kind()==Objref && inport->edGetType()->kind()==Objref)
+    {
+      return new PyNeutral(inport);
+    }
   //non convertible type
   stringstream msg;
   msg << "Cannot connect Python output port with type: " << type->id() ;
@@ -805,7 +906,7 @@ InputPort* RuntimeSALOME::adaptNeutralToPython(InputPort* inport,
  *   \return an input port of type InputXmlPort
  */
 InputPort* RuntimeSALOME::adaptNeutralToXml(InputPort* inport,
-                      TypeCode * type) throw (ConversionException)
+                      TypeCode * type)
 {
   // BEWARE : using the generic check
   if(inport->edGetType()->isAdaptable(type))
@@ -830,7 +931,7 @@ InputPort* RuntimeSALOME::adaptNeutralToXml(InputPort* inport,
  *   \return an input port of type InputCppPort
  */
 InputPort* RuntimeSALOME::adaptNeutralToCpp(InputPort* inport,
-                      TypeCode * type) throw (ConversionException)
+                      TypeCode * type)
 {
   DEBTRACE("RuntimeSALOME::adaptNeutralToCpp(InputPort* inport" );
   if(isAdaptableNeutralCpp(type,inport->edGetType()))
@@ -858,7 +959,7 @@ InputPort* RuntimeSALOME::adaptNeutralToCpp(InputPort* inport,
  */
 InputPort* RuntimeSALOME::adaptNeutral(InputPort* source,
                                        const std::string& impl,
-                                       TypeCode * type,bool init) throw (ConversionException)
+                                       TypeCode * type,bool init)
 {
   if(impl == CppNode::IMPL_NAME)
     {
@@ -897,7 +998,7 @@ InputPort* RuntimeSALOME::adaptNeutral(InputPort* source,
  */
 
 InputPort* RuntimeSALOME::adaptXmlToCorba(InputXmlPort* inport,
-                                          TypeCode * type) throw (ConversionException)
+                                          TypeCode * type)
 {
   if(isAdaptableXmlCorba(type,inport->edGetType()))
     {
@@ -921,7 +1022,7 @@ InputPort* RuntimeSALOME::adaptXmlToCorba(InputXmlPort* inport,
  *   \return an adaptated input port of type InputPyPort
  */
 InputPort* RuntimeSALOME::adaptXmlToPython(InputXmlPort* inport,
-                      TypeCode * type) throw (ConversionException)
+                      TypeCode * type)
 {
   if(inport->edGetType()->isAdaptable(type))
     {
@@ -945,7 +1046,7 @@ InputPort* RuntimeSALOME::adaptXmlToPython(InputXmlPort* inport,
  *   \return an adaptated input port of type InputPyPort
  */
 InputPort* RuntimeSALOME::adaptXmlToCpp(InputXmlPort* inport,
-                      TypeCode * type) throw (ConversionException)
+                      TypeCode * type)
 {
   DEBTRACE("RuntimeSALOME::adaptXmlToCpp(InputPort* inport" );
   DEBTRACE(type->kind() << "   " << inport->edGetType()->kind() );
@@ -971,7 +1072,7 @@ InputPort* RuntimeSALOME::adaptXmlToCpp(InputXmlPort* inport,
  *   \return an adaptated input port of type Neutralxxxx
  */
 InputPort* RuntimeSALOME::adaptXmlToNeutral(InputXmlPort* inport,
-                      TypeCode * type) throw (ConversionException)
+                      TypeCode * type)
 {
   if(inport->edGetType()->isAdaptable(type))
     {
@@ -993,7 +1094,7 @@ InputPort* RuntimeSALOME::adaptXmlToNeutral(InputXmlPort* inport,
  *   \return an adaptated input port of type Xmlxxxx
  */
 InputPort* RuntimeSALOME::adaptXmlToXml(InputXmlPort* inport,
-                      TypeCode * type,bool init) throw (ConversionException)
+                      TypeCode * type,bool init)
 {
   if(init)
     return new ProxyPort(inport);
@@ -1021,7 +1122,7 @@ InputPort* RuntimeSALOME::adaptXmlToXml(InputXmlPort* inport,
 
 InputPort* RuntimeSALOME::adapt(InputXmlPort* source,
                                 const std::string& impl,
-                                TypeCode * type,bool init) throw (ConversionException)
+                                TypeCode * type,bool init)
 {
   if(impl == CORBANode::IMPL_NAME)
     {
@@ -1047,7 +1148,7 @@ InputPort* RuntimeSALOME::adapt(InputXmlPort* source,
     {
       stringstream msg;
       msg << "Cannot connect InputXmlPort to " << impl << " implementation";
-      msg << " ("__FILE__ << ":" << __LINE__ << ")";
+      msg << " (" << __FILE__ << ":" << __LINE__ << ")";
       throw ConversionException(msg.str());
     }
 }
@@ -1060,7 +1161,7 @@ InputPort* RuntimeSALOME::adapt(InputXmlPort* source,
  *   \return an adaptator port of type InputCORBAPort 
  */
 InputPort* RuntimeSALOME::adaptCorbaToCorba(InputCorbaPort* inport,
-                                            TypeCode * type) throw (ConversionException)
+                                            TypeCode * type)
 {
   if(type->isA(inport->edGetType()))
     {
@@ -1092,7 +1193,7 @@ InputPort* RuntimeSALOME::adaptCorbaToCorba(InputCorbaPort* inport,
  */
 
 InputPort* RuntimeSALOME::adaptCorbaToPython(InputCorbaPort* inport,
-                                             TypeCode * type) throw (ConversionException)
+                                             TypeCode * type)
 {
   if(inport->edGetType()->kind() == Double)
     {
@@ -1171,7 +1272,7 @@ InputPort* RuntimeSALOME::adaptCorbaToPython(InputCorbaPort* inport,
  */
 
 InputPort* RuntimeSALOME::adaptCorbaToXml(InputCorbaPort* inport,
-                                          TypeCode * type) throw (ConversionException)
+                                          TypeCode * type)
 {
   // BEWARE : using the generic check
   if(inport->edGetType()->isAdaptable(type))
@@ -1197,7 +1298,7 @@ InputPort* RuntimeSALOME::adaptCorbaToXml(InputCorbaPort* inport,
  */
 
 InputPort* RuntimeSALOME::adaptCorbaToCpp(InputCorbaPort* inport,
-                                          TypeCode * type) throw (ConversionException)
+                                          TypeCode * type)
 {
   DEBTRACE("RuntimeSALOME::adaptCorbaToCpp(InputCorbaPort* inport" );
   if(isAdaptableCorbaCpp(type,inport->edGetType()))
@@ -1223,7 +1324,7 @@ InputPort* RuntimeSALOME::adaptCorbaToCpp(InputCorbaPort* inport,
  */
 
 InputPort* RuntimeSALOME::adaptCorbaToNeutral(InputCorbaPort* inport,
-                                              TypeCode * type) throw (ConversionException)
+                                              TypeCode * type)
 {
   if(inport->edGetType()->kind() == Double)
     {
@@ -1283,7 +1384,7 @@ InputPort* RuntimeSALOME::adaptCorbaToNeutral(InputCorbaPort* inport,
 
 InputPort* RuntimeSALOME::adapt(InputCorbaPort* source,
                                 const std::string& impl,
-                                TypeCode * type,bool init) throw (ConversionException)
+                                TypeCode * type,bool init)
 {
   if(impl == CppNode::IMPL_NAME)
     {
@@ -1328,7 +1429,7 @@ InputPort* RuntimeSALOME::adapt(InputCorbaPort* source,
  */
 
 InputPort* RuntimeSALOME::adaptPythonToPython(InputPyPort* inport,
-                                              TypeCode * type,bool init) throw (ConversionException)
+                                              TypeCode * type,bool init)
 {
   if(init)
     return new PyInit(inport);
@@ -1358,7 +1459,7 @@ InputPort* RuntimeSALOME::adaptPythonToPython(InputPyPort* inport,
  */
 
 InputPort* RuntimeSALOME::adaptPythonToCpp(InputPyPort* inport,
-                                           TypeCode * type) throw (ConversionException)
+                                           TypeCode * type)
 {
   DEBTRACE("RuntimeSALOME::adaptPythonToCpp(InputPyPort* inport" );
   if(isAdaptablePyObjectCpp(type,inport->edGetType()))
@@ -1384,7 +1485,7 @@ InputPort* RuntimeSALOME::adaptPythonToCpp(InputPyPort* inport,
  */
 
 InputPort* RuntimeSALOME::adaptPythonToNeutral(InputPyPort* inport,
-                                               TypeCode * type) throw (ConversionException)
+                                               TypeCode * type)
 {
   if(inport->edGetType()->kind() == Double)
     {
@@ -1442,7 +1543,7 @@ InputPort* RuntimeSALOME::adaptPythonToNeutral(InputPyPort* inport,
  */
 
 InputPort* RuntimeSALOME::adaptPythonToCorba(InputPyPort* inport,
-                                             TypeCode * type) throw (ConversionException)
+                                             TypeCode * type)
 {
   if(inport->edGetType()->kind() == Double)
     {
@@ -1520,7 +1621,7 @@ InputPort* RuntimeSALOME::adaptPythonToCorba(InputPyPort* inport,
  */
 
 InputPort* RuntimeSALOME::adaptPythonToXml(InputPyPort* inport,
-                                          TypeCode * type) throw (ConversionException)
+                                          TypeCode * type)
 {
   // BEWARE : using the generic check
   if(inport->edGetType()->isAdaptable(type))
@@ -1549,7 +1650,7 @@ InputPort* RuntimeSALOME::adaptPythonToXml(InputPyPort* inport,
 
 InputPort* RuntimeSALOME::adapt(InputPyPort* source,
                                 const std::string& impl,
-                                TypeCode * type,bool init) throw (ConversionException)
+                                TypeCode * type,bool init)
 {
   if(impl == CppNode::IMPL_NAME)
     {
@@ -1589,7 +1690,7 @@ InputPort* RuntimeSALOME::adapt(InputPyPort* source,
  */
 
 InputPort* RuntimeSALOME::adaptCppToCorba(InputCppPort* inport,
-                                          TypeCode * type) throw (ConversionException)
+                                          TypeCode * type)
 {
   DEBTRACE("RuntimeSALOME::adaptCppToCorba(InputCppPort* inport)");
   if(isAdaptableCppCorba(type,inport->edGetType()))
@@ -1614,7 +1715,7 @@ InputPort* RuntimeSALOME::adaptCppToCorba(InputCppPort* inport,
  *   \return an adaptated input port of type InputPyPort
  */
 InputPort* RuntimeSALOME::adaptCppToPython(InputCppPort* inport,
-                      TypeCode * type) throw (ConversionException)
+                      TypeCode * type)
 {
   DEBTRACE("RuntimeSALOME::adaptCppToPython(InputCppPort* inport)");
   if(isAdaptableCppPyObject(type,inport->edGetType()))
@@ -1639,7 +1740,7 @@ InputPort* RuntimeSALOME::adaptCppToPython(InputCppPort* inport,
  *   \return an adaptated input port of type InputPyPort
  */
 InputPort* RuntimeSALOME::adaptCppToCpp(InputCppPort* inport,
-                      TypeCode * type) throw (ConversionException)
+                      TypeCode * type)
 {
   DEBTRACE("RuntimeSALOME::adaptCppToCpp(InputPort* inport" );
   DEBTRACE(type->kind() << "   " << inport->edGetType()->kind() );
@@ -1665,7 +1766,7 @@ InputPort* RuntimeSALOME::adaptCppToCpp(InputCppPort* inport,
  *   \return an adaptated input port of type InputPyPort
  */
 InputPort* RuntimeSALOME::adaptCppToNeutral(InputCppPort* inport,
-                      TypeCode * type) throw (ConversionException)
+                      TypeCode * type)
 {
   DEBTRACE("RuntimeSALOME::adaptCppToNeutral(InputPort* inport" );
   DEBTRACE(type->kind() << "   " << inport->edGetType()->kind() );
@@ -1685,7 +1786,7 @@ InputPort* RuntimeSALOME::adaptCppToNeutral(InputCppPort* inport,
 }
 
 InputPort* RuntimeSALOME::adaptCppToXml(InputCppPort* inport,
-                      TypeCode * type) throw (ConversionException)
+                      TypeCode * type)
 {
   DEBTRACE("RuntimeSALOME::adaptCppToXml(InputCppPort* inport" );
   if(isAdaptableCppXml(type,inport->edGetType()))
@@ -1714,7 +1815,7 @@ InputPort* RuntimeSALOME::adaptCppToXml(InputCppPort* inport,
 
 InputPort* RuntimeSALOME::adapt(InputCppPort* source,
                                 const std::string& impl,
-                                TypeCode * type,bool init) throw (ConversionException)
+                                TypeCode * type,bool init)
 {
   DEBTRACE("RuntimeSALOME::adapt(InputCppPort* source)");
   if(impl == CORBANode::IMPL_NAME)
@@ -1741,7 +1842,7 @@ InputPort* RuntimeSALOME::adapt(InputCppPort* source,
     {
       stringstream msg;
       msg << "Cannot connect InputCppPort to " << impl << " implementation";
-      msg << " ("__FILE__ << ":" << __LINE__ << ")";
+      msg << " (" << __FILE__ << ":" << __LINE__ << ")";
       throw ConversionException(msg.str());
     }
 }
@@ -1753,22 +1854,22 @@ InputPort* RuntimeSALOME::adapt(InputCppPort* source,
 //   return result;
 // }
 
-CORBA::ORB_ptr RuntimeSALOME::getOrb()
+CORBA::ORB_ptr RuntimeSALOME::getOrb() const
 {
   return _orb;
 }
 
-PyObject * RuntimeSALOME::getPyOrb()
+PyObject * RuntimeSALOME::getPyOrb() const
 {
   return _pyorb;
 }
 
-PyObject * RuntimeSALOME::getBuiltins()
+PyObject * RuntimeSALOME::getBuiltins() const
 {
   return _bltins;
 }
 
-DynamicAny::DynAnyFactory_ptr RuntimeSALOME::getDynFactory()
+DynamicAny::DynAnyFactory_ptr RuntimeSALOME::getDynFactory() const
 {
   return _dynFactory;
 }
@@ -1799,6 +1900,10 @@ std::string RuntimeSALOME::convertNeutralAsString(TypeCode * type, Any *data)
   PyObject* ob;
   if(data)
     {
+      // The call to PyGILState_Ensure was moved here because there was also
+      // a crash when calling convertNeutralPyObject with a sequence of pyobj.
+      // see also the comment below.
+      PyGILState_STATE gstate = PyGILState_Ensure();
       ob=convertNeutralPyObject(type,data);
       std::string s=convertPyObjectToString(ob);
 
@@ -1807,7 +1912,7 @@ std::string RuntimeSALOME::convertNeutralAsString(TypeCode * type, Any *data)
       // lock. I thus added the call to PyGILState_Ensure / PyGILState_Release. It worked fine in
       // Python 2.6 without this call. If anyone finds the real reason of this bug and another fix,
       // feel free to change this code.
-      PyGILState_STATE gstate = PyGILState_Ensure();
+      //PyGILState_STATE gstate = PyGILState_Ensure();
       Py_DECREF(ob);
       PyGILState_Release(gstate);
       return s;