fight warnings c++17 error throw(). Build SMESH finished.

src/Controls/SMESH_ControlsDef.hxx

@@ -1214,8 +1214,8 @@ namespace SMESH{
     protected:
       PredicatePtr myPredicate;
     };
-  };
+  }
-};
+}
 
 
 #endif

src/Driver/Driver_Mesh.h

@@ -63,8 +63,8 @@ class MESHDRIVER_EXPORT Driver_Mesh
   virtual void        SetMeshName(const std::string& theMeshName);
   virtual std::string GetMeshName() const;
 
-  virtual void        SetOption(const std::string& optionName,
+  virtual void        SetOption(const std::string& /*optionName*/,
-                                const std::string& optionValue) {}
+                                const std::string& /*optionValue*/) {}
 
   virtual Status Perform() = 0;
 

src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx

@@ -112,7 +112,7 @@ void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes()
   myAllSubMeshes = true;
 }
 
-void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID)
+void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int /*theID*/)
 {
   mySubMeshes.push_back( theSubMesh );
 }

src/MEDWrapper/MED_Common.cxx

@@ -65,8 +65,8 @@ namespace MED
 
   TInt
   GetNbConn(EGeometrieElement typmai,
-            EEntiteMaillage typent,
+            EEntiteMaillage /*typent*/,
-            TInt mdim)
+            TInt /*mdim*/)
   {
     return typmai % 100;
   }

src/MEDWrapper/MED_CoordUtils.cxx

@@ -36,7 +36,7 @@ namespace MED
 
   template<>
   TFloat
-  GetCoord<eNone>(const TCCoordSlice& theCoordSlice)
+  GetCoord<eNone>(const TCCoordSlice& /*theCoordSlice*/)
   {
     return 0.0;
   }

src/MEDWrapper/MED_TStructures.hxx

@@ -930,7 +930,7 @@ namespace MED
                     const TGeom2Size& theGeom2Size,
                     const TGeom2NbGauss& theGeom2NbGauss,
                     TInt theNumDt,
-                    TInt theNumOrd,
+                    TInt /*theNumOrd*/,
                     TFloat theDt,
                     const std::string& theUnitDt,
                     const TGeom2Gauss& theGeom2Gauss)

src/MEDWrapper/MED_Wrapper.cxx

@@ -630,7 +630,7 @@ namespace MED
   void
   TWrapper
   ::GetNames(TElemInfo& theInfo,
-             TInt theNb,
+             TInt /*theNb*/,
              EEntiteMaillage theEntity,
              EGeometrieElement theGeom,
              TErr* theErr)
@@ -721,7 +721,7 @@ namespace MED
   void
   TWrapper
   ::GetNumeration(TElemInfo& theInfo,
-                  TInt theNb,
+                  TInt /*theNb*/,
                   EEntiteMaillage theEntity,
                   EGeometrieElement theGeom,
                   TErr* theErr)
@@ -812,7 +812,7 @@ namespace MED
   void
   TWrapper
   ::GetFamilies(TElemInfo& theInfo,
-                TInt theNb,
+                TInt /*theNb*/,
                 EEntiteMaillage theEntity,
                 EGeometrieElement theGeom,
                 TErr* theErr)
@@ -2323,7 +2323,7 @@ namespace MED
   //----------------------------------------------------------------------------
   EGeometrieElement
   TWrapper
-  ::GetBallGeom(const TMeshInfo& theMeshInfo)
+  ::GetBallGeom(const TMeshInfo& /*theMeshInfo*/)
   {
     TErr anError;
     TFileWrapper aFileWrapper(myFile, eLECTURE, &anError, myMinor);
@@ -2763,7 +2763,7 @@ namespace MED
   //----------------------------------------------------------------------------
   void
   TWrapper
-  ::GetGaussInfo(TInt theId,
+  ::GetGaussInfo(TInt /*theId*/,
                  TGaussInfo& theInfo,
                  TErr* theErr)
   {
@@ -3127,7 +3127,7 @@ namespace MED
   //----------------------------------------------------------------------------
   void
   TWrapper
-  ::GetProfileInfo(TInt theId,
+  ::GetProfileInfo(TInt /*theId*/,
                    TProfileInfo& theInfo,
                    TErr* theErr)
   {
@@ -4006,7 +4006,7 @@ namespace MED
   //----------------------------------------------------------------------------
   PGrilleInfo
   TWrapper
-  ::CrGrilleInfo(const PMeshInfo& theMeshInfo)
+  ::CrGrilleInfo(const PMeshInfo& /*theMeshInfo*/)
   {
     return PGrilleInfo(); // not implemented????
   }

src/SMDS/SMDS_Downward.cxx

@@ -122,7 +122,7 @@ int SMDS_Downward::addCell(int vtkId)
  *
  * @param cellId
  */
-void SMDS_Downward::initCell(int cellId)
+void SMDS_Downward::initCell(int /*cellId*/)
 {
 }
 
@@ -131,7 +131,7 @@ void SMDS_Downward::initCell(int cellId)
  * @param cellId not used here.
  * @return
  */
-int SMDS_Downward::getNumberOfDownCells(int cellId)
+int SMDS_Downward::getNumberOfDownCells(int /*cellId*/)
 {
   return _nbDownCells;
 }
@@ -154,7 +154,7 @@ const int* SMDS_Downward::getDownCells(int cellId)
  * @param cellId index of the cell in the downward structure relative to a vtk cell type.
  * @return table of downward entities types.
  */
-const unsigned char* SMDS_Downward::getDownTypes(int cellId)
+const unsigned char* SMDS_Downward::getDownTypes(int /*cellId*/)
 {
   return &_cellTypes[0];
 }
@@ -165,7 +165,7 @@ const unsigned char* SMDS_Downward::getDownTypes(int cellId)
  * @param lowCellId index of the children cell to add (dimension n-1)
  * @param aType vtk cell type of the cell to add (needed to find the SMDS_Downward structure containing the cell to add).
  */
-void SMDS_Downward::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_Downward::addDownCell(int /*cellId*/, int /*lowCellId*/, unsigned char /*aType*/)
 {
   ASSERT(0); // must be re-implemented in derived class
 }
@@ -176,12 +176,12 @@ void SMDS_Downward::addDownCell(int cellId, int lowCellId, unsigned char aType)
  * @param upCellId index of the parent cell to add (dimension n+1)
  * @param aType vtk cell type of the cell to add (needed to find the SMDS_Downward structure containing the cell to add).
  */
-void SMDS_Downward::addUpCell(int cellId, int upCellId, unsigned char aType)
+void SMDS_Downward::addUpCell(int /*cellId*/, int /*upCellId*/, unsigned char /*aType*/)
 {
   ASSERT(0); // must be re-implemented in derived class
 }
 
-int SMDS_Downward::getNodeSet(int cellId, int* nodeSet)
+int SMDS_Downward::getNodeSet(int /*cellId*/, int* /*nodeSet*/)
 {
   return 0;
 }
@@ -777,17 +777,17 @@ void SMDS_Down3D::compactStorage()
   // nothing to do, size was known before
 }
 
-int SMDS_Down3D::getNumberOfUpCells(int cellId)
+int SMDS_Down3D::getNumberOfUpCells(int /*cellId*/)
 {
   return 0;
 }
 
-const int* SMDS_Down3D::getUpCells(int cellId)
+const int* SMDS_Down3D::getUpCells(int /*cellId*/)
 {
   return 0;
 }
 
-const unsigned char* SMDS_Down3D::getUpTypes(int cellId)
+const unsigned char* SMDS_Down3D::getUpTypes(int /*cellId*/)
 {
   return 0;
 }
@@ -904,7 +904,7 @@ void SMDS_DownTriangle::computeEdgesWithNodes(int cellId, ListElemByNodesType& e
   edgesWithNodes.elems[2].vtkType = VTK_LINE;
 }
 
-void SMDS_DownTriangle::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownTriangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
 {
   //ASSERT((cellId >=0)&& (cellId < _maxId));
   //ASSERT(aType == VTK_LINE);
@@ -961,7 +961,7 @@ void SMDS_DownQuadTriangle::computeEdgesWithNodes(int cellId, ListElemByNodesTyp
   edgesWithNodes.elems[2].vtkType = VTK_QUADRATIC_EDGE;
 }
 
-void SMDS_DownQuadTriangle::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownQuadTriangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
 {
   //ASSERT((cellId >=0)&& (cellId < _maxId));
   //ASSERT(aType == VTK_QUADRATIC_EDGE);
@@ -1021,7 +1021,7 @@ void SMDS_DownQuadrangle::computeEdgesWithNodes(int cellId, ListElemByNodesType&
   edgesWithNodes.elems[3].vtkType = VTK_LINE;
 }
 
-void SMDS_DownQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
 {
   //ASSERT((cellId >=0)&& (cellId < _maxId));
   //ASSERT(aType == VTK_LINE);
@@ -1085,7 +1085,7 @@ void SMDS_DownQuadQuadrangle::computeEdgesWithNodes(int cellId, ListElemByNodesT
   edgesWithNodes.elems[3].vtkType = VTK_QUADRATIC_EDGE;
 }
 
-void SMDS_DownQuadQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownQuadQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
 {
   //ASSERT((cellId >=0)&& (cellId < _maxId));
   //ASSERT(aType == VTK_QUADRATIC_EDGE);
@@ -1150,7 +1150,7 @@ void SMDS_DownTetra::getOrderedNodesOfFace(int cellId, std::vector<vtkIdType>& o
   MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]);
 }
 
-void SMDS_DownTetra::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownTetra::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
 {
   //ASSERT((cellId >=0)&& (cellId < _maxId));
   //ASSERT(aType == VTK_TRIANGLE);
@@ -1258,7 +1258,7 @@ void SMDS_DownQuadTetra::getOrderedNodesOfFace(int cellId, std::vector<vtkIdType
   MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]);
 }
 
-void SMDS_DownQuadTetra::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownQuadTetra::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
 {
   //ASSERT((cellId >=0)&& (cellId < _maxId));
   //ASSERT(aType == VTK_QUADRATIC_TRIANGLE);
@@ -2006,7 +2006,7 @@ void SMDS_DownHexa::getOrderedNodesOfFace(int cellId, std::vector<vtkIdType>& or
   MESSAGE(nodes[4] << " " << nodes[5] << " " << nodes[6] << " " << nodes[7]);
 }
 
-void SMDS_DownHexa::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownHexa::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
 {
   //ASSERT((cellId >=0)&& (cellId < _maxId));
   int *faces = &_cellIds[_nbDownCells * cellId];
@@ -2137,7 +2137,7 @@ void SMDS_DownQuadHexa::getOrderedNodesOfFace(int cellId, std::vector<vtkIdType>
   MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]);
 }
 
-void SMDS_DownQuadHexa::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownQuadHexa::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
 {
   //ASSERT((cellId >=0)&& (cellId < _maxId));
   int *faces = &_cellIds[_nbDownCells * cellId];

src/SMDS/SMDS_Downward.hxx

@@ -77,8 +77,8 @@ public:
   virtual const int* getUpCells(int cellId) = 0;
   virtual const unsigned char* getUpTypes(int cellId) = 0;
   virtual void getNodeIds(int cellId, std::set<int>& nodeSet) = 0;
-  virtual int getNodes(int cellId, int* nodevec) {return 0; }
+  virtual int getNodes(int /*cellId*/, int* /*nodevec*/) {return 0; }
-  virtual void getOrderedNodesOfFace(int cellId, std::vector<vtkIdType>& orderedNodes) {};
+  virtual void getOrderedNodesOfFace(int /*cellId*/, std::vector<vtkIdType>& /*orderedNodes*/) {};
   int getVtkCellId(int cellId)
   {
     return _vtkCellIds[cellId];

src/SMDS/SMDS_ElementFactory.hxx

@@ -417,7 +417,7 @@ public:
   { min = false; max = true; return myUsedRanges; }
 
   //! Return ranges of elements assigned to sub-shapes and min/max of sub-shape IDs
-  const TSubIDRangeSet& GetSubIDRangesMinMax( int& min, int& max ) const
+  const TSubIDRangeSet& GetSubIDRangesMinMax( int& /*min*/, int& /*max*/ ) const
   { /*min = myMinSubID; max = myMaxSubID;*/ return mySubIDRanges; }
 
   //! Minimize allocated memory

src/SMDS/SMDS_Mesh.cxx

@@ -68,7 +68,7 @@ int SMDS_Mesh::chunkSize = 1024;
  */
 //================================================================================
 
-int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc)
+int SMDS_Mesh::CheckMemory(const bool doNotRaise) 
 {
   return -1;
 #if !defined WIN32 && !defined __APPLE__

src/SMDS/SMDS_Mesh.hxx

@@ -679,7 +679,7 @@ public:
     * \param doNotRaise - if true, suppress exception, just return free memory size
     * \retval int - amount of available memory in MB or negative number in failure case
    */
-  static int CheckMemory(const bool doNotRaise=false) throw (std::bad_alloc);
+  static int CheckMemory(const bool doNotRaise=false);
 
   virtual int MaxNodeID() const;
   virtual int MinNodeID() const;

src/SMDS/SMDS_MeshNode.hxx

@@ -62,7 +62,7 @@ class SMDS_EXPORT SMDS_MeshNode: public SMDS_MeshElement
 
   virtual bool IsPoly() const { return false; }
   virtual bool IsQuadratic() const { return false; }
-  virtual bool IsMediumNode(const SMDS_MeshNode* node) const  { return false; }
+  virtual bool IsMediumNode(const SMDS_MeshNode* /*node*/) const  { return false; }
   virtual int  NbCornerNodes() const { return 1; }
 
   void Print(std::ostream & OS) const;

src/SMDS/SMDS_MeshVolume.cxx

@@ -201,7 +201,7 @@ int SMDS_MeshVolume::GetNodeIndex( const SMDS_MeshNode* node ) const
   }
   return -1;
 }
-bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes)
+bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* /*nodes[]*/, const int /*nbNodes*/)
 {
   return false;
 }

src/SMDS/SMDS_MeshVolume.hxx

@@ -52,7 +52,7 @@ class SMDS_EXPORT SMDS_MeshVolume : public SMDS_MeshCell
   virtual int  NbFaces() const;
   virtual int  NbEdges() const;
   virtual int  GetNodeIndex( const SMDS_MeshNode* node ) const;
-  virtual bool ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes);
+  virtual bool ChangeNodes(const SMDS_MeshNode* /*nodes[]*/, const int /*nbNodes*/);
   virtual bool IsMediumNode(const SMDS_MeshNode* node) const;
   virtual int  NbCornerNodes() const;
 

src/SMDS/SMDS_SetIterator.hxx

@@ -63,7 +63,7 @@ namespace SMDS {
   template <typename VALUE>
   struct PassAllValueFilter
   {
-    bool operator()(const VALUE& t ) { return true; }
+    bool operator()(const VALUE& /*t*/ ) { return true; }
   };
 
   template <typename VALUE>

src/SMESH/SMESH_Gen.cxx

@@ -118,7 +118,6 @@ SMESH_Gen::~SMESH_Gen()
 //=============================================================================
 
 SMESH_Mesh* SMESH_Gen::CreateMesh(bool theIsEmbeddedMode)
-  throw(SALOME_Exception)
 {
   Unexpect aCatch(SalomeException);
 

src/SMESH/SMESH_Gen.hxx

@@ -67,7 +67,7 @@ public:
   ~SMESH_Gen();
 
   SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode)
-    throw(SALOME_Exception);
+    ;
 
   enum ComputeFlags
   {

src/SMESH/SMESH_HypoFilter.cxx

@@ -57,7 +57,7 @@ bool SMESH_HypoFilter::NamePredicate::IsOk (const SMESH_Hypothesis* aHyp,
 int SMESH_HypoFilter::TypePredicate::Value( const SMESH_Hypothesis* aHyp ) const
 {
   return aHyp->GetType();
-};
+}
 
 //=======================================================================
 //function : DimPredicate::Value
@@ -78,7 +78,7 @@ bool SMESH_HypoFilter::ApplicablePredicate::IsOk(const SMESH_Hypothesis* aHyp,
                                                  const TopoDS_Shape&     /*aShape*/) const
 {
   return SMESH_subMesh::IsApplicableHypothesis( aHyp, (TopAbs_ShapeEnum)_shapeType );
-};
+}
 
 //=======================================================================
 //function : IsAuxiliaryPredicate::IsOk
@@ -89,7 +89,7 @@ bool SMESH_HypoFilter::IsAuxiliaryPredicate::IsOk(const SMESH_Hypothesis* aHyp,
                                                   const TopoDS_Shape&     /*aShape*/) const
 {
   return aHyp->IsAuxiliary();
-};
+}
 
 //=======================================================================
 //function : ApplicablePredicate::ApplicablePredicate
@@ -117,7 +117,7 @@ bool SMESH_HypoFilter::InstancePredicate::IsOk(const SMESH_Hypothesis* aHyp,
 //purpose  : 
 //=======================================================================
 
-bool SMESH_HypoFilter::IsAssignedToPredicate::IsOk(const SMESH_Hypothesis* aHyp,
+bool SMESH_HypoFilter::IsAssignedToPredicate::IsOk(const SMESH_Hypothesis* /*aHyp*/,
                                                    const TopoDS_Shape&     aShape) const
 {
   return ( !_mainShape.IsNull() && !aShape.IsNull() && _mainShape.IsSame( aShape ));

src/SMESH/SMESH_Mesh.cxx

@@ -618,7 +618,7 @@ SMESH_ComputeErrorPtr SMESH_Mesh::GMFToMesh(const char* theFileName,
 SMESH_Hypothesis::Hypothesis_Status
 SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
                           int                  anHypId,
-                          std::string*         anError  ) throw(SALOME_Exception)
+                          std::string*         anError  ) 
 {
   Unexpect aCatch(SalomeException);
   if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis");
@@ -713,7 +713,7 @@ SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
 
 SMESH_Hypothesis::Hypothesis_Status
 SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
-                             int                    anHypId) throw( SALOME_Exception )
+                             int                    anHypId) 
 {
   Unexpect aCatch(SalomeException);
   if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis");
@@ -784,7 +784,7 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
 
 const std::list<const SMESHDS_Hypothesis*>&
 SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
-  throw(SALOME_Exception)
+  
 {
   return _myMeshDS->GetHypothesis(aSubShape);
 }
@@ -993,7 +993,7 @@ SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const int anHypId) const
  */
 //=============================================================================
 
-const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
+const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog() 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetScript()->GetCommands();
@@ -1004,7 +1004,7 @@ const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
  * 
  */
 //=============================================================================
-void SMESH_Mesh::ClearLog() throw(SALOME_Exception)
+void SMESH_Mesh::ClearLog() 
 {
   Unexpect aCatch(SalomeException);
   _myMeshDS->GetScript()->Clear();
@@ -1017,7 +1017,7 @@ void SMESH_Mesh::ClearLog() throw(SALOME_Exception)
 //=============================================================================
 
 SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
-  throw(SALOME_Exception)
+  
 {
   int index = _myMeshDS->ShapeToIndex(aSubShape);
   if ( !index && aSubShape.IsNull() )
@@ -1070,7 +1070,7 @@ SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
 //=============================================================================
 
 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
-  throw(SALOME_Exception)
+  
 {
   int index = _myMeshDS->ShapeToIndex(aSubShape);
   return GetSubMeshContaining( index );
@@ -1084,7 +1084,7 @@ SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape)
 //=============================================================================
 
 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const
-throw(SALOME_Exception)
+
 {
   SMESH_subMesh *aSubMesh = _subMeshHolder->Get( aShapeID );
 
@@ -1099,7 +1099,7 @@ throw(SALOME_Exception)
 
 std::list<SMESH_subMesh*>
 SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
-  throw(SALOME_Exception)
+  
 {
   std::list<SMESH_subMesh*> found;
 
@@ -1273,13 +1273,13 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h
  *  Auto color functionality
  */
 //=============================================================================
-void SMESH_Mesh::SetAutoColor(bool theAutoColor) throw(SALOME_Exception)
+void SMESH_Mesh::SetAutoColor(bool theAutoColor) 
 {
   Unexpect aCatch(SalomeException);
   _isAutoColor = theAutoColor;
 }
 
-bool SMESH_Mesh::GetAutoColor() throw(SALOME_Exception)
+bool SMESH_Mesh::GetAutoColor() 
 {
   Unexpect aCatch(SalomeException);
   return _isAutoColor;
@@ -1434,7 +1434,7 @@ void SMESH_Mesh::ExportMED(const char *        file,
                            bool                theAddODOnVertices,
                            double              theZTolerance,
                            bool                theAllElemsToGroup)
-throw(SALOME_Exception)
+
 {
   MESSAGE("MED_VERSION:"<< theVersion);
   SMESH_TRY;
@@ -1505,7 +1505,7 @@ throw(SALOME_Exception)
 void SMESH_Mesh::ExportSAUV(const char *file, 
                             const char* theMeshName, 
                             bool theAutoGroups)
-  throw(SALOME_Exception)
+  
 {
   std::string medfilename(file);
   medfilename += ".med";
@@ -1549,7 +1549,7 @@ void SMESH_Mesh::ExportSAUV(const char *file,
 //================================================================================
 
 void SMESH_Mesh::ExportDAT(const char *        file,
-                           const SMESHDS_Mesh* meshPart) throw(SALOME_Exception)
+                           const SMESHDS_Mesh* meshPart) 
 {
   Unexpect aCatch(SalomeException);
   DriverDAT_W_SMDS_Mesh myWriter;
@@ -1566,7 +1566,7 @@ void SMESH_Mesh::ExportDAT(const char *        file,
 //================================================================================
 
 void SMESH_Mesh::ExportUNV(const char *        file,
-                           const SMESHDS_Mesh* meshPart) throw(SALOME_Exception)
+                           const SMESHDS_Mesh* meshPart) 
 {
   Unexpect aCatch(SalomeException);
   DriverUNV_W_SMDS_Mesh myWriter;
@@ -1601,7 +1601,7 @@ void SMESH_Mesh::ExportUNV(const char *        file,
 void SMESH_Mesh::ExportSTL(const char *        file,
                            const bool          isascii,
                            const char *        name,
-                           const SMESHDS_Mesh* meshPart) throw(SALOME_Exception)
+                           const SMESHDS_Mesh* meshPart) 
 {
   Unexpect aCatch(SalomeException);
   DriverSTL_W_SMDS_Mesh myWriter;
@@ -1756,7 +1756,7 @@ double SMESH_Mesh::GetComputeProgress() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbNodes() const throw(SALOME_Exception)
+int SMESH_Mesh::NbNodes() const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->NbNodes();
@@ -1768,7 +1768,7 @@ int SMESH_Mesh::NbNodes() const throw(SALOME_Exception)
  */
 //================================================================================
 
-int SMESH_Mesh::Nb0DElements() const throw(SALOME_Exception)
+int SMESH_Mesh::Nb0DElements() const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().Nb0DElements();
@@ -1780,7 +1780,7 @@ int SMESH_Mesh::Nb0DElements() const throw(SALOME_Exception)
  */
 //================================================================================
 
-int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbEdges(order);
@@ -1792,7 +1792,7 @@ int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const throw(SALOME_Exception
  */
 //================================================================================
 
-int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbFaces(order);
@@ -1804,7 +1804,7 @@ int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const throw(SALOME_Exception
  */
 //================================================================================
 
-int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbTriangles(order);
@@ -1816,7 +1816,7 @@ int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const throw(SALOME_Excep
  */
 //================================================================================
 
-int SMESH_Mesh::NbBiQuadTriangles() const throw(SALOME_Exception)
+int SMESH_Mesh::NbBiQuadTriangles() const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBiQuadTriangles();
@@ -1828,7 +1828,7 @@ int SMESH_Mesh::NbBiQuadTriangles() const throw(SALOME_Exception)
  */
 //================================================================================
 
-int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbQuadrangles(order);
@@ -1840,7 +1840,7 @@ int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const throw(SALOME_Exc
  */
 //================================================================================
 
-int SMESH_Mesh::NbBiQuadQuadrangles() const throw(SALOME_Exception)
+int SMESH_Mesh::NbBiQuadQuadrangles() const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBiQuadQuadrangles();
@@ -1852,7 +1852,7 @@ int SMESH_Mesh::NbBiQuadQuadrangles() const throw(SALOME_Exception)
  */
 //================================================================================
 
-int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPolygons(order);
@@ -1864,7 +1864,7 @@ int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const throw(SALOME_Except
  */
 //================================================================================
 
-int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbVolumes(order);
@@ -1876,7 +1876,7 @@ int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const throw(SALOME_Excepti
  */
 //================================================================================
 
-int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbTetras(order);
@@ -1888,7 +1888,7 @@ int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const throw(SALOME_Exceptio
  */
 //================================================================================
 
-int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbHexas(order);
@@ -1900,7 +1900,7 @@ int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const throw(SALOME_Exception
  */
 //================================================================================
 
-int SMESH_Mesh::NbTriQuadraticHexas() const throw(SALOME_Exception)
+int SMESH_Mesh::NbTriQuadraticHexas() const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbTriQuadHexas();
@@ -1912,7 +1912,7 @@ int SMESH_Mesh::NbTriQuadraticHexas() const throw(SALOME_Exception)
  */
 //================================================================================
 
-int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPyramids(order);
@@ -1924,19 +1924,19 @@ int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const throw(SALOME_Except
  */
 //================================================================================
 
-int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPrisms(order);
 }
 
-int SMESH_Mesh::NbQuadPrisms() const throw (SALOME_Exception)
+int SMESH_Mesh::NbQuadPrisms() const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbQuadPrisms();
 }
 
-int SMESH_Mesh::NbBiQuadPrisms() const throw (SALOME_Exception)
+int SMESH_Mesh::NbBiQuadPrisms() const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBiQuadPrisms();
@@ -1949,7 +1949,7 @@ int SMESH_Mesh::NbBiQuadPrisms() const throw (SALOME_Exception)
  */
 //================================================================================
 
-int SMESH_Mesh::NbHexagonalPrisms() const throw(SALOME_Exception)
+int SMESH_Mesh::NbHexagonalPrisms() const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbHexPrisms();
@@ -1961,7 +1961,7 @@ int SMESH_Mesh::NbHexagonalPrisms() const throw(SALOME_Exception)
  */
 //================================================================================
 
-int SMESH_Mesh::NbPolyhedrons() const throw(SALOME_Exception)
+int SMESH_Mesh::NbPolyhedrons() const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPolyhedrons();
@@ -1973,7 +1973,7 @@ int SMESH_Mesh::NbPolyhedrons() const throw(SALOME_Exception)
  */
 //================================================================================
 
-int SMESH_Mesh::NbBalls() const throw(SALOME_Exception)
+int SMESH_Mesh::NbBalls() const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBalls();
@@ -1985,7 +1985,7 @@ int SMESH_Mesh::NbBalls() const throw(SALOME_Exception)
  */
 //================================================================================
 
-int SMESH_Mesh::NbSubMesh() const throw(SALOME_Exception)
+int SMESH_Mesh::NbSubMesh() const 
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->NbSubMesh();
@@ -2054,7 +2054,7 @@ SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType,
  */
 //================================================================================
 
-SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS) throw(SALOME_Exception)
+SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS) 
 {
   if ( !groupDS )
     throw SALOME_Exception(LOCALIZED ("SMESH_Mesh::AddGroup(): NULL SMESHDS_GroupBase"));

src/SMESH/SMESH_Mesh.hxx

@@ -133,15 +133,15 @@ class SMESH_EXPORT SMESH_Mesh
 
   SMESH_Hypothesis::Hypothesis_Status
   AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0)
-    throw(SALOME_Exception);
+    ;
   
   SMESH_Hypothesis::Hypothesis_Status
   RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId)
-    throw(SALOME_Exception);
+    ;
   
   const std::list <const SMESHDS_Hypothesis * >&
   GetHypothesisList(const TopoDS_Shape & aSubShape) const
-    throw(SALOME_Exception);
+    ;
 
   const SMESH_Hypothesis * GetHypothesis(const TopoDS_Shape &    aSubShape,
                                          const SMESH_HypoFilter& aFilter,
@@ -167,9 +167,9 @@ class SMESH_EXPORT SMESH_Mesh
 
   SMESH_Hypothesis * GetHypothesis(const int aHypID) const;
 
-  const std::list<SMESHDS_Command*> & GetLog() throw(SALOME_Exception);
+  const std::list<SMESHDS_Command*> & GetLog() ;
   
-  void ClearLog() throw(SALOME_Exception);
+  void ClearLog() ;
   
   int GetId() const          { return _id; }
   
@@ -184,18 +184,18 @@ class SMESH_EXPORT SMESH_Mesh
   SMESH_Gen *GetGen()        { return _gen; }
 
   SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape)
-    throw(SALOME_Exception);
+    ;
   
   SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
-    throw(SALOME_Exception);
+    ;
   
   SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const
-    throw(SALOME_Exception);
+    ;
   /*!
    * \brief Return submeshes of groups containing the given subshape
    */
   std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const
-    throw(SALOME_Exception);
+    ;
   /*!
    * \brief Say all submeshes that theChangedHyp has been modified
    */
@@ -220,9 +220,9 @@ class SMESH_EXPORT SMESH_Mesh
    */
   const TopTools_ListOfShape& GetAncestors(const TopoDS_Shape& theSubShape) const;
 
-  void SetAutoColor(bool theAutoColor) throw(SALOME_Exception);
+  void SetAutoColor(bool theAutoColor) ;
 
-  bool GetAutoColor() throw(SALOME_Exception);
+  bool GetAutoColor() ;
 
   /*!
    * \brief Set the flag meaning that the mesh has been edited "manually".
@@ -264,16 +264,16 @@ class SMESH_EXPORT SMESH_Mesh
                  bool                theAddODOnVertices = false,
                  double              theZTolerance = -1.,
                  bool                theAllElemsToGroup = false)
-    throw(SALOME_Exception);
+    ;
 
   void ExportDAT(const char *        file,
-                 const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception);
+                 const SMESHDS_Mesh* meshPart = 0) ;
   void ExportUNV(const char *        file,
-                 const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception);
+                 const SMESHDS_Mesh* meshPart = 0) ;
   void ExportSTL(const char *        file,
                  const bool          isascii,
                  const char *        name = 0,
-                 const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception);
+                 const SMESHDS_Mesh* meshPart = 0) ;
   void ExportCGNS(const char *        file,
                   const SMESHDS_Mesh* mesh,
                   const char *        meshName = 0,
@@ -283,35 +283,35 @@ class SMESH_EXPORT SMESH_Mesh
                  bool                withRequiredGroups = true );
   void ExportSAUV(const char *file, 
                   const char* theMeshName = NULL, 
-                  bool theAutoGroups = true) throw(SALOME_Exception);
+                  bool theAutoGroups = true) ;
 
   double GetComputeProgress() const;
   
-  int NbNodes() const throw(SALOME_Exception);
+  int NbNodes() const ;
-  int Nb0DElements() const throw(SALOME_Exception);
+  int Nb0DElements() const ;
-  int NbBalls() const throw(SALOME_Exception);
+  int NbBalls() const ;
   
-  int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+  int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
   
-  int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+  int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+  int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+  int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbBiQuadQuadrangles() const throw(SALOME_Exception);
+  int NbBiQuadQuadrangles() const ;
-  int NbBiQuadTriangles() const throw(SALOME_Exception);
+  int NbBiQuadTriangles() const ;
-  int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+  int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
   
-  int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+  int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+  int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+  int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbTriQuadraticHexas() const throw(SALOME_Exception);
+  int NbTriQuadraticHexas() const ;
-  int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+  int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+  int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbQuadPrisms() const throw(SALOME_Exception);
+  int NbQuadPrisms() const ;
-  int NbBiQuadPrisms() const throw(SALOME_Exception);
+  int NbBiQuadPrisms() const ;
-  int NbHexagonalPrisms() const throw(SALOME_Exception);
+  int NbHexagonalPrisms() const ;
-  int NbPolyhedrons() const throw(SALOME_Exception);
+  int NbPolyhedrons() const ;
   
-  int NbSubMesh() const throw(SALOME_Exception);
+  int NbSubMesh() const ;
   
   int NbGroup() const { return _mapGroup.size(); }
 
@@ -323,7 +323,7 @@ class SMESH_EXPORT SMESH_Mesh
                          const TopoDS_Shape&       theShape = TopoDS_Shape(),
                          const SMESH_PredicatePtr& thePredicate = SMESH_PredicatePtr());
 
-  SMESH_Group* AddGroup (SMESHDS_GroupBase* groupDS) throw(SALOME_Exception);
+  SMESH_Group* AddGroup (SMESHDS_GroupBase* groupDS) ;
 
   typedef boost::shared_ptr< SMDS_Iterator<SMESH_Group*> > GroupIteratorPtr;
   GroupIteratorPtr GetGroups() const;

src/SMESH/SMESH_ProxyMesh.hxx

@@ -92,7 +92,7 @@ public:
   protected: // methods of SMDS_ElementHolder; remove elements before mesh compacting or clearing
     virtual SMDS_ElemIteratorPtr getElements() { Clear(); return GetElements(); }
     virtual void tmpClear() {}
-    virtual void add( const SMDS_MeshElement* element ) {}
+    virtual void add( const SMDS_MeshElement* /*element*/ ) {}
     virtual void compact() {}
     virtual void clear() { Clear(); }
   };

src/SMESHDS/SMESHDS_Mesh.cxx

@@ -273,7 +273,7 @@ bool SMESHDS_Mesh
 //purpose  :
 //=======================================================================
 
-void SMESHDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
+void SMESHDS_Mesh::Renumber (const bool /*isNodes*/, const int /*startID*/, const int /*deltaID*/)
 {
   // TODO not possible yet to have node numbers not starting to O and continuous.
   if ( !this->IsCompacted() )
@@ -838,7 +838,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
 //purpose  : 
 //=======================================================================
 
-static void removeFromContainers (SMESHDS_Mesh*                         theMesh,
+static void removeFromContainers (SMESHDS_Mesh*                         /*theMesh*/,
                                   std::set<SMESHDS_GroupBase*>&         theGroups,
                                   std::vector<const SMDS_MeshElement*>& theElems)
 {

src/SMESHUtils/SMESH_Block.cxx

@@ -1142,7 +1142,7 @@ bool SMESH_Block::findUVByHalfDivision( const gp_Pnt&             thePoint,
 //================================================================================
 
 bool SMESH_Block::findUVAround( const gp_Pnt&             thePoint,
-                                const gp_XY&              theUV,
+                                const gp_XY&              /*theUV*/,
                                 const SMESH_Block::TFace& tface,
                                 gp_XYZ&                   theParams,
                                 int                       nbGetWorstLimit )

src/SMESHUtils/SMESH_MAT2d.cxx

@@ -418,7 +418,7 @@ namespace
    */
   //================================================================================
 
-  void bndSegsToMesh( const vector< vector< BndSeg > >& bndSegsPerEdge )
+  void bndSegsToMesh( const vector< vector< BndSeg > >& /*bndSegsPerEdge*/ )
   {
 #ifdef _MYDEBUG_
     if ( !getenv("bndSegsToMesh")) return;

src/SMESHUtils/SMESH_Offset.cxx

@@ -552,7 +552,7 @@ namespace
 
   bool getTranslatedPosition( const SMDS_MeshNode*         theNewNode,
                               const double                 theOffset,
-                              const double                 theTol,
+                              const double                 /*theTol*/,
                               const double                 theSign,
                               const std::vector< gp_XYZ >& theFaceNormals,
                               SMDS_Mesh&                   theSrcMesh,
@@ -2497,7 +2497,7 @@ namespace
    */
   //================================================================================
 
-  void CutFace::AddPoint( const CutLink& p1, const CutLink& p2, double tol ) const
+  void CutFace::AddPoint( const CutLink& p1, const CutLink& p2, double /*tol*/ ) const
   {
     if ( myInitFace->GetNodeIndex( p1.IntNode() ) >= 0 ||
          myInitFace->GetNodeIndex( p2.IntNode() ) >= 0 )
@@ -2918,7 +2918,7 @@ namespace
                              const double                 theSign,
                              const std::vector< gp_XYZ >& theNormals,
                              std::vector< EdgePart >&     theCutOffLinks,
-                             TLinkMap&                    theCutOffCoplanarLinks) const
+                             TLinkMap&                    /*theCutOffCoplanarLinks*/) const
   {
     EdgePart sideEdge;
     boost::container::flat_set< const SMDS_MeshElement* > checkedCoplanar;

src/SMESHUtils/SMESH_Slot.cxx

@@ -483,7 +483,7 @@ namespace
 
   const Segment* findTooCloseSegment( const IntPoint&        p,
                                       const double           minDist,
-                                      const double           tol,
+                                      const double           /*tol*/,
                                       const Segment*         curSegment,
                                       const SMDS_MeshNode*   curNode,
                                       const TSegmentsOfNode& segmentsOfNode )

src/SMESH_I/SMESH_2smeshpy.cxx

@@ -50,22 +50,22 @@
 #include <unistd.h>
 #endif
 
-IMPLEMENT_STANDARD_RTTIEXT(_pyObject          ,Standard_Transient);
+IMPLEMENT_STANDARD_RTTIEXT(_pyObject          ,Standard_Transient)
-IMPLEMENT_STANDARD_RTTIEXT(_pyCommand         ,Standard_Transient);
+IMPLEMENT_STANDARD_RTTIEXT(_pyCommand         ,Standard_Transient)
-IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient);
+IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient)
-IMPLEMENT_STANDARD_RTTIEXT(_pyGen             ,_pyObject);
+IMPLEMENT_STANDARD_RTTIEXT(_pyGen             ,_pyObject)
-IMPLEMENT_STANDARD_RTTIEXT(_pyMesh            ,_pyObject);
+IMPLEMENT_STANDARD_RTTIEXT(_pyMesh            ,_pyObject)
-IMPLEMENT_STANDARD_RTTIEXT(_pySubMesh         ,_pyObject);
+IMPLEMENT_STANDARD_RTTIEXT(_pySubMesh         ,_pyObject)
-IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor      ,_pyObject);
+IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor      ,_pyObject)
-IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis      ,_pyObject);
+IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis      ,_pyObject)
-IMPLEMENT_STANDARD_RTTIEXT(_pySelfEraser      ,_pyObject);
+IMPLEMENT_STANDARD_RTTIEXT(_pySelfEraser      ,_pyObject)
-IMPLEMENT_STANDARD_RTTIEXT(_pyGroup           ,_pyObject);
+IMPLEMENT_STANDARD_RTTIEXT(_pyGroup           ,_pyObject)
-IMPLEMENT_STANDARD_RTTIEXT(_pyFilter          ,_pyObject);
+IMPLEMENT_STANDARD_RTTIEXT(_pyFilter          ,_pyObject)
-IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm       ,_pyHypothesis);
+IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm       ,_pyHypothesis)
-IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis);
+IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis)
-IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis);
+IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis)
-IMPLEMENT_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis);
+IMPLEMENT_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis)
-IMPLEMENT_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis);
+IMPLEMENT_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis)
 
 using namespace std;
 using SMESH::TPythonDump;

src/SMESH_I/SMESH_2smeshpy.hxx

@@ -74,16 +74,16 @@ class _pyHypothesis;
 class _pyAlgorithm;
 class _pyHypothesisReader;
 
-DEFINE_STANDARD_HANDLE (_pyCommand         ,Standard_Transient);
+DEFINE_STANDARD_HANDLE (_pyCommand         ,Standard_Transient)
-DEFINE_STANDARD_HANDLE (_pyObject          ,Standard_Transient);
+DEFINE_STANDARD_HANDLE (_pyObject          ,Standard_Transient)
-DEFINE_STANDARD_HANDLE (_pyHypothesisReader,Standard_Transient);
+DEFINE_STANDARD_HANDLE (_pyHypothesisReader,Standard_Transient)
-DEFINE_STANDARD_HANDLE (_pyGen             ,_pyObject);
+DEFINE_STANDARD_HANDLE (_pyGen             ,_pyObject)
-DEFINE_STANDARD_HANDLE (_pyMesh            ,_pyObject);
+DEFINE_STANDARD_HANDLE (_pyMesh            ,_pyObject)
-DEFINE_STANDARD_HANDLE (_pySubMesh         ,_pyObject);
+DEFINE_STANDARD_HANDLE (_pySubMesh         ,_pyObject)
-DEFINE_STANDARD_HANDLE (_pyGroup           ,_pySubMesh);
+DEFINE_STANDARD_HANDLE (_pyGroup           ,_pySubMesh)
-DEFINE_STANDARD_HANDLE (_pyMeshEditor      ,_pyObject);
+DEFINE_STANDARD_HANDLE (_pyMeshEditor      ,_pyObject)
-DEFINE_STANDARD_HANDLE (_pyHypothesis      ,_pyObject);
+DEFINE_STANDARD_HANDLE (_pyHypothesis      ,_pyObject)
-DEFINE_STANDARD_HANDLE (_pyAlgorithm       ,_pyHypothesis);
+DEFINE_STANDARD_HANDLE (_pyAlgorithm       ,_pyHypothesis)
 
 typedef TCollection_AsciiString _pyID;
 typedef TCollection_AsciiString _AString;
@@ -509,7 +509,7 @@ public:
 
   DEFINE_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis)
 };
-DEFINE_STANDARD_HANDLE (_pyComplexParamHypo, _pyHypothesis);
+DEFINE_STANDARD_HANDLE (_pyComplexParamHypo, _pyHypothesis)
 
 // -------------------------------------------------------------------------------------
 /*!
@@ -531,7 +531,7 @@ public:
 
   DEFINE_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis)
 };
-DEFINE_STANDARD_HANDLE (_pyLayerDistributionHypo, _pyHypothesis);
+DEFINE_STANDARD_HANDLE (_pyLayerDistributionHypo, _pyHypothesis)
 
 // -------------------------------------------------------------------------------------
 /*!
@@ -548,7 +548,7 @@ public:
 
   DEFINE_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis)
 };
-DEFINE_STANDARD_HANDLE (_pyNumberOfSegmentsHyp, _pyHypothesis);
+DEFINE_STANDARD_HANDLE (_pyNumberOfSegmentsHyp, _pyHypothesis)
 
 // -------------------------------------------------------------------------------------
 /*!
@@ -563,7 +563,7 @@ public:
                                   const _pyID&              theMesh);
   DEFINE_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis)
 };
-DEFINE_STANDARD_HANDLE (_pySegmentLengthAroundVertexHyp, _pyHypothesis);
+DEFINE_STANDARD_HANDLE (_pySegmentLengthAroundVertexHyp, _pyHypothesis)
 
 // -------------------------------------------------------------------------------------
 /*!
@@ -582,7 +582,7 @@ public:
 
   DEFINE_STANDARD_RTTIEXT(_pySelfEraser,_pyObject)
 };
-DEFINE_STANDARD_HANDLE (_pySelfEraser, _pyObject);
+DEFINE_STANDARD_HANDLE (_pySelfEraser, _pyObject)
 
 // -------------------------------------------------------------------------------------
 /*!
@@ -624,7 +624,7 @@ public:
 
   DEFINE_STANDARD_RTTIEXT(_pyFilter,_pyObject)
 };
-DEFINE_STANDARD_HANDLE (_pyFilter, _pyObject);
+DEFINE_STANDARD_HANDLE (_pyFilter, _pyObject)
 
 // -------------------------------------------------------------------------------------
 /*!

src/SMESH_I/SMESH_Filter_i.cxx

@@ -1637,7 +1637,6 @@ void ConnectedElements_i::SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Dou
 }
 
 void ConnectedElements_i::SetVertex( GEOM::GEOM_Object_ptr vertex )
-  throw (SALOME::SALOME_Exception)
 {
   TopoDS_Shape shape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( vertex );
   if ( shape.IsNull() )
@@ -1659,7 +1658,6 @@ void ConnectedElements_i::SetVertex( GEOM::GEOM_Object_ptr vertex )
 }
 
 void ConnectedElements_i::SetNode ( CORBA::Long nodeID )
-  throw (SALOME::SALOME_Exception)
 {
   if ( nodeID < 1 )
     THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetNode(): nodeID must be > 0",
@@ -1675,7 +1673,6 @@ void ConnectedElements_i::SetNode ( CORBA::Long nodeID )
  */
 void ConnectedElements_i::SetThreshold ( const char*                             threshold,
                                          SMESH::ConnectedElements::ThresholdType type )
-  throw (SALOME::SALOME_Exception)
 {
   if ( !threshold )
     THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetThreshold(): NULL threshold",

src/SMESH_I/SMESH_Filter_i.hxx

@@ -823,12 +823,12 @@ namespace SMESH
     void                    SetElementType( ElementType theType );
     void                    SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Double z );
     void                    SetVertex( GEOM::GEOM_Object_ptr vertex )
-      throw (SALOME::SALOME_Exception);
+      ;
     void                    SetNode ( CORBA::Long nodeID )
-      throw (SALOME::SALOME_Exception);
+      ;
     void                    SetThreshold ( const char* threshold,
                                            SMESH::ConnectedElements::ThresholdType type )
-      throw (SALOME::SALOME_Exception);
+      ;
     char*                   GetThreshold ( SMESH::ConnectedElements::ThresholdType& type );
 
   private:

src/SMESH_I/SMESH_Gen_i.cxx

@@ -414,7 +414,7 @@ SMESH_Gen_i::~SMESH_Gen_i()
 GenericHypothesisCreator_i* SMESH_Gen_i::getHypothesisCreator(const char* theHypName,
                                                               const char* theLibName,
                                                               std::string& thePlatformLibName)
-  throw (SALOME::SALOME_Exception)
+  
 {
   std::string aPlatformLibName;
   /* It's Need to translate lib name for WIN32 or X platform */
@@ -565,7 +565,7 @@ SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName
 //=============================================================================
 
 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" );
@@ -814,7 +814,7 @@ StudyContext* SMESH_Gen_i::GetStudyContext()
 
 SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName,
                                                            const char* theLibName )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   // Create hypothesis/algorithm
@@ -849,7 +849,7 @@ SMESH_Gen_i::CreateHypothesisByAverageLength( const char*    theHypType,
                                               const char*    theLibName,
                                               CORBA::Double  theAverageLength,
                                               CORBA::Boolean theQuadDominated)
-  throw ( SALOME::SALOME_Exception )
+  
 {
   SMESH::HypInitParams initParams = { ::SMESH_Hypothesis::BY_AVERAGE_LENGTH,
                                       theAverageLength, theQuadDominated };
@@ -890,7 +890,7 @@ SMESH_Gen_i::GetHypothesisParameterValues( const char*                 theHypTyp
                                            SMESH::SMESH_Mesh_ptr       theMesh,
                                            GEOM::GEOM_Object_ptr       theGeom,
                                            const SMESH::HypInitParams& theParams)
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -1080,7 +1080,7 @@ CORBA::Boolean SMESH_Gen_i::GetSoleSubMeshUsingHyp( SMESH::SMESH_Hypothesis_ptr
 //=============================================================================
 
 void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   if ( theNbSegments > 0 )
     myGen.SetBoundaryBoxSegmentation( int( theNbSegments ));
@@ -1095,7 +1095,7 @@ void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
 //=============================================================================
 
 void SMESH_Gen_i::SetDefaultNbSegments(CORBA::Long theNbSegments)
-  throw ( SALOME::SALOME_Exception )
+  
 {
   if ( theNbSegments > 0 )
     myGen.SetDefaultNbSegments( int(theNbSegments) );
@@ -1201,7 +1201,7 @@ char* SMESH_Gen_i::GetOption(const char* name)
 //=============================================================================
 
 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
-     throw ( SALOME::SALOME_Exception )
+     
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
@@ -1236,7 +1236,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObj
 //=============================================================================
 
 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
-     throw ( SALOME::SALOME_Exception )
+     
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
@@ -1266,7 +1266,7 @@ namespace
    */
   //================================================================================
 
-  void checkFileReadable( const char* theFileName ) throw ( SALOME::SALOME_Exception )
+  void checkFileReadable( const char* theFileName ) 
   {
     SMESH_File f ( theFileName );
     if ( !f )
@@ -1290,7 +1290,7 @@ namespace
 //=============================================================================
 
 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -1421,7 +1421,7 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMEDorSAUV( const char* theFileNa
 
 SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char*                  theFileName,
                                                      SMESH::DriverMED_ReadStatus& theStatus)
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   checkFileReadable( theFileName );
@@ -1441,7 +1441,7 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char*
 
 SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char*                  theFileName,
                                                       SMESH::DriverMED_ReadStatus& theStatus)
-     throw ( SALOME::SALOME_Exception )
+     
 {
   Unexpect aCatch(SALOME_SalomeException);
   checkFileReadable( theFileName );
@@ -1484,7 +1484,7 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char*
 //=============================================================================
 
 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   checkFileReadable( theFileName );
@@ -1525,7 +1525,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName
 
 SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char*                  theFileName,
                                                       SMESH::DriverMED_ReadStatus& theStatus)
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   checkFileReadable( theFileName );
@@ -1613,7 +1613,7 @@ SMESH::SMESH_Mesh_ptr
 SMESH_Gen_i::CreateMeshesFromGMF( const char*             theFileName,
                                   CORBA::Boolean          theMakeRequiredGroups,
                                   SMESH::ComputeError_out theError)
-    throw ( SALOME::SALOME_Exception )
+    
 {
   Unexpect aCatch(SALOME_SalomeException);
   checkFileReadable( theFileName );
@@ -1657,7 +1657,7 @@ SMESH_Gen_i::CreateMeshesFromGMF( const char*             theFileName,
 
 CORBA::Boolean SMESH_Gen_i::IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
                                               GEOM::GEOM_Object_ptr theShapeObject )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
@@ -1732,7 +1732,7 @@ SALOMEDS::SObject_ptr SMESH_Gen_i::GetAlgoSO(const ::SMESH_Algo* algo)
 
 SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr theMesh,
                                                            GEOM::GEOM_Object_ptr theSubObject )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
@@ -1807,7 +1807,7 @@ SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr
 SMESH::MeshPreviewStruct*
 SMESH_Gen_i::GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
                                   CORBA::Short          theSubShapeID )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
@@ -1895,7 +1895,7 @@ SMESH::ListOfGroups*
 SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
                                            CORBA::Short          theSubShapeID,
                                            const char*           theGroupName )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -1930,7 +1930,7 @@ SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
 
 SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
                                                     GEOM::GEOM_Object_ptr theSubObject )
-      throw ( SALOME::SALOME_Exception )
+      
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
@@ -1992,7 +1992,7 @@ SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMes
 SMESH::long_array*
 SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr      theMainShapeObject,
                              const SMESH::object_array& theListOfSubShapeObject )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
@@ -2066,7 +2066,7 @@ SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr      theMainShapeObject,
 
 CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
                                      GEOM::GEOM_Object_ptr theShapeObject )
-     throw ( SALOME::SALOME_Exception )
+     
 {
   //MEMOSTAT;
   Unexpect aCatch(SALOME_SalomeException);
@@ -2163,7 +2163,7 @@ SMESH::MeshPreviewStruct* SMESH_Gen_i::Precompute( SMESH::SMESH_Mesh_ptr theMesh
                                                    GEOM::GEOM_Object_ptr theShapeObject,
                                                    SMESH::Dimension      theDimension,
                                                    SMESH::long_array&    theShapesId)
-     throw ( SALOME::SALOME_Exception )
+     
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
@@ -2351,7 +2351,7 @@ SMESH::MeshPreviewStruct* SMESH_Gen_i::Precompute( SMESH::SMESH_Mesh_ptr theMesh
 SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
                                          GEOM::GEOM_Object_ptr theShapeObject)
 //                                     SMESH::long_array& theNbElems)
-     throw ( SALOME::SALOME_Exception )
+     
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
@@ -2439,7 +2439,7 @@ GEOM::GEOM_Object_ptr
 SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
                                        CORBA::Long            theElementID,
                                        const char*            theGeomName)
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -2503,7 +2503,7 @@ SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
 GEOM::GEOM_Object_ptr
 SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
                                         CORBA::Long            theElementID)
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( CORBA::is_nil( theMesh ) )
@@ -2579,7 +2579,7 @@ SMESH_Gen_i::Concatenate(const SMESH::ListOfIDSources& theMeshesArray,
                          CORBA::Boolean                theMergeNodesAndElements,
                          CORBA::Double                 theMergeTolerance,
                          SMESH::SMESH_Mesh_ptr         theMeshToAppendTo)
-  throw ( SALOME::SALOME_Exception )
+  
 {
   return ConcatenateCommon(theMeshesArray,
                            theUniteIdenticalGroups,
@@ -2604,7 +2604,7 @@ SMESH_Gen_i::ConcatenateWithGroups(const SMESH::ListOfIDSources& theMeshesArray,
                                    CORBA::Boolean                theMergeNodesAndElements,
                                    CORBA::Double                 theMergeTolerance,
                                    SMESH::SMESH_Mesh_ptr         theMeshToAppendTo)
-  throw ( SALOME::SALOME_Exception )
+  
 {
   return ConcatenateCommon(theMeshesArray,
                            theUniteIdenticalGroups,
@@ -2629,7 +2629,7 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
                                CORBA::Double                 theMergeTolerance,
                                CORBA::Boolean                theCommonGroups,
                                SMESH::SMESH_Mesh_ptr         theMeshToAppendTo)
-  throw ( SALOME::SALOME_Exception )
+  
 {
   std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump );
   TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods
@@ -2909,7 +2909,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
                                             const char*               meshName,
                                             CORBA::Boolean            toCopyGroups,
                                             CORBA::Boolean            toKeepIDs)
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -3684,7 +3684,7 @@ CORBA::Boolean SMESH_Gen_i::CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr       theSou
                                               SMESH::submesh_array_out    theNewSubmeshes,
                                               SMESH::ListOfHypothesis_out theNewHypotheses,
                                               SMESH::string_array_out     theInvalidEntries)
-throw ( SALOME::SALOME_Exception )
+
 {
   if ( CORBA::is_nil( theSourceMesh ) ||
        CORBA::is_nil( theNewGeometry ))

src/SMESH_I/SMESH_Gen_i.hxx

@@ -168,13 +168,13 @@ public:
   // Create hypothesis/algorithm of given type
   SMESH::SMESH_Hypothesis_ptr CreateHypothesis (const char* theHypType,
                                                 const char* theLibName)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   SMESH::SMESH_Hypothesis_ptr CreateHypothesisByAverageLength( const char*    theHypType,
                                                                const char*    theLibName,
                                                                CORBA::Double  theAverageLength,
                                                                CORBA::Boolean theQuadDominated)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Return hypothesis of given type holding parameter values of the existing mesh
   SMESH::SMESH_Hypothesis_ptr
@@ -183,7 +183,7 @@ public:
                                   SMESH::SMESH_Mesh_ptr       theMesh,
                                   GEOM::GEOM_Object_ptr       theGeom,
                                   const SMESH::HypInitParams& theWay)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   /*
    * Returns True if a hypothesis is assigned to a sole sub-mesh in a current Study
@@ -198,11 +198,11 @@ public:
    * Sets number of segments per diagonal of boundary box of geometry by which
    * default segment length of appropriate 1D hypotheses is defined
    */
-  void SetBoundaryBoxSegmentation( CORBA::Long theNbSegments ) throw ( SALOME::SALOME_Exception );
+  void SetBoundaryBoxSegmentation( CORBA::Long theNbSegments ) ;
   /*!
    * \brief Sets default number of segments per edge
    */
-  void SetDefaultNbSegments(CORBA::Long theNbSegments) throw ( SALOME::SALOME_Exception );
+  void SetDefaultNbSegments(CORBA::Long theNbSegments) ;
 
   /*!
     Set an option value
@@ -221,47 +221,47 @@ public:
 
   // Create empty mesh on a shape
   SMESH::SMESH_Mesh_ptr CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Create empty mesh
   SMESH::SMESH_Mesh_ptr CreateEmptyMesh()
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   //  Create a mesh and import data from an UNV file
   SMESH::SMESH_Mesh_ptr CreateMeshesFromUNV( const char* theFileName )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   //  Create mesh(es) and import data from MED file
   SMESH::mesh_array* CreateMeshesFromMED( const char* theFileName,
                                           SMESH::DriverMED_ReadStatus& theStatus )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   //  Create mesh(es) and import data from MED file
   SMESH::mesh_array* CreateMeshesFromSAUV( const char* theFileName,
                                            SMESH::DriverMED_ReadStatus& theStatus )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   //  Create a mesh and import data from a STL file
   SMESH::SMESH_Mesh_ptr CreateMeshesFromSTL( const char* theFileName )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   //  Create mesh(es) and import data from CGNS file
   SMESH::mesh_array* CreateMeshesFromCGNS( const char* theFileName,
                                            SMESH::DriverMED_ReadStatus& theStatus )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   //  Create a mesh and import data from a GMF file
   SMESH::SMESH_Mesh_ptr CreateMeshesFromGMF( const char*             theFileName,
                                              CORBA::Boolean          theMakeRequiredGroups,
                                              SMESH::ComputeError_out theError)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Copy a part of mesh
   SMESH::SMESH_Mesh_ptr CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
                                  const char*               meshName,
                                  CORBA::Boolean            toCopyGroups,
                                  CORBA::Boolean            toKeepIDs)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Create a mesh by copying definitions of another mesh to a given geometry
   CORBA::Boolean CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr       sourceMesh,
@@ -275,12 +275,12 @@ public:
                                    SMESH::submesh_array_out    newSubmeshes,
                                    SMESH::ListOfHypothesis_out newHypotheses,
                                    SMESH::string_array_out     invalidEntries)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
     // Compute mesh on a shape
   CORBA::Boolean Compute( SMESH::SMESH_Mesh_ptr theMesh,
                           GEOM::GEOM_Object_ptr theShapeObject )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Cancel Compute mesh on a shape
   void CancelCompute( SMESH::SMESH_Mesh_ptr theMesh,
@@ -291,7 +291,7 @@ public:
    */
   SMESH::compute_error_array* GetComputeErrors(SMESH::SMESH_Mesh_ptr theMesh,
                                                GEOM::GEOM_Object_ptr  theShapeObject )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   /*!
    * Evaluate mesh on a shape and
@@ -300,12 +300,12 @@ public:
    */
   SMESH::long_array* Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
                               GEOM::GEOM_Object_ptr theShapeObject)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Returns true if mesh contains enough data to be computed
   CORBA::Boolean IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
                                    GEOM::GEOM_Object_ptr theShapeObject )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   /*!
    * Calculate Mesh as preview till indicated dimension on shape
@@ -316,39 +316,39 @@ public:
                                         GEOM::GEOM_Object_ptr theSubObject,
                                         SMESH::Dimension      theDimension,
                                         SMESH::long_array&    theShapesId )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Returns errors of hypotheses definition
   SMESH::algo_error_array* GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
                                          GEOM::GEOM_Object_ptr theSubObject )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Return mesh elements preventing computation of a subshape
   SMESH::MeshPreviewStruct* GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
                                                  CORBA::Short          theSubShapeID )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Create groups of elements preventing computation of a sub-shape
   SMESH::ListOfGroups* MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
                                                      CORBA::Short          theSubShapeID,
                                                      const char*           theGroupName)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Get sub-shapes unique ID's list
   SMESH::long_array* GetSubShapesId( GEOM::GEOM_Object_ptr      theMainShapeObject,
                                      const SMESH::object_array& theListOfSubShape )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Return geometrical object the given element is built on. Publish it in study.
   GEOM::GEOM_Object_ptr GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
                                                   CORBA::Long            theElementID,
                                                   const char*            theGeomName)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Return geometrical object the given element is built on. Don't publish it in study.
   GEOM::GEOM_Object_ptr FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
                                                    CORBA::Long            theElementID)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Concatenate the given meshes into one mesh
   SMESH::SMESH_Mesh_ptr ConcatenateCommon(const SMESH::ListOfIDSources& meshesArray,
@@ -357,7 +357,7 @@ public:
                                           CORBA::Double                 mergeTolerance,
                                           CORBA::Boolean                commonGroups,
                                           SMESH::SMESH_Mesh_ptr         meshToAppendTo)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Concatenate the given meshes into one mesh
   SMESH::SMESH_Mesh_ptr Concatenate(const SMESH::ListOfIDSources& meshesArray,
@@ -365,7 +365,7 @@ public:
                                     CORBA::Boolean                mergeNodesAndElements,
                                     CORBA::Double                 mergeTolerance,
                                     SMESH::SMESH_Mesh_ptr         meshToAppendTo)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Concatenate the given meshes into one mesh
   // Create the groups of all elements from initial meshes
@@ -374,7 +374,7 @@ public:
                                               CORBA::Boolean                mergeNodesAndElements,
                                               CORBA::Double                 mergeTolerance,
                                               SMESH::SMESH_Mesh_ptr         meshToAppendTo)
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Get version of MED format being used.
   char* GetMEDFileVersion();
@@ -446,18 +446,18 @@ public:
   SALOMEDS::SObject_ptr PublishInStudy( SALOMEDS::SObject_ptr theSObject,
                                         CORBA::Object_ptr     theObject,
                                         const char*           theName )
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Copy-paste methods - returns true if object can be copied to the clipboard
-  CORBA::Boolean CanCopy( SALOMEDS::SObject_ptr theObject ) { return false; }
+  CORBA::Boolean CanCopy( SALOMEDS::SObject_ptr /*theObject*/ ) { return false; }
   // Copy-paste methods - copy object to the clipboard
-  SALOMEDS::TMPFile* CopyFrom( SALOMEDS::SObject_ptr theObject, CORBA::Long& theObjectID ) { return NULL; }
+  SALOMEDS::TMPFile* CopyFrom( SALOMEDS::SObject_ptr /*theObject*/, CORBA::Long& /*theObjectID*/ ) { return NULL; }
   // Copy-paste methods - returns true if object can be pasted from the clipboard
-  CORBA::Boolean CanPaste( const char* theComponentName, CORBA::Long theObjectID ) { return false; }
+  CORBA::Boolean CanPaste( const char* /*theComponentName*/, CORBA::Long /*theObjectID*/ ) { return false; }
   // Copy-paste methods - paste object from the clipboard
-  SALOMEDS::SObject_ptr PasteInto( const SALOMEDS::TMPFile& theStream,
+  SALOMEDS::SObject_ptr PasteInto( const SALOMEDS::TMPFile& /*theStream*/,
-                                   CORBA::Long              theObjectID,
+                                   CORBA::Long              /*theObjectID*/,
-                                   SALOMEDS::SObject_ptr    theObject ) {
+                                   SALOMEDS::SObject_ptr    /*theObject*/ ) {
     SALOMEDS::SObject_var aResultSO;
     return aResultSO._retn();
   }
@@ -636,13 +636,13 @@ private:
   GenericHypothesisCreator_i* getHypothesisCreator( const char*  theHypName,
                                                     const char*  theLibName,
                                                     std::string& thePlatformLibName)
-  throw ( SALOME::SALOME_Exception );
+  ;
   // Create hypothesis of given type
   SMESH::SMESH_Hypothesis_ptr createHypothesis( const char* theHypName,
                                                 const char* theLibName);
   // Create empty mesh on shape
   SMESH::SMESH_Mesh_ptr createMesh()
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Check mesh icon
   bool isGeomModifIcon( SMESH::SMESH_Mesh_ptr mesh );

src/SMESH_I/SMESH_Gen_i_1.cxx

@@ -487,7 +487,6 @@ static void addReference (SALOMEDS::SObject_ptr theSObject,
 SALOMEDS::SObject_ptr SMESH_Gen_i::PublishInStudy(SALOMEDS::SObject_ptr theSObject,
                                                   CORBA::Object_ptr     theIOR,
                                                   const char*           theName)
-     throw (SALOME::SALOME_Exception)
 {
   Unexpect aCatch(SALOME_SalomeException);
   SALOMEDS::SObject_wrap aSO;

src/SMESH_I/SMESH_Group_i.cxx

@@ -798,7 +798,6 @@ SMESH_PredicatePtr SMESH_GroupOnFilter_i::GetPredicate( SMESH::Filter_ptr filter
 //================================================================================
 
 void SMESH_GroupOnFilter_i::SetFilter(SMESH::Filter_ptr theFilter)
-  throw (SALOME::SALOME_Exception)
 {
   if ( myFilter->_is_equivalent( theFilter ))
     return;

src/SMESH_I/SMESH_Group_i.hxx

@@ -196,7 +196,7 @@ class SMESH_I_EXPORT SMESH_GroupOnFilter_i:
   static SMESH_PredicatePtr GetPredicate( SMESH::Filter_ptr );
 
   // CORBA interface implementation
-  void SetFilter(SMESH::Filter_ptr theFilter) throw (SALOME::SALOME_Exception);
+  void SetFilter(SMESH::Filter_ptr theFilter) ;
   SMESH::Filter_ptr GetFilter();
   virtual CORBA::Boolean IsUpToDate();
   virtual SMESH::long_array* GetListOfID();

src/SMESH_I/SMESH_MeshEditor_i.hxx

@@ -65,27 +65,27 @@ public:
   /*!
    * Return data of mesh edition preview
    */
-  SMESH::MeshPreviewStruct* GetPreviewData() throw (SALOME::SALOME_Exception);
+  SMESH::MeshPreviewStruct* GetPreviewData() ;
   /*!
    * If during last operation of MeshEditor some nodes were
    * created this method returns list of their IDs, if new nodes
    * not created - returns an empty list
    */
-  SMESH::long_array* GetLastCreatedNodes() throw (SALOME::SALOME_Exception);
+  SMESH::long_array* GetLastCreatedNodes() ;
   /*!
    * If during last operation of MeshEditor some elements were
    * created this method returns list of their IDs, if new elements
    * not created - returns an empty list
    */
-  SMESH::long_array* GetLastCreatedElems() throw (SALOME::SALOME_Exception);
+  SMESH::long_array* GetLastCreatedElems() ;
   /*!
    * \brief Clears sequences of last created elements and nodes 
    */
-  void ClearLastCreated() throw (SALOME::SALOME_Exception);
+  void ClearLastCreated() ;
   /*!
    * \brief Returns description of an error/warning occurred during the last operation
    */
-  SMESH::ComputeError* GetLastError() throw (SALOME::SALOME_Exception);
+  SMESH::ComputeError* GetLastError() ;
 
   /*!
    * \brief Wrap a sequence of ids in a SMESH_IDSource
@@ -101,37 +101,37 @@ public:
   std::string GenerateGroupName(const std::string& thePrefix);
 
   CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean RemoveNodes   (const SMESH::long_array & IDsOfNodes)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long    RemoveOrphanNodes()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Methods for creation new elements.
    * Returns ID of created element or 0 if element not created
    */
   CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long Add0DElement(CORBA::Long IDOfNode, CORBA::Boolean DuplicateElements)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long AddQuadPolygonalFace(const SMESH::long_array & IDsOfNodes)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long AddPolyhedralVolume(const SMESH::long_array & IDsOfNodes,
                                   const SMESH::long_array & Quantities)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Create 0D elements on all nodes of the given object except those 
@@ -146,7 +146,7 @@ public:
   SMESH::SMESH_IDSource_ptr Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
                                                        const char*               theGroupName,
                                                        CORBA::Boolean            theDuplicateElements)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Bind a node to a vertex
@@ -154,7 +154,7 @@ public:
    * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
    */
   void SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
-    throw (SALOME::SALOME_Exception);
+    ;
   /*!
    * \brief Store node position on an edge
    * \param NodeID - node ID
@@ -163,7 +163,7 @@ public:
    */
   void SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
                      CORBA::Double paramOnEdge)
-    throw (SALOME::SALOME_Exception);
+    ;
   /*!
    * \brief Store node position on a face
    * \param NodeID - node ID
@@ -173,35 +173,35 @@ public:
    */
   void SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
                      CORBA::Double u, CORBA::Double v)
-    throw (SALOME::SALOME_Exception);
+    ;
   /*!
    * \brief Bind a node to a solid
    * \param NodeID - node ID
    * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
    */
   void SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
-    throw (SALOME::SALOME_Exception);
+    ;
   /*!
    * \brief Bind an element to a shape
    * \param ElementID - element ID
    * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
    */
   void SetMeshElementOnShape(CORBA::Long ElementID, CORBA::Long ShapeID)
-    throw (SALOME::SALOME_Exception);
+    ;
 
 
   CORBA::Boolean MoveNode(CORBA::Long NodeID,
                           CORBA::Double x, CORBA::Double y, CORBA::Double z)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Boolean InverseDiag(CORBA::Long NodeID1, CORBA::Long NodeID2)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean DeleteDiag(CORBA::Long NodeID1, CORBA::Long NodeID2)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean Reorient(const SMESH::long_array & IDsOfElements)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Reorient faces contained in \a the2Dgroup.
@@ -215,7 +215,7 @@ public:
   CORBA::Long Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
                          const SMESH::DirStruct&   theDirection,
                          CORBA::Long               theFace,
-                         const SMESH::PointStruct& thePoint) throw (SALOME::SALOME_Exception);
+                         const SMESH::PointStruct& thePoint) ;
   /*!
    * \brief Reorient faces basing on orientation of adjacent volumes.
    * \param faces - a list of objects containing face to reorient
@@ -227,100 +227,100 @@ public:
   CORBA::Long Reorient2DBy3D(const SMESH::ListOfIDSources & faces,
                              SMESH::SMESH_IDSource_ptr      volumes,
                              CORBA::Boolean                 outsideNormal)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   // Split/Join
   CORBA::Boolean TriToQuad       (const SMESH::long_array &   IDsOfElements,
                                   SMESH::NumericalFunctor_ptr Criterion,
                                   CORBA::Double               MaxAngle)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean TriToQuadObject (SMESH::SMESH_IDSource_ptr   theObject,
                                   SMESH::NumericalFunctor_ptr Criterion,
                                   CORBA::Double               MaxAngle)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean QuadToTri       (const SMESH::long_array &   IDsOfElements,
                                   SMESH::NumericalFunctor_ptr Criterion)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean QuadToTriObject (SMESH::SMESH_IDSource_ptr   theObject,
                                   SMESH::NumericalFunctor_ptr Criterion)
-    throw (SALOME::SALOME_Exception);
+    ;
   void           QuadTo4Tri      (SMESH::SMESH_IDSource_ptr   theObject)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean SplitQuad       (const SMESH::long_array &   IDsOfElements,
                                   CORBA::Boolean              Diag13)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean SplitQuadObject (SMESH::SMESH_IDSource_ptr   theObject,
                                   CORBA::Boolean              Diag13)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long    BestSplit       (CORBA::Long                 IDOfQuad,
                                   SMESH::NumericalFunctor_ptr Criterion)
-    throw (SALOME::SALOME_Exception);
+    ;
   void           SplitVolumesIntoTetra(SMESH::SMESH_IDSource_ptr elems,
                                        CORBA::Short             methodFlags)
-    throw (SALOME::SALOME_Exception);
+    ;
   void           SplitHexahedraIntoPrisms(SMESH::SMESH_IDSource_ptr  elems,
                                           const SMESH::PointStruct & startHexPoint,
                                           const SMESH::DirStruct&    facetToSplitNormal,
                                           CORBA::Short               methodFlags,
                                           CORBA::Boolean             allDomains)
-    throw (SALOME::SALOME_Exception);
+    ;
   void           SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& elems)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Boolean Smooth(const SMESH::long_array &              IDsOfElements,
                         const SMESH::long_array &              IDsOfFixedNodes,
                         CORBA::Long                            MaxNbOfIterations,
                         CORBA::Double                          MaxAspectRatio,
                         SMESH::SMESH_MeshEditor::Smooth_Method Method)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean SmoothObject(SMESH::SMESH_IDSource_ptr              theObject,
                               const SMESH::long_array &              IDsOfFixedNodes,
                               CORBA::Long                            MaxNbOfIterations,
                               CORBA::Double                          MaxAspectRatio,
                               SMESH::SMESH_MeshEditor::Smooth_Method Method)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean SmoothParametric(const SMESH::long_array &              IDsOfElements,
                                   const SMESH::long_array &              IDsOfFixedNodes,
                                   CORBA::Long                            MaxNbOfIterations,
                                   CORBA::Double                          MaxAspectRatio,
                                   SMESH::SMESH_MeshEditor::Smooth_Method Method)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean SmoothParametricObject(SMESH::SMESH_IDSource_ptr              theObject,
                                         const SMESH::long_array &              IDsOfFixedNodes,
                                         CORBA::Long                            MaxNbOfIterations,
                                         CORBA::Double                          MaxAspectRatio,
                                         SMESH::SMESH_MeshEditor::Smooth_Method Method)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean smooth(const SMESH::long_array &              IDsOfElements,
                         const SMESH::long_array &              IDsOfFixedNodes,
                         CORBA::Long                            MaxNbOfIterations,
                         CORBA::Double                          MaxAspectRatio,
                         SMESH::SMESH_MeshEditor::Smooth_Method Method,
                         bool                                   IsParametric)
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Boolean smoothObject(SMESH::SMESH_IDSource_ptr              theObject,
                               const SMESH::long_array &              IDsOfFixedNodes,
                               CORBA::Long                            MaxNbOfIterations,
                               CORBA::Double                          MaxAspectRatio,
                               SMESH::SMESH_MeshEditor::Smooth_Method Method,
                               bool                                   IsParametric)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Boolean ConvertFromQuadratic()
-    throw (SALOME::SALOME_Exception);
+    ;
   void           ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
-    throw (SALOME::SALOME_Exception);
+    ;
   void           ConvertToQuadratic(CORBA::Boolean Force3d)
-    throw (SALOME::SALOME_Exception);
+    ;
   void           ConvertToQuadraticObject(CORBA::Boolean            theForce3d,
                                           SMESH::SMESH_IDSource_ptr theObject)
-    throw (SALOME::SALOME_Exception);
+    ;
   void           ConvertToBiQuadratic(CORBA::Boolean            theForce3d,
                                       SMESH::SMESH_IDSource_ptr theObject)
-    throw (SALOME::SALOME_Exception);
+    ;
 
-  void RenumberNodes() throw (SALOME::SALOME_Exception);
+  void RenumberNodes() ;
-  void RenumberElements() throw (SALOME::SALOME_Exception);
+  void RenumberElements() ;
 
   SMESH::ListOfGroups* RotationSweepObjects(const SMESH::ListOfIDSources & Nodes,
                                             const SMESH::ListOfIDSources & Edges,
@@ -330,7 +330,7 @@ public:
                                             CORBA::Long                    NbOfSteps,
                                             CORBA::Double                  Tolerance,
                                             CORBA::Boolean                 ToMakeGroups)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfGroups* ExtrusionSweepObjects(const SMESH::ListOfIDSources & Nodes,
                                              const SMESH::ListOfIDSources & Edges,
@@ -343,7 +343,7 @@ public:
                                              const SMESH::double_array &    BasePoint,
                                              const SMESH::double_array &    Angles,
                                              CORBA::Boolean                 AnglesVariation)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfGroups* ExtrusionByNormal(const SMESH::ListOfIDSources& objects,
                                          CORBA::Double                 stepSize,
@@ -352,14 +352,14 @@ public:
                                          CORBA::Boolean                useInputElemsOnly,
                                          CORBA::Boolean                makeGroups,
                                          CORBA::Short                  dim)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::ListOfGroups*  AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
                                           const SMESH::DirStruct &  theStepVector,
                                           CORBA::Long               theNbOfSteps,
                                           CORBA::Long               theExtrFlags,
                                           CORBA::Double             theSewTolerance,
                                           CORBA::Boolean            theMakeGroups)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfGroups*
     ExtrusionAlongPathObjects(const SMESH::ListOfIDSources & Nodes,
@@ -377,7 +377,7 @@ public:
                               const SMESH::double_array &    ScaleFactors,
                               CORBA::Boolean                 ScalesVariation,
                               SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::double_array* LinearAnglesVariation(SMESH::SMESH_Mesh_ptr       PathMesh,
                                                GEOM::GEOM_Object_ptr       PathShape,
@@ -387,106 +387,106 @@ public:
               const SMESH::AxisStruct &           Axis,
               SMESH::SMESH_MeshEditor::MirrorType MirrorType,
               CORBA::Boolean                      Copy)
-    throw (SALOME::SALOME_Exception);
+    ;
   void MirrorObject(SMESH::SMESH_IDSource_ptr           theObject,
                     const SMESH::AxisStruct &           Axis,
                     SMESH::SMESH_MeshEditor::MirrorType MirrorType,
                     CORBA::Boolean                      Copy)
-    throw (SALOME::SALOME_Exception);
+    ;
   void Translate(const SMESH::long_array & IDsOfElements,
                  const SMESH::DirStruct &   Vector,
                  CORBA::Boolean            Copy)
-    throw (SALOME::SALOME_Exception);
+    ;
   void TranslateObject(SMESH::SMESH_IDSource_ptr  theObject,
                        const SMESH::DirStruct &   Vector,
                        CORBA::Boolean             Copy)
-    throw (SALOME::SALOME_Exception);
+    ;
   void Rotate(const SMESH::long_array & IDsOfElements,
               const SMESH::AxisStruct &  Axis,
               CORBA::Double             Angle,
               CORBA::Boolean            Copy)
-    throw (SALOME::SALOME_Exception);
+    ;
   void RotateObject(SMESH::SMESH_IDSource_ptr  theObject,
                     const SMESH::AxisStruct &  Axis,
                     CORBA::Double              Angle,
                     CORBA::Boolean             Copy)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfGroups* MirrorMakeGroups(const SMESH::long_array&            IDsOfElements,
                                         const SMESH::AxisStruct&            Mirror,
                                         SMESH::SMESH_MeshEditor::MirrorType MirrorType)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::ListOfGroups* MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr           Object,
                                               const SMESH::AxisStruct&            Mirror,
                                               SMESH::SMESH_MeshEditor::MirrorType MirrorType)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::ListOfGroups* TranslateMakeGroups(const SMESH::long_array& IDsOfElements,
                                            const SMESH::DirStruct&  Vector)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::ListOfGroups* TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
                                                  const SMESH::DirStruct&   Vector)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::ListOfGroups* RotateMakeGroups(const SMESH::long_array& IDsOfElements,
                                         const SMESH::AxisStruct& Axis,
                                         CORBA::Double            AngleInRadians)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::ListOfGroups* RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
                                               const SMESH::AxisStruct&  Axis,
                                               CORBA::Double             AngleInRadians)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Mesh_ptr MirrorMakeMesh(const SMESH::long_array&            IDsOfElements,
                                        const SMESH::AxisStruct&            Mirror,
                                        SMESH::SMESH_MeshEditor::MirrorType MirrorType,
                                        CORBA::Boolean                      CopyGroups,
                                        const char*                         MeshName)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::SMESH_Mesh_ptr MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr           Object,
                                              const SMESH::AxisStruct&            Mirror,
                                              SMESH::SMESH_MeshEditor::MirrorType MirrorType,
                                              CORBA::Boolean                      CopyGroups,
                                              const char*                         MeshName)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::SMESH_Mesh_ptr TranslateMakeMesh(const SMESH::long_array& IDsOfElements,
                                           const SMESH::DirStruct&  Vector,
                                           CORBA::Boolean           CopyGroups,
                                           const char*              MeshName)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::SMESH_Mesh_ptr TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
                                                 const SMESH::DirStruct&   Vector,
                                                 CORBA::Boolean            CopyGroups,
                                                 const char*               MeshName)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::SMESH_Mesh_ptr RotateMakeMesh(const SMESH::long_array& IDsOfElements,
                                        const SMESH::AxisStruct& Axis,
                                        CORBA::Double            AngleInRadians,
                                        CORBA::Boolean           CopyGroups,
                                        const char*              MeshName)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::SMESH_Mesh_ptr RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
                                              const SMESH::AxisStruct&  Axis,
                                              CORBA::Double             AngleInRadians,
                                              CORBA::Boolean            CopyGroups,
                                              const char*               MeshName)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   void Scale(SMESH::SMESH_IDSource_ptr  theObject,
              const SMESH::PointStruct&  thePoint,
              const SMESH::double_array& theScaleFact,
              CORBA::Boolean             theCopy)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfGroups* ScaleMakeGroups(SMESH::SMESH_IDSource_ptr  theObject,
                                        const SMESH::PointStruct&  thePoint,
                                        const SMESH::double_array& theScaleFact)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Mesh_ptr ScaleMakeMesh(SMESH::SMESH_IDSource_ptr  Object,
                                       const SMESH::PointStruct&  Point,
                                       const SMESH::double_array& theScaleFact,
                                       CORBA::Boolean             CopyGroups,
                                       const char*                MeshName)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Mesh_ptr Offset( SMESH::SMESH_IDSource_ptr theObject,
                                 CORBA::Double             Value,
@@ -494,48 +494,48 @@ public:
                                 CORBA::Boolean            CopyElements,
                                 const char*               MeshName,
                                 SMESH::ListOfGroups_out   Groups)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   void FindCoincidentNodes (CORBA::Double                  Tolerance,
                             SMESH::array_of_long_array_out GroupsOfNodes,
                             CORBA::Boolean                 SeparateCornersAndMedium)
-    throw (SALOME::SALOME_Exception);
+    ;
   void FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr      Object,
                                  CORBA::Double                  Tolerance,
                                  SMESH::array_of_long_array_out GroupsOfNodes,
                                  CORBA::Boolean                 SeparateCornersAndMedium)
-    throw (SALOME::SALOME_Exception);
+    ;
   void FindCoincidentNodesOnPartBut(const SMESH::ListOfIDSources&  Objects,
                                     CORBA::Double                  Tolerance,
                                     SMESH::array_of_long_array_out GroupsOfNodes,
                                     const SMESH::ListOfIDSources&  ExceptSubMeshOrGroups,
                                     CORBA::Boolean                 SeparateCornersAndMedium)
-    throw (SALOME::SALOME_Exception);
+    ;
   void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
                    const SMESH::ListOfIDSources&     NodesToKeep,
                    CORBA::Boolean                    AvoidMakingHoles )
-    throw (SALOME::SALOME_Exception);
+    ;
   void FindEqualElements(const SMESH::ListOfIDSources&  Objects,
                          const SMESH::ListOfIDSources&  ExceptSubMeshOrGroups,
                          SMESH::array_of_long_array_out GroupsOfElementsID)
-    throw (SALOME::SALOME_Exception);
+    ;
   void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID,
                      const SMESH::ListOfIDSources&     ElementsToKeep)
-    throw (SALOME::SALOME_Exception);
+    ;
   void MergeEqualElements()
-    throw (SALOME::SALOME_Exception);
+    ;
   CORBA::Long MoveClosestNodeToPoint(CORBA::Double x,
                                      CORBA::Double y,
                                      CORBA::Double z,
                                      CORBA::Long   nodeID)
-    throw (SALOME::SALOME_Exception);
+    ;
   /*!
    * \brief Return ID of node closest to a given point
    */
   CORBA::Long FindNodeClosestTo(CORBA::Double x,
                                 CORBA::Double y,
                                 CORBA::Double z)
-    throw (SALOME::SALOME_Exception);
+    ;
   /*!
    * Return elements of given type where the given point is IN or ON.
    * 'ALL' type means elements of any type excluding nodes
@@ -544,7 +544,7 @@ public:
                                          CORBA::Double      y,
                                          CORBA::Double      z,
                                          SMESH::ElementType type)
-    throw (SALOME::SALOME_Exception);
+    ;
   /*!
    * Searching among the given elements, return elements of given type
    * where the given point is IN or ON.
@@ -555,7 +555,7 @@ public:
                                               CORBA::Double             y,
                                               CORBA::Double             z,
                                               SMESH::ElementType        type)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Project a point to a mesh object.
@@ -569,26 +569,26 @@ public:
                            SMESH::ElementType        type,
                            SMESH::SMESH_IDSource_ptr meshObject,
                            SMESH::double_array_out   projecton)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
    * TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
    */
   CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Check if a 2D mesh is manifold
    */
   CORBA::Boolean IsManifold()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Check if orientation of 2D elements is coherent
    */
   CORBA::Boolean IsCoherentOrientation2D()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Partition given 1D elements into groups of contiguous edges.
@@ -600,19 +600,19 @@ public:
   SMESH::array_of_long_array* Get1DBranches( SMESH::SMESH_IDSource_ptr      edges,
                                              CORBA::Long                    startNode,
                                              SMESH::array_of_long_array_out nodeGroups)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Return sharp edges of faces and non-manifold ones. Optionally adds existing edges.
    */
   SMESH::ListOfEdges* FindSharpEdges(CORBA::Double angle, CORBA::Boolean addExisting)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Returns all or only closed FreeBorder's.
    */
   SMESH::ListOfFreeBorders* FindFreeBorders(CORBA::Boolean closedOnly)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Fill with 2D elements a hole defined by a FreeBorder.
@@ -620,13 +620,13 @@ public:
    */
   SMESH::SMESH_Group_ptr FillHole(const SMESH::FreeBorder& hole,
                                   const char*              groupName)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::CoincidentFreeBorders* FindCoincidentFreeBorders(CORBA::Double tolerance);
   CORBA::Short SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
                                         CORBA::Boolean                      createPolygons,
                                         CORBA::Boolean                      createPolyedrs)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_MeshEditor::Sew_Error
     SewFreeBorders(CORBA::Long FirstNodeID1,
@@ -636,13 +636,13 @@ public:
                    CORBA::Long SecondNodeID2,
                    CORBA::Long LastNodeID2,
                    CORBA::Boolean CreatePolygons,
-                   CORBA::Boolean CreatePolyedrs) throw (SALOME::SALOME_Exception);
+                   CORBA::Boolean CreatePolyedrs) ;
   SMESH::SMESH_MeshEditor::Sew_Error
     SewConformFreeBorders(CORBA::Long FirstNodeID1,
                           CORBA::Long SecondNodeID1,
                           CORBA::Long LastNodeID1,
                           CORBA::Long FirstNodeID2,
-                          CORBA::Long SecondNodeID2) throw (SALOME::SALOME_Exception);
+                          CORBA::Long SecondNodeID2) ;
   SMESH::SMESH_MeshEditor::Sew_Error
     SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
                     CORBA::Long SecondNodeIDOnFreeBorder,
@@ -650,14 +650,14 @@ public:
                     CORBA::Long FirstNodeIDOnSide,
                     CORBA::Long LastNodeIDOnSide,
                     CORBA::Boolean CreatePolygons,
-                    CORBA::Boolean CreatePolyedrs) throw (SALOME::SALOME_Exception);
+                    CORBA::Boolean CreatePolyedrs) ;
   SMESH::SMESH_MeshEditor::Sew_Error
     SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
                     const SMESH::long_array& IDsOfSide2Elements,
                     CORBA::Long NodeID1OfSide1ToMerge,
                     CORBA::Long NodeID1OfSide2ToMerge,
                     CORBA::Long NodeID2OfSide1ToMerge,
-                    CORBA::Long NodeID2OfSide2ToMerge) throw (SALOME::SALOME_Exception);
+                    CORBA::Long NodeID2OfSide2ToMerge) ;
 
   /*!
    * Set new nodes for given element.
@@ -665,23 +665,23 @@ public:
    * element - returns false
    */
   CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Group_ptr DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
                                         const char*               theGroupName)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes,
                               const SMESH::long_array& theModifiedElems )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Boolean DoubleNode( CORBA::Long theNodeId,
                              const SMESH::long_array& theModifiedElems )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes,
                                   SMESH::SMESH_GroupBase_ptr theModifiedElems )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
@@ -693,15 +693,15 @@ public:
    */
   SMESH::SMESH_Group_ptr DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
                                              SMESH::SMESH_GroupBase_ptr theModifiedElems )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes,
                                    const SMESH::ListOfGroups& theModifiedElems )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Group_ptr DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
                                               const SMESH::ListOfGroups& theModifiedElems )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -716,7 +716,7 @@ public:
   CORBA::Boolean DoubleNodeElem( const SMESH::long_array& theElems, 
                                  const SMESH::long_array& theNodesNot,
                                  const SMESH::long_array& theAffectedElems )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -732,7 +732,7 @@ public:
   CORBA::Boolean DoubleNodeElemInRegion( const SMESH::long_array& theElems, 
                                          const SMESH::long_array& theNodesNot,
                                          GEOM::GEOM_Object_ptr    theShape )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -746,7 +746,7 @@ public:
   CORBA::Boolean DoubleNodeElemGroup( SMESH::SMESH_GroupBase_ptr theElems,
                                       SMESH::SMESH_GroupBase_ptr theNodesNot,
                                       SMESH::SMESH_GroupBase_ptr theAffectedElems )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -761,14 +761,14 @@ public:
   SMESH::SMESH_Group_ptr DoubleNodeElemGroupNew( SMESH::SMESH_GroupBase_ptr theElems,
                                                  SMESH::SMESH_GroupBase_ptr theNodesNot,
                                                  SMESH::SMESH_GroupBase_ptr theAffectedElems )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfGroups*   DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
                                                  SMESH::SMESH_GroupBase_ptr theNodesNot,
                                                  SMESH::SMESH_GroupBase_ptr theAffectedElems,
                                                  CORBA::Boolean             theElemGroupNeeded,
                                                  CORBA::Boolean             theNodeGroupNeeded)
-    throw (SALOME::SALOME_Exception);
+    ;
   
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -783,7 +783,7 @@ public:
   CORBA::Boolean DoubleNodeElemGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems,
                                               SMESH::SMESH_GroupBase_ptr theNodesNot,
                                               GEOM::GEOM_Object_ptr      theShape )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -798,7 +798,7 @@ public:
   CORBA::Boolean DoubleNodeElemGroups( const SMESH::ListOfGroups& theElems,
                                        const SMESH::ListOfGroups& theNodesNot,
                                        const SMESH::ListOfGroups& theAffectedElems )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -813,14 +813,14 @@ public:
   SMESH::SMESH_Group_ptr DoubleNodeElemGroupsNew( const SMESH::ListOfGroups& theElems,
                                                   const SMESH::ListOfGroups& theNodesNot,
                                                   const SMESH::ListOfGroups& theAffectedElems )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfGroups*   DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems,
                                                   const SMESH::ListOfGroups& theNodesNot,
                                                   const SMESH::ListOfGroups& theAffectedElems,
                                                   CORBA::Boolean             theElemGroupNeeded,
                                                   CORBA::Boolean             theNodeGroupNeeded)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -836,7 +836,7 @@ public:
   CORBA::Boolean DoubleNodeElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
                                                const SMESH::ListOfGroups& theNodesNot,
                                                GEOM::GEOM_Object_ptr      theShape )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Identify the elements that will be affected by node duplication (actual duplication is not performed.
@@ -852,7 +852,7 @@ public:
   SMESH::ListOfGroups* AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
                                                    const SMESH::ListOfGroups& theNodesNot,
                                                    GEOM::GEOM_Object_ptr      theShape )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
@@ -869,7 +869,7 @@ public:
   CORBA::Boolean DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
                                                CORBA::Boolean             createJointElems,
                                                CORBA::Boolean             onAllBoundaries )
-    throw (SALOME::SALOME_Exception);
+    ;
   /*!
    * \brief Double nodes on some external faces and create flat elements.
    * Flat elements are mainly used by some types of mechanic calculations.
@@ -880,7 +880,7 @@ public:
    * @return TRUE if operation has been completed successfully, FALSE otherwise
    */
   CORBA::Boolean CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    *  \brief identify all the elements around a geom shape, get the faces delimiting the hole
@@ -893,7 +893,7 @@ public:
                       const char* groupName,
                       const SMESH::double_array& theNodesCoords,
                       SMESH::array_of_long_array_out GroupsOfNodes)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Generated skin mesh (containing 2D cells) from 3D mesh
@@ -901,7 +901,7 @@ public:
    * \return TRUE if operation has been completed successfully, FALSE otherwise
    */
   CORBA::Boolean Make2DMeshFrom3D()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Mesh_ptr MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr elements,
                                          SMESH::Bnd_Dimension      dimension,
@@ -910,7 +910,7 @@ public:
                                          CORBA::Boolean            toCopyElements,
                                          CORBA::Boolean            toCopyMissingBondary,
                                          SMESH::SMESH_Group_out    group)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension,
                                    const char* groupName,
@@ -919,7 +919,7 @@ public:
                                    const SMESH::ListOfIDSources& groups,
                                    SMESH::SMESH_Mesh_out mesh,
                                    SMESH::SMESH_Group_out group)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
@@ -939,7 +939,7 @@ public:
    */
   void MakePolyLine(SMESH::ListOfPolySegments& segments,
                     const char*                groupName)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * \brief Create a slot of given width around given 1D elements lying on a triangle mesh.
@@ -949,7 +949,7 @@ public:
    */
   SMESH::ListOfEdges* MakeSlot(SMESH::SMESH_GroupBase_ptr segments,
                                CORBA::Double              width)
-    throw (SALOME::SALOME_Exception);
+    ;
 
 
  private: //!< private methods
@@ -971,7 +971,7 @@ public:
    * \brief Return groups by their IDs
    */
   SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfGroups* mirror(TIDSortedElemSet &                  IDsOfElements,
                               const SMESH::AxisStruct &           Axis,
@@ -979,20 +979,20 @@ public:
                               CORBA::Boolean                      Copy,
                               bool                                MakeGroups,
                               ::SMESH_Mesh*                       TargetMesh=0)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::ListOfGroups* translate(TIDSortedElemSet        & IDsOfElements,
                                  const SMESH::DirStruct &  Vector,
                                  CORBA::Boolean            Copy,
                                  bool                      MakeGroups,
                                  ::SMESH_Mesh*             TargetMesh=0)
-    throw (SALOME::SALOME_Exception);
+    ;
   SMESH::ListOfGroups* rotate(TIDSortedElemSet &           IDsOfElements,
                               const SMESH::AxisStruct &  Axis,
                               CORBA::Double             Angle,
                               CORBA::Boolean            Copy,
                               bool                      MakeGroups,
                               ::SMESH_Mesh*             TargetMesh=0)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfGroups* scale(SMESH::SMESH_IDSource_ptr   theObject,
                              const SMESH::PointStruct&   thePoint,
@@ -1000,12 +1000,12 @@ public:
                              CORBA::Boolean              theCopy,
                              bool                        theMakeGroups,
                              ::SMESH_Mesh*               theTargetMesh=0)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   void convertToQuadratic(CORBA::Boolean            theForce3d,
                           CORBA::Boolean            theToBiQuad,
                           SMESH::SMESH_IDSource_ptr theObject = SMESH::SMESH_IDSource::_nil())
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Mesh_ptr makeMesh(const char* theMeshName);
 

src/SMESH_I/SMESH_Mesh_i.cxx

@@ -183,7 +183,7 @@ SMESH_Mesh_i::~SMESH_Mesh_i()
 //=============================================================================
 
 void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject )
-    throw (SALOME::SALOME_Exception)
+    
 {
   Unexpect aCatch(SALOME_SalomeException);
   try {
@@ -206,7 +206,7 @@ void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject )
 //================================================================================
 
 CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh()
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   bool res = false;
@@ -226,7 +226,7 @@ CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh()
 //================================================================================
 
 GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   GEOM::GEOM_Object_var aShapeObj;
@@ -263,7 +263,7 @@ GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
  */
 //================================================================================
 
-CORBA::Boolean SMESH_Mesh_i::IsLoaded() throw (SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_Mesh_i::IsLoaded() 
 {
   Unexpect aCatch(SALOME_SalomeException);
   return !_preMeshInfo;
@@ -275,7 +275,7 @@ CORBA::Boolean SMESH_Mesh_i::IsLoaded() throw (SALOME::SALOME_Exception)
  */
 //================================================================================
 
-void SMESH_Mesh_i::Load() throw (SALOME::SALOME_Exception)
+void SMESH_Mesh_i::Load() 
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -288,7 +288,7 @@ void SMESH_Mesh_i::Load() throw (SALOME::SALOME_Exception)
  */
 //================================================================================
 
-void SMESH_Mesh_i::Clear() throw (SALOME::SALOME_Exception)
+void SMESH_Mesh_i::Clear() 
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -315,7 +315,7 @@ void SMESH_Mesh_i::Clear() throw (SALOME::SALOME_Exception)
 //================================================================================
 
 void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID)
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -394,7 +394,6 @@ static SMESH::ComputeError* ConvertComputeError( SMESH_ComputeErrorPtr errorPtr
 
 SMESH::DriverMED_ReadStatus
 SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
-  throw ( SALOME::SALOME_Exception )
 {
   Unexpect aCatch(SALOME_SalomeException);
   int status;
@@ -433,7 +432,7 @@ SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
 SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char*  theFileName,
                                                           const int    theMeshIndex,
                                                           std::string& theMeshName )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   int status;
@@ -499,7 +498,7 @@ SMESH::long_array* SMESH_Mesh_i::GetMEDVersionsCompatibleForAppend()
 //=============================================================================
 
 int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   SMESH_TRY;
 
@@ -529,7 +528,7 @@ int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
 //=============================================================================
 
 int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   SMESH_TRY;
 
@@ -574,7 +573,7 @@ namespace
 
 SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName,
                                                   bool        theMakeRequiredGroups )
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH_ComputeErrorPtr error;
 
@@ -646,7 +645,7 @@ SMESH::Hypothesis_Status
 SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
                             SMESH::SMESH_Hypothesis_ptr anHyp,
                             CORBA::String_out           anErrorText)
-  throw(SALOME::SALOME_Exception)
+
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -739,7 +738,7 @@ SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
 
 SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
                                                         SMESH::SMESH_Hypothesis_ptr anHyp)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -818,7 +817,7 @@ SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
 
 SMESH::ListOfHypothesis *
 SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
-throw(SALOME::SALOME_Exception)
+
 {
   Unexpect aCatch(SALOME_SalomeException);
   if (MYDEBUG) MESSAGE("GetHypothesisList");
@@ -858,7 +857,7 @@ throw(SALOME::SALOME_Exception)
  */
 //================================================================================
 
-SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes() throw (SALOME::SALOME_Exception)
+SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes() 
 {
   Unexpect aCatch(SALOME_SalomeException);
   if (MYDEBUG) MESSAGE("GetSubMeshes");
@@ -902,7 +901,7 @@ SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes() throw (SALOME::SALOME_Excepti
 
 SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShape,
                                                   const char*           theName )
-     throw(SALOME::SALOME_Exception)
+     
 {
   Unexpect aCatch(SALOME_SalomeException);
   if (CORBA::is_nil(aSubShape))
@@ -954,7 +953,7 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShap
 //================================================================================
 
 void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH_TRY;
 
@@ -998,7 +997,7 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
 
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType,
                                                   const char*        theName )
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -1030,7 +1029,7 @@ SMESH::SMESH_GroupOnGeom_ptr
 SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType    theElemType,
                                    const char*           theName,
                                    GEOM::GEOM_Object_ptr theGeomObj)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -1072,7 +1071,7 @@ SMESH::SMESH_GroupOnFilter_ptr
 SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
                                     const char*        theName,
                                     SMESH::Filter_ptr  theFilter )
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -1112,7 +1111,7 @@ SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
 //================================================================================
 
 void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
-  throw (SALOME::SALOME_Exception)
+  
 {
   if ( theGroup->_is_nil() )
     return;
@@ -1152,7 +1151,7 @@ void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
 //=============================================================================
 
 void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH_TRY;
   if ( _preMeshInfo )
@@ -1226,7 +1225,7 @@ void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup
  */
 //================================================================================
 
-SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups() throw(SALOME::SALOME_Exception)
+SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups() 
 {
   Unexpect aCatch(SALOME_SalomeException);
   if (MYDEBUG) MESSAGE("GetGroups");
@@ -1265,7 +1264,7 @@ SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups() throw(SALOME::SALOME_Exception)
  */
 //=============================================================================
 
-CORBA::Long SMESH_Mesh_i::NbGroups() throw (SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbGroups() 
 {
   Unexpect aCatch(SALOME_SalomeException);
   return _mapGroups.size();
@@ -1280,7 +1279,7 @@ CORBA::Long SMESH_Mesh_i::NbGroups() throw (SALOME::SALOME_Exception)
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                                   SMESH::SMESH_GroupBase_ptr theGroup2,
                                                   const char*                theName )
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1324,7 +1323,7 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr the
 
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups,
                                                        const char*                theName )
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1387,7 +1386,7 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                                       SMESH::SMESH_GroupBase_ptr theGroup2,
                                                       const char*                theName )
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1453,7 +1452,7 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr
 SMESH::SMESH_Group_ptr
 SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups,
                                     const char*                theName )
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1537,7 +1536,7 @@ SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups,
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                                 SMESH::SMESH_GroupBase_ptr theGroup2,
                                                 const char*                theName )
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1604,7 +1603,7 @@ SMESH::SMESH_Group_ptr
 SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups,
                               const SMESH::ListOfGroups& theToolGroups,
                               const char*                theName )
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1737,7 +1736,7 @@ SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfIDSources& theGroups,
                              const char*                   theName,
                              SMESH::NB_COMMON_NODES_ENUM   theNbCommonNodes,
                              CORBA::Boolean                theUnderlyingOnly)
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1918,7 +1917,7 @@ SMESH::ListOfGroups*
 SMESH_Mesh_i::FaceGroupsSeparatedByEdges( CORBA::Double  theSharpAngle,
                                           CORBA::Boolean theCreateEdges,
                                           CORBA::Boolean theUseExistingEdges )
-  throw (SALOME::SALOME_Exception)
+  
 {
   if ( theSharpAngle < 0 || theSharpAngle > 180 )
     THROW_SALOME_CORBA_EXCEPTION("Invalid sharp angle, it must be between 0 and 180 degrees",
@@ -2046,7 +2045,7 @@ void SMESH_Mesh_i::removeGeomGroupData(CORBA::Object_ptr theSmeshObj)
 //================================================================================
 
 void SMESH_Mesh_i::ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom)
-  throw (SALOME::SALOME_Exception)
+  
 {
   // check if geometry changed
   bool geomChanged = true;
@@ -3041,7 +3040,7 @@ void SMESH_Mesh_i::CheckGeomGroupModif()
 //=============================================================================
 
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroup )
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::SMESH_Group_var aGroup;
 
@@ -3343,7 +3342,7 @@ void SMESH_Mesh_i::removeGroup( const int theId )
 //================================================================================
 
 SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
-  throw(SALOME::SALOME_Exception)
+  
 {
   SMESH::log_array_var aLog;
 
@@ -3396,7 +3395,7 @@ SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
  */
 //================================================================================
 
-void SMESH_Mesh_i::ClearLog() throw(SALOME::SALOME_Exception)
+void SMESH_Mesh_i::ClearLog() 
 {
   SMESH_TRY;
   _impl->ClearLog();
@@ -3409,7 +3408,7 @@ void SMESH_Mesh_i::ClearLog() throw(SALOME::SALOME_Exception)
  */
 //================================================================================
 
-CORBA::Long SMESH_Mesh_i::GetId()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::GetId()
 {
   return _id;
 }
@@ -3510,7 +3509,7 @@ void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl)
 //=============================================================================
 
 SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::SMESH_MeshEditor_var aMeshEdVar;
 
@@ -3539,7 +3538,7 @@ SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
 //=============================================================================
 
 SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer()
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::SMESH_MeshEditor_var aMeshEdVar;
 
@@ -3563,7 +3562,7 @@ SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer()
  */
 //================================================================================
 
-CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard() throw(SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard() 
 {
   Unexpect aCatch(SALOME_SalomeException);
   return _impl->HasModificationsToDiscard();
@@ -3611,7 +3610,7 @@ static SALOMEDS::Color getUniqueColor( const std::list<SALOMEDS::Color>& theRese
  */
 //=============================================================================
 
-void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) throw(SALOME::SALOME_Exception)
+void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) 
 {
   Unexpect aCatch(SALOME_SalomeException);
   _impl->SetAutoColor(theAutoColor);
@@ -3635,7 +3634,7 @@ void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) throw(SALOME::SALOM
  */
 //=============================================================================
 
-CORBA::Boolean SMESH_Mesh_i::GetAutoColor() throw(SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_Mesh_i::GetAutoColor() 
 {
   Unexpect aCatch(SALOME_SalomeException);
   return _impl->GetAutoColor();
@@ -3752,7 +3751,7 @@ void SMESH_Mesh_i::ExportMED(const char*        file,
                              CORBA::Long        version,
                              CORBA::Boolean     overwrite,
                              CORBA::Boolean     autoDimension)
-  throw(SALOME::SALOME_Exception)
+  
 {
   //MESSAGE("MED minor version: "<< minor);
   SMESH_TRY;
@@ -3781,7 +3780,7 @@ void SMESH_Mesh_i::ExportMED(const char*        file,
 
 void SMESH_Mesh_i::ExportSAUV (const char* file,
                                CORBA::Boolean auto_groups)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -3801,7 +3800,7 @@ void SMESH_Mesh_i::ExportSAUV (const char* file,
 //================================================================================
 
 void SMESH_Mesh_i::ExportDAT (const char *file)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -3824,7 +3823,7 @@ void SMESH_Mesh_i::ExportDAT (const char *file)
 //================================================================================
 
 void SMESH_Mesh_i::ExportUNV (const char *file)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -3847,7 +3846,7 @@ void SMESH_Mesh_i::ExportUNV (const char *file)
 //================================================================================
 
 void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -3884,7 +3883,7 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
                                    const GEOM::ListOfFields& fields,
                                    const char*               geomAssocFields,
                                    CORBA::Double             ZTolerance)
-  throw (SALOME::SALOME_Exception)
+  
 {
   MESSAGE("MED version: "<< version);
   SMESH_TRY;
@@ -4269,7 +4268,7 @@ void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field&        fieldWriter,
 
 void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart,
                                    const char*                 file)
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4291,7 +4290,7 @@ void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart,
 
 void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart,
                                    const char*                 file)
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4314,7 +4313,7 @@ void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart,
 void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart,
                                    const char*                 file,
                                    ::CORBA::Boolean            isascii)
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4344,7 +4343,7 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart,
                               const char*                 file,
                               CORBA::Boolean              overwrite,
                               CORBA::Boolean              groupElemsByType)
-  throw (SALOME::SALOME_Exception)
+  
 {
 #ifdef WITH_CGNS
   Unexpect aCatch(SALOME_SalomeException);
@@ -4383,7 +4382,7 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart,
 void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart,
                              const char*                 file,
                              bool                        withRequiredGroups)
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4422,7 +4421,7 @@ CORBA::Double SMESH_Mesh_i::GetComputeProgress()
  */
 //================================================================================
 
-CORBA::Long SMESH_Mesh_i::NbNodes()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbNodes()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4437,7 +4436,7 @@ CORBA::Long SMESH_Mesh_i::NbNodes()throw(SALOME::SALOME_Exception)
  */
 //================================================================================
 
-CORBA::Long SMESH_Mesh_i::NbElements()throw (SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbElements()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4452,7 +4451,7 @@ CORBA::Long SMESH_Mesh_i::NbElements()throw (SALOME::SALOME_Exception)
  */
 //================================================================================
 
-CORBA::Long SMESH_Mesh_i::Nb0DElements()throw (SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::Nb0DElements()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4467,7 +4466,7 @@ CORBA::Long SMESH_Mesh_i::Nb0DElements()throw (SALOME::SALOME_Exception)
  */
 //================================================================================
 
-CORBA::Long SMESH_Mesh_i::NbBalls() throw (SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbBalls() 
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4482,7 +4481,7 @@ CORBA::Long SMESH_Mesh_i::NbBalls() throw (SALOME::SALOME_Exception)
  */
 //================================================================================
 
-CORBA::Long SMESH_Mesh_i::NbEdges()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbEdges()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4498,7 +4497,7 @@ CORBA::Long SMESH_Mesh_i::NbEdges()throw(SALOME::SALOME_Exception)
 //================================================================================
 
 CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4513,7 +4512,7 @@ CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
  */
 //================================================================================
 
-CORBA::Long SMESH_Mesh_i::NbFaces()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbFaces()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4528,7 +4527,7 @@ CORBA::Long SMESH_Mesh_i::NbFaces()throw(SALOME::SALOME_Exception)
  */
 //================================================================================
 
-CORBA::Long SMESH_Mesh_i::NbTriangles()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbTriangles()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4543,7 +4542,7 @@ CORBA::Long SMESH_Mesh_i::NbTriangles()throw(SALOME::SALOME_Exception)
  */
 //================================================================================
 
-CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4552,7 +4551,7 @@ CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles()throw(SALOME::SALOME_Exception)
   return _impl->NbBiQuadTriangles();
 }
 
-CORBA::Long SMESH_Mesh_i::NbQuadrangles()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbQuadrangles()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4561,7 +4560,7 @@ CORBA::Long SMESH_Mesh_i::NbQuadrangles()throw(SALOME::SALOME_Exception)
   return _impl->NbQuadrangles();
 }
 
-CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4570,7 +4569,7 @@ CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()throw(SALOME::SALOME_Exception)
   return _impl->NbBiQuadQuadrangles();
 }
 
-CORBA::Long SMESH_Mesh_i::NbPolygons() throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbPolygons() 
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4579,7 +4578,7 @@ CORBA::Long SMESH_Mesh_i::NbPolygons() throw(SALOME::SALOME_Exception)
   return _impl->NbPolygons();
 }
 
-CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order) 
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4589,7 +4588,7 @@ CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order) throw(SAL
 }
 
 CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4599,7 +4598,7 @@ CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4609,7 +4608,7 @@ CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4620,7 +4619,7 @@ CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
 
 //=============================================================================
 
-CORBA::Long SMESH_Mesh_i::NbVolumes()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbVolumes()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4629,7 +4628,7 @@ CORBA::Long SMESH_Mesh_i::NbVolumes()throw(SALOME::SALOME_Exception)
   return _impl->NbVolumes();
 }
 
-CORBA::Long SMESH_Mesh_i::NbTetras()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbTetras()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4638,7 +4637,7 @@ CORBA::Long SMESH_Mesh_i::NbTetras()throw(SALOME::SALOME_Exception)
   return _impl->NbTetras();
 }
 
-CORBA::Long SMESH_Mesh_i::NbHexas()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbHexas()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4647,7 +4646,7 @@ CORBA::Long SMESH_Mesh_i::NbHexas()throw(SALOME::SALOME_Exception)
   return _impl->NbHexas();
 }
 
-CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4656,7 +4655,7 @@ CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas()throw(SALOME::SALOME_Exception)
   return _impl->NbTriQuadraticHexas();
 }
 
-CORBA::Long SMESH_Mesh_i::NbPyramids()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbPyramids()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4665,7 +4664,7 @@ CORBA::Long SMESH_Mesh_i::NbPyramids()throw(SALOME::SALOME_Exception)
   return _impl->NbPyramids();
 }
 
-CORBA::Long SMESH_Mesh_i::NbPrisms()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbPrisms()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4674,7 +4673,7 @@ CORBA::Long SMESH_Mesh_i::NbPrisms()throw(SALOME::SALOME_Exception)
   return _impl->NbPrisms();
 }
 
-CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4683,7 +4682,7 @@ CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms()throw(SALOME::SALOME_Exception)
   return _impl->NbHexagonalPrisms();
 }
 
-CORBA::Long SMESH_Mesh_i::NbPolyhedrons()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbPolyhedrons()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4693,7 +4692,7 @@ CORBA::Long SMESH_Mesh_i::NbPolyhedrons()throw(SALOME::SALOME_Exception)
 }
 
 CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4703,7 +4702,7 @@ CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4713,7 +4712,7 @@ CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4723,7 +4722,7 @@ CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4733,7 +4732,7 @@ CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
-  throw(SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4748,7 +4747,7 @@ CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
  */
 //=============================================================================
 
-CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbSubMesh()
 {
   Unexpect aCatch(SALOME_SalomeException);
   return _mapSubMesh_i.size();
@@ -4785,7 +4784,7 @@ SMESH::long_array* SMESH_Mesh_i::GetIDs()
 //=============================================================================
 
 SMESH::long_array* SMESH_Mesh_i::GetElementsId()
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4814,7 +4813,7 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsId()
 //=============================================================================
 
 SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType )
-    throw (SALOME::SALOME_Exception)
+    
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4854,7 +4853,7 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemTy
 //=============================================================================
 
 SMESH::long_array* SMESH_Mesh_i::GetNodesId()
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4882,7 +4881,7 @@ SMESH::long_array* SMESH_Mesh_i::GetNodesId()
 //=============================================================================
 
 SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::ElementType type = SMESH::ALL;
   SMESH_TRY;
@@ -4904,7 +4903,7 @@ SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const boo
 //=============================================================================
 
 SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id )
-  throw (SALOME::SALOME_Exception)
+  
 {
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
@@ -4923,7 +4922,7 @@ SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id )
 //=============================================================================
 
 SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id )
-  throw (SALOME::SALOME_Exception)
+  
 {
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
@@ -4942,7 +4941,7 @@ SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id )
 //=============================================================================
 
 SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
-     throw (SALOME::SALOME_Exception)
+     
 {
   SMESH::long_array_var aResult = new SMESH::long_array();
 
@@ -4979,7 +4978,7 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
 
 SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
                                                    CORBA::Boolean    all)
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::long_array_var aResult = new SMESH::long_array();
 
@@ -5031,7 +5030,7 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
 //=============================================================================
 
 SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID)
-  throw (SALOME::SALOME_Exception)
+  
 {
   SMESH::ElementType type = SMESH::ALL;
 
@@ -5691,7 +5690,7 @@ SMESH::double_array* SMESH_Mesh_i::BaryCenter(const CORBA::Long id)
 SMESH::ListOfGroups*
 SMESH_Mesh_i::MakeGroupsOfBadInputElements( int         theSubShapeID,
                                             const char* theGroupName )
-  throw ( SALOME::SALOME_Exception )
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
 

src/SMESH_I/SMESH_Mesh_i.hxx

@@ -66,130 +66,130 @@ public:
   // --- CORBA
 
   void SetShape( GEOM::GEOM_Object_ptr theShapeObject )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Boolean HasShapeToMesh()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   GEOM::GEOM_Object_ptr GetShapeToMesh()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   virtual void ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Boolean IsLoaded()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   void Load()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   void Clear()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   void ClearSubMesh(CORBA::Long ShapeID)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::Hypothesis_Status AddHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
                                          SMESH::SMESH_Hypothesis_ptr anHyp,
                                          CORBA::String_out           anErrorText)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::Hypothesis_Status RemoveHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
                                             SMESH::SMESH_Hypothesis_ptr anHyp)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfHypothesis* GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::submesh_array* GetSubMeshes()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_subMesh_ptr GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   void RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Group_ptr CreateGroup( SMESH::ElementType theElemType, const char* theName )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_GroupOnGeom_ptr CreateGroupFromGEOM(SMESH::ElementType    theElemType,
                                                    const char*           theName,
                                                    GEOM::GEOM_Object_ptr theGeomObj )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_GroupOnFilter_ptr CreateGroupFromFilter(SMESH::ElementType theElemType,
                                                        const char*        theName,
                                                        SMESH::Filter_ptr  theFilter )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   void RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   void RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfGroups* GetGroups()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbGroups()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Group_ptr UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                       SMESH::SMESH_GroupBase_ptr theGroup2,
                                       const char* theName )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Group_ptr UnionListOfGroups( const SMESH::ListOfGroups& theGroups,
                                             const char* theName)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Group_ptr IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                           SMESH::SMESH_GroupBase_ptr theGroup2,
                                           const char* theName )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Group_ptr IntersectListOfGroups( const SMESH::ListOfGroups&  theGroups,
                                                 const char* theName )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Group_ptr CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                     SMESH::SMESH_GroupBase_ptr theGroup2,
                                     const char* theName )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Group_ptr CutListOfGroups( const SMESH::ListOfGroups& theMainGroups,
                                           const SMESH::ListOfGroups& theToolGroups,
                                           const char* theName )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Group_ptr CreateDimGroup( const SMESH::ListOfIDSources& theGroups,
                                          SMESH::ElementType            theElemType,
                                          const char*                   theName,
                                          SMESH::NB_COMMON_NODES_ENUM   theNbCommonNodes,
                                          CORBA::Boolean                theUnderlyingOnly )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ListOfGroups* FaceGroupsSeparatedByEdges( CORBA::Double  theSharpAngle,
                                                    CORBA::Boolean theCreateEdges,
                                                    CORBA::Boolean theUseExistingEdges )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::SMESH_Group_ptr ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroupOn )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet)
-    throw (SALOME::SALOME_Exception);
+    ;
 
-  SMESH::SMESH_MeshEditor_ptr GetMeshEditor() throw (SALOME::SALOME_Exception);
+  SMESH::SMESH_MeshEditor_ptr GetMeshEditor() ;
 
-  SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer() throw (SALOME::SALOME_Exception);
+  SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer() ;
 
-  CORBA::Boolean HasModificationsToDiscard() throw (SALOME::SALOME_Exception);
+  CORBA::Boolean HasModificationsToDiscard() ;
 
-  void ClearLog() throw (SALOME::SALOME_Exception);
+  void ClearLog() ;
 
-  CORBA::Long GetId() throw (SALOME::SALOME_Exception);
+  CORBA::Long GetId() ;
 
   // --- C++ interface
 
@@ -199,34 +199,34 @@ public:
   SMESH_Gen_i* GetGen() { return _gen_i; }
 
   int ImportUNVFile( const char* theFileName )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   int ImportSTLFile( const char* theFileName )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ComputeError* ImportGMFFile( const char* theFileName,
                                       bool        theMakeRequiredGroups)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * consult DriverMED_R_SMESHDS_Mesh::ReadStatus for returned value
    */
   SMESH::DriverMED_ReadStatus ImportMEDFile( const char* theFileName, const char* theMeshName )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::DriverMED_ReadStatus ImportCGNSFile( const char*  theFileName,
                                               const int    theMeshIndex,
                                               std::string& theMeshName)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    *  Auto color
    */
   void SetAutoColor(CORBA::Boolean theAutoColor)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Boolean GetAutoColor()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*! Check group names for duplications.
    *  Consider maximum group name length stored in MED file.
@@ -248,20 +248,20 @@ public:
                   CORBA::Boolean     auto_groups,
                   CORBA::Long        version,
                   CORBA::Boolean     overwrite,
-                  CORBA::Boolean     autoDimension = true) throw (SALOME::SALOME_Exception);
+                  CORBA::Boolean     autoDimension = true) ;
 
-  void ExportSAUV( const char* file, CORBA::Boolean auto_groups ) throw (SALOME::SALOME_Exception);
+  void ExportSAUV( const char* file, CORBA::Boolean auto_groups ) ;
 
-  void ExportDAT( const char* file ) throw (SALOME::SALOME_Exception);
+  void ExportDAT( const char* file ) ;
-  void ExportUNV( const char* file ) throw (SALOME::SALOME_Exception);
+  void ExportUNV( const char* file ) ;
-  void ExportSTL( const char* file, bool isascii ) throw (SALOME::SALOME_Exception);
+  void ExportSTL( const char* file, bool isascii ) ;
   void ExportCGNS(SMESH::SMESH_IDSource_ptr meshPart,
                   const char*               file,
                   CORBA::Boolean            overwrite,
-                  CORBA::Boolean            groupElemsByType) throw (SALOME::SALOME_Exception);
+                  CORBA::Boolean            groupElemsByType) ;
   void ExportGMF(SMESH::SMESH_IDSource_ptr meshPart,
                  const char*               file,
-                 CORBA::Boolean            withRequiredGroups) throw (SALOME::SALOME_Exception);
+                 CORBA::Boolean            withRequiredGroups) ;
 
   void ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
                        const char*               file,
@@ -271,130 +271,130 @@ public:
                        CORBA::Boolean            autoDim,
                        const GEOM::ListOfFields& fields,
                        const char*               geomAssocFields,
-                       CORBA::Double             ZTolerance) throw (SALOME::SALOME_Exception);
+                       CORBA::Double             ZTolerance) ;
   void ExportPartToDAT(SMESH::SMESH_IDSource_ptr meshPart,
-                       const char*               file) throw (SALOME::SALOME_Exception);
+                       const char*               file) ;
   void ExportPartToUNV(SMESH::SMESH_IDSource_ptr meshPart,
-                       const char*               file) throw (SALOME::SALOME_Exception);
+                       const char*               file) ;
   void ExportPartToSTL(SMESH::SMESH_IDSource_ptr meshPart,
                        const char*               file,
-                       CORBA::Boolean            isascii) throw (SALOME::SALOME_Exception);
+                       CORBA::Boolean            isascii) ;
 
   CORBA::Double GetComputeProgress();
 
   CORBA::Long NbNodes()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbElements()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long Nb0DElements()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbBalls()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbEdges()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbFaces()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbTriangles()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbBiQuadTriangles()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbQuadrangles()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbBiQuadQuadrangles()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbPolygons()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbVolumes()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbTetras()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbHexas()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbTriQuadraticHexas()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbPyramids()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbPrisms()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbHexagonalPrisms()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbPolyhedrons()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long NbSubMesh()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::long_array* GetElementsId()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::long_array* GetNodesId()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::EntityType GetElementGeomType( CORBA::Long id )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::GeometryType GetElementShape( CORBA::Long id )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Returns ID of elements for given submesh
    */
   SMESH::long_array* GetSubMeshElementsId(CORBA::Long ShapeID)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Returns ID of nodes for given submesh
@@ -402,20 +402,20 @@ public:
    * returns only nodes on shapes.
    */
   SMESH::long_array* GetSubMeshNodesId(CORBA::Long ShapeID, CORBA::Boolean all)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   /*!
    * Returns type of elements for given submesh
    */
   SMESH::ElementType GetSubMeshElementType(CORBA::Long ShapeID)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   char* Dump();
 
   // Create groups of elements preventing computation of a sub-shape
   SMESH::ListOfGroups* MakeGroupsOfBadInputElements( int         theSubShapeID,
                                                      const char* theGroupName)
-    throw (SALOME::SALOME_Exception);
+    ;
 
   // ===================================================
   // Internal methods not available through CORBA

src/SMESH_I/SMESH_subMesh_i.cxx

@@ -141,7 +141,7 @@ bool getSubMeshes(::SMESH_subMesh*  theSubMesh,
 //=============================================================================
 
 CORBA::Long SMESH_subMesh_i::GetNumberOfElements()
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -172,7 +172,7 @@ CORBA::Long SMESH_subMesh_i::GetNumberOfElements()
 //=============================================================================
 
 CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -220,7 +220,7 @@ CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
 //=============================================================================
 
 SMESH::long_array* SMESH_subMesh_i::GetElementsId()
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -265,7 +265,7 @@ SMESH::long_array* SMESH_subMesh_i::GetElementsId()
 //=============================================================================
 
 SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theElemType )
-    throw (SALOME::SALOME_Exception)
+    
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -351,7 +351,7 @@ SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theEle
 //=============================================================================
   
 SMESH::long_array* SMESH_subMesh_i::GetNodesId()
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -366,7 +366,7 @@ SMESH::long_array* SMESH_subMesh_i::GetNodesId()
 //=============================================================================
   
 SMESH::SMESH_Mesh_ptr SMESH_subMesh_i::GetFather()
-  throw (SALOME::SALOME_Exception)
+  
 {
   Unexpect aCatch(SALOME_SalomeException);
   return _mesh_i->_this();
@@ -389,7 +389,7 @@ CORBA::Long SMESH_subMesh_i::GetId()
 //=======================================================================
 
 GEOM::GEOM_Object_ptr SMESH_subMesh_i::GetSubShape()
-     throw (SALOME::SALOME_Exception)
+     
 {
   Unexpect aCatch(SALOME_SalomeException);
   GEOM::GEOM_Object_var aShapeObj;
@@ -428,7 +428,7 @@ SMESH::long_array* SMESH_subMesh_i::GetIDs()
  */
 //=============================================================================
 SMESH::ElementType SMESH_subMesh_i::GetElementType( const CORBA::Long id, const bool iselem )
-  throw (SALOME::SALOME_Exception)
+  
 {
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
@@ -607,7 +607,7 @@ SMESH_Invalid_subMesh_i::SMESH_Invalid_subMesh_i( PortableServer::POA_ptr thePOA
 //=======================================================================
 
 GEOM::GEOM_Object_ptr SMESH_Invalid_subMesh_i::GetSubShape()
-  throw (SALOME::SALOME_Exception)
+  
 {
   return GEOM::GEOM_Object::_duplicate( _geom );
 }

src/SMESH_I/SMESH_subMesh_i.hxx

@@ -54,28 +54,28 @@ public:
   ~SMESH_subMesh_i();
 
   CORBA::Long GetNumberOfElements()
-    throw (SALOME::SALOME_Exception);
+    ;
   
   CORBA::Long  GetNumberOfNodes( CORBA::Boolean all )
-    throw (SALOME::SALOME_Exception);
+    ;
   
   SMESH::long_array* GetElementsId()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
-    throw (SALOME::SALOME_Exception);
+    ;
   
   SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
-    throw (SALOME::SALOME_Exception);
+    ;
   
   SMESH::long_array* GetNodesId()
-    throw (SALOME::SALOME_Exception);
+    ;
   
   SMESH::SMESH_Mesh_ptr GetFather()
-    throw (SALOME::SALOME_Exception);
+    ;
   
   GEOM::GEOM_Object_ptr GetSubShape()
-    throw (SALOME::SALOME_Exception);
+    ;
 
   CORBA::Long GetId();
 
@@ -145,7 +145,7 @@ class SMESH_I_EXPORT SMESH_Invalid_subMesh_i:
                            GEOM::GEOM_Object_ptr   shape);
 
   virtual GEOM::GEOM_Object_ptr GetSubShape()
-    throw (SALOME::SALOME_Exception);
+    ;
 
  protected:
 

src/StdMeshers/StdMeshers_Adaptive1D.cxx

@@ -937,7 +937,6 @@ StdMeshers_Adaptive1D::~StdMeshers_Adaptive1D()
 //function : SetDeflection
 //purpose  : 
 void StdMeshers_Adaptive1D::SetDeflection(double value)
-  throw(SALOME_Exception)
 {
   if (value <= std::numeric_limits<double>::min() )
     throw SALOME_Exception("Deflection must be greater that zero");
@@ -951,7 +950,6 @@ void StdMeshers_Adaptive1D::SetDeflection(double value)
 //function : SetMinSize
 //purpose  : Sets minimal allowed segment length
 void StdMeshers_Adaptive1D::SetMinSize(double minSize)
-  throw(SALOME_Exception)
 {
   if (minSize <= std::numeric_limits<double>::min() )
     throw SALOME_Exception("Min size must be greater that zero");
@@ -966,7 +964,6 @@ void StdMeshers_Adaptive1D::SetMinSize(double minSize)
 //function : SetMaxSize
 //purpose  : Sets maximal allowed segment length
 void StdMeshers_Adaptive1D::SetMaxSize(double maxSize)
-  throw(SALOME_Exception)
 {
   if (maxSize <= std::numeric_limits<double>::min() )
     throw SALOME_Exception("Max size must be greater that zero");

src/StdMeshers/StdMeshers_Adaptive1D.hxx

@@ -43,20 +43,20 @@ class STDMESHERS_EXPORT StdMeshers_Adaptive1D : public SMESH_Hypothesis
   /*!
    * Sets minimal allowed segment length
    */
-  void SetMinSize( double minSegLen ) throw (SALOME_Exception);
+  void SetMinSize( double minSegLen ) ;
   double GetMinSize() const { return myMinSize; }
 
   /*!
    * Sets maximal allowed segment length
    */
-  void SetMaxSize( double maxSegLen ) throw (SALOME_Exception);
+  void SetMaxSize( double maxSegLen ) ;
   double GetMaxSize() const { return myMaxSize; }
 
   /*!
    * Sets <deflection> parameter value, 
    * i.e. a maximal allowed distance between a segment and an edge.
    */
-  void SetDeflection(double value) throw(SALOME_Exception);
+  void SetDeflection(double value) ;
   double GetDeflection() const { return myDeflection; }
   
   virtual std::ostream & SaveTo(std::ostream & save);

src/StdMeshers/StdMeshers_Arithmetic1D.cxx

@@ -74,7 +74,6 @@ StdMeshers_Arithmetic1D::~StdMeshers_Arithmetic1D()
 //=============================================================================
 
 void StdMeshers_Arithmetic1D::SetLength(double length, bool isStartLength)
-     throw(SALOME_Exception)
 {
   if ( (isStartLength ? _begLength : _endLength) != length ) {
     if (length <= 0)

src/StdMeshers/StdMeshers_Arithmetic1D.hxx

@@ -42,7 +42,7 @@ public:
   StdMeshers_Arithmetic1D(int hypId, SMESH_Gen* gen);
   virtual ~StdMeshers_Arithmetic1D();
 
-  void SetLength(double length, bool isStartLength) throw(SALOME_Exception);
+  void SetLength(double length, bool isStartLength) ;
 
   double GetLength(bool isStartLength) const;
 

src/StdMeshers/StdMeshers_AutomaticLength.cxx

@@ -84,7 +84,7 @@ const double theCoarseConst = 0.5;
 const double theFineConst   = 4.5;
 
 void StdMeshers_AutomaticLength::SetFineness(double theFineness)
-  throw(SALOME_Exception)
+  
 {
   if ( theFineness < 0.0 || theFineness > 1.0 )
     throw SALOME_Exception(LOCALIZED("theFineness is out of range [0.0-1.0]"));
@@ -239,7 +239,7 @@ namespace {
 
 double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
                                              const double      theEdgeLength)
-  throw(SALOME_Exception)
+  
 {
   if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));
 
@@ -261,7 +261,7 @@ double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
 
 double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh*   theMesh,
                                              const TopoDS_Shape& anEdge)
-  throw(SALOME_Exception)
+  
 {
   if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));
 

src/StdMeshers/StdMeshers_AutomaticLength.hxx

@@ -56,13 +56,13 @@ public:
    * \brief Computes segment for a given edge
    */
   double GetLength(const SMESH_Mesh* aMesh, const TopoDS_Shape& anEdge)
-    throw(SALOME_Exception);
+    ;
 
   /*!
    * \brief Computes segment length for an edge of given length
    */
   double GetLength(const SMESH_Mesh* aMesh, const double edgeLength)
-    throw(SALOME_Exception);
+    ;
 
   /*!
    * \brief Set Fineness
@@ -75,7 +75,7 @@ public:
    * is divided by (0.5 + 4.5 x theFineness)
    */
   void SetFineness(double theFineness)
-    throw(SALOME_Exception);
+    ;
 
   /*!
    * \brief Return mesh Fineness

src/StdMeshers/StdMeshers_CartesianParameters3D.cxx

@@ -133,7 +133,7 @@ namespace
   void checkGridSpacing(std::vector<std::string>& spaceFunctions,
                         std::vector<double>&      internalPoints,
                         const std::string&        axis)
-    throw ( SALOME_Exception )
+    
   {
     if ( spaceFunctions.empty() )
       throw SALOME_Exception(SMESH_Comment("Empty space function for ") << axis );
@@ -170,7 +170,7 @@ namespace
 //=======================================================================
 
 void StdMeshers_CartesianParameters3D::SetGrid(std::vector<double>& coords, int axis)
-  throw ( SALOME_Exception )
+  
 {
   checkAxis( axis );
 
@@ -198,7 +198,7 @@ void StdMeshers_CartesianParameters3D::SetGrid(std::vector<double>& coords, int
 void StdMeshers_CartesianParameters3D::SetGridSpacing(std::vector<string>& xSpaceFuns,
                                                       std::vector<double>& xInternalPoints,
                                                       const int            axis)
-  throw ( SALOME_Exception )
+  
 {
   checkAxis( axis );
 
@@ -252,7 +252,7 @@ bool StdMeshers_CartesianParameters3D::GetFixedPoint(double p[3]) const
 //=======================================================================
 
 void StdMeshers_CartesianParameters3D::SetSizeThreshold(const double threshold)
-  throw ( SALOME_Exception )
+  
 {
   if ( threshold <= 1.0 )
     throw SALOME_Exception(LOCALIZED("threshold must be > 1.0"));
@@ -272,7 +272,7 @@ void StdMeshers_CartesianParameters3D::SetSizeThreshold(const double threshold)
 void StdMeshers_CartesianParameters3D::GetGridSpacing(std::vector<std::string>& spaceFunctions,
                                                       std::vector<double>&      internalPoints,
                                                       const int                 axis) const
-  throw ( SALOME_Exception )
+  
 {
   if ( !IsGridBySpacing(axis) )
     throw SALOME_Exception(LOCALIZED("The grid is defined by coordinates and not by spacing"));
@@ -286,7 +286,7 @@ void StdMeshers_CartesianParameters3D::GetGridSpacing(std::vector<std::string>&
 //=======================================================================
 
 bool StdMeshers_CartesianParameters3D::IsGridBySpacing(const int axis) const
-  throw ( SALOME_Exception )
+  
 {
   checkAxis(axis);
   return !_spaceFunctions[axis].empty();
@@ -305,7 +305,7 @@ void StdMeshers_CartesianParameters3D::ComputeCoordinates(const double    x0,
                                                           vector<double>& coords,
                                                           const string&   axis,
                                                           const double*   xForced )
-  throw ( SALOME_Exception )
+  
 {
   checkGridSpacing( theSpaceFuns, thePoints, axis );
 
@@ -404,7 +404,7 @@ void StdMeshers_CartesianParameters3D::GetCoordinates(std::vector<double>& xNode
                                                       std::vector<double>& yNodes,
                                                       std::vector<double>& zNodes,
                                                       const Bnd_Box&       bndBox) const
-  throw ( SALOME_Exception )
+  
 {
   double x0,y0,z0, x1,y1,z1;
   if ( IsGridBySpacing(0) || IsGridBySpacing(1) || IsGridBySpacing(2))
@@ -655,7 +655,7 @@ ComputeOptimalAxesDirs(const TopoDS_Shape& shape,
 //=======================================================================
 
 void StdMeshers_CartesianParameters3D::SetAxisDirs(const double* the9DirComps)
-  throw ( SALOME_Exception )
+  
 {
   gp_Vec x( the9DirComps[0],
             the9DirComps[1],
@@ -697,7 +697,7 @@ void StdMeshers_CartesianParameters3D::SetAxisDirs(const double* the9DirComps)
 //=======================================================================
 
 void StdMeshers_CartesianParameters3D::GetGrid(std::vector<double>& coords, int axis) const
-  throw ( SALOME_Exception )
+  
 {
   if ( IsGridBySpacing(axis) )
     throw SALOME_Exception(LOCALIZED("The grid is defined by spacing and not by coordinates"));

src/StdMeshers/StdMeshers_CartesianParameters3D.hxx

@@ -54,11 +54,11 @@ public:
   /*!
    * Sets coordinates of node positions along an axis (countered from 0)
    */
-  void SetGrid(std::vector<double>& xNodes, int axis) throw ( SALOME_Exception );
+  void SetGrid(std::vector<double>& xNodes, int axis) ;
   /*!
    * Return coordinates of node positions along the three axes
    */
-  void GetGrid(std::vector<double>& xNodes, int axis) const throw ( SALOME_Exception );
+  void GetGrid(std::vector<double>& xNodes, int axis) const ;
 
   /*!
    * \brief Set grid spacing along the three axes
@@ -70,13 +70,13 @@ public:
    */
   void SetGridSpacing(std::vector<std::string>& spaceFunctions,
                       std::vector<double>&      internalPoints,
-                      const int                 axis) throw ( SALOME_Exception );
+                      const int                 axis) ;
 
   void GetGridSpacing(std::vector<std::string>& spaceFunctions,
                       std::vector<double>&      internalPoints,
-                      const int                 axis) const throw ( SALOME_Exception );
+                      const int                 axis) const ;
 
-  bool IsGridBySpacing(const int axis) const throw ( SALOME_Exception );
+  bool IsGridBySpacing(const int axis) const ;
 
   /*!
    * Set/unset a fixed point, at which a node will be created provided that grid
@@ -99,7 +99,7 @@ public:
                                  std::vector<double>&      points,
                                  std::vector<double>&      coords,
                                  const std::string&        axis,
-                                 const double*             xForced=0) throw (SALOME_Exception);
+                                 const double*             xForced=0) ;
   /*!
    * Return coordinates of node positions along the three axes.
    * If the grid is defined by spacing functions, the coordinates are computed
@@ -107,12 +107,12 @@ public:
   void GetCoordinates(std::vector<double>& xNodes,
                       std::vector<double>& yNodes,
                       std::vector<double>& zNodes,
-                      const Bnd_Box&       bndBox) const throw ( SALOME_Exception );
+                      const Bnd_Box&       bndBox) const ;
 
   /*!
    * \brief Set custom direction of axes
    */
-  void SetAxisDirs(const double* the9DirComps) throw ( SALOME_Exception );
+  void SetAxisDirs(const double* the9DirComps) ;
   const double* GetAxisDirs() const { return _axisDirs; }
   /*!
    * \brief Returns axes at which number of hexahedra is maximal
@@ -125,7 +125,7 @@ public:
    * hexahedron by geometry boundary is considered small and is removed if
    * it's size is \athreshold times less than the size of the initial hexahedron.
    */
-  void SetSizeThreshold(const double threshold) throw ( SALOME_Exception );
+  void SetSizeThreshold(const double threshold) ;
   /*!
    * \brief Return size threshold
    */

src/StdMeshers/StdMeshers_Deflection1D.cxx

@@ -75,7 +75,6 @@ StdMeshers_Deflection1D::~StdMeshers_Deflection1D()
 //=============================================================================
 
 void StdMeshers_Deflection1D::SetDeflection(double value)
-     throw(SALOME_Exception)
 {
   if (_value != value) {
     if (value <= 0.)

src/StdMeshers/StdMeshers_Deflection1D.hxx

@@ -38,7 +38,7 @@ class STDMESHERS_EXPORT StdMeshers_Deflection1D:public SMESH_Hypothesis
   StdMeshers_Deflection1D(int hypId, SMESH_Gen * gen);
   virtual ~ StdMeshers_Deflection1D();
 
-  void SetDeflection(double value) throw(SALOME_Exception);
+  void SetDeflection(double value) ;
 
   double GetDeflection() const;
   

src/StdMeshers/StdMeshers_FixedPoints1D.cxx

@@ -61,7 +61,7 @@ StdMeshers_FixedPoints1D::~StdMeshers_FixedPoints1D()
 //=============================================================================
 
 void StdMeshers_FixedPoints1D::SetPoints(const std::vector<double>& listParams)
-  throw(SALOME_Exception)
+  
 {
   _params = listParams;
   NotifySubMeshesHypothesisModification();
@@ -74,7 +74,7 @@ void StdMeshers_FixedPoints1D::SetPoints(const std::vector<double>& listParams)
 //=============================================================================
 
 void StdMeshers_FixedPoints1D::SetNbSegments(const std::vector<int>& listNbSeg) 
-  throw(SALOME_Exception)
+  
 {
   _nbsegs = listNbSeg;
   NotifySubMeshesHypothesisModification();

src/StdMeshers/StdMeshers_FixedPoints1D.hxx

@@ -42,10 +42,10 @@ public:
   virtual ~StdMeshers_FixedPoints1D();
 
   void SetPoints(const std::vector<double>& listParams)
-    throw(SALOME_Exception);
+    ;
 
   void SetNbSegments(const std::vector<int>& listNbSeg) 
-    throw(SALOME_Exception);
+    ;
 
   const std::vector<double>& GetPoints() const { return _params; }
 

src/StdMeshers/StdMeshers_Geometric1D.cxx

@@ -57,7 +57,6 @@ StdMeshers_Geometric1D::StdMeshers_Geometric1D(int hypId, SMESH_Gen * gen)
 //=============================================================================
 
 void StdMeshers_Geometric1D::SetStartLength(double length)
-  throw(SALOME_Exception)
 {
   if ( _begLength != length )
   {
@@ -75,7 +74,6 @@ void StdMeshers_Geometric1D::SetStartLength(double length)
 //=============================================================================
 
 void StdMeshers_Geometric1D::SetCommonRatio(double factor)
-  throw(SALOME_Exception)
 {
   if ( _ratio != factor )
   {

src/StdMeshers/StdMeshers_Geometric1D.hxx

@@ -37,8 +37,8 @@ class STDMESHERS_EXPORT StdMeshers_Geometric1D: public StdMeshers_Reversible1D
 public:
   StdMeshers_Geometric1D(int hypId, SMESH_Gen* gen);
 
-  void SetStartLength(double length) throw(SALOME_Exception);
+  void SetStartLength(double length) ;
-  void SetCommonRatio(double factor) throw(SALOME_Exception);
+  void SetCommonRatio(double factor) ;
 
   double GetStartLength() const;
   double GetCommonRatio() const;

src/StdMeshers/StdMeshers_LayerDistribution.cxx

@@ -69,7 +69,6 @@ StdMeshers_LayerDistribution::~StdMeshers_LayerDistribution()
 //=============================================================================
 
 void StdMeshers_LayerDistribution::SetLayerDistribution(SMESH_Hypothesis* hyp1D)
-  throw ( SALOME_Exception )
 {
   if ( myHyp != hyp1D ) {
     if ( myHyp && hyp1D->GetDim() != 1 )

src/StdMeshers/StdMeshers_LayerDistribution.hxx

@@ -60,7 +60,7 @@ public:
     * \param hyp1D - 1D hypothesis
    */
   void SetLayerDistribution(SMESH_Hypothesis* hyp1D)
-    throw ( SALOME_Exception );
+    ;
 
   /*!
    * \brief Returns 1D hypothesis specifying distribution of layers

src/StdMeshers/StdMeshers_LengthFromEdges.cxx

@@ -63,7 +63,6 @@ StdMeshers_LengthFromEdges::~StdMeshers_LengthFromEdges()
 //=============================================================================
 
 void StdMeshers_LengthFromEdges::SetMode(int mode)
-  throw (SALOME_Exception)
 {
   int oldMode = _mode;
   if (mode <= 0) 

src/StdMeshers/StdMeshers_LengthFromEdges.hxx

@@ -41,8 +41,7 @@ public:
   StdMeshers_LengthFromEdges(int hypId, SMESH_Gen* gen);
   virtual ~StdMeshers_LengthFromEdges();
 
-  void SetMode(int mode)
+  void SetMode(int mode);
-    throw (SALOME_Exception);
 
   int GetMode();
 

src/StdMeshers/StdMeshers_LocalLength.cxx

@@ -77,7 +77,7 @@ StdMeshers_LocalLength::~StdMeshers_LocalLength()
  */
 //=============================================================================
 
-void StdMeshers_LocalLength::SetLength(double length) throw(SALOME_Exception)
+void StdMeshers_LocalLength::SetLength(double length) 
 {
   double oldLength = _length;
   if (length <= 0)
@@ -104,7 +104,7 @@ double StdMeshers_LocalLength::GetLength() const
  *  
  */
 //=============================================================================
-void StdMeshers_LocalLength::SetPrecision (double thePrecision) throw(SALOME_Exception)
+void StdMeshers_LocalLength::SetPrecision (double thePrecision) 
 {
   double oldPrecision = _precision;
   if (_precision < 0)

src/StdMeshers/StdMeshers_LocalLength.hxx

@@ -40,8 +40,8 @@ class STDMESHERS_EXPORT StdMeshers_LocalLength: public SMESH_Hypothesis
   StdMeshers_LocalLength(int hypId, SMESH_Gen * gen);
   virtual ~ StdMeshers_LocalLength();
 
-  void SetLength(double length) throw(SALOME_Exception);
+  void SetLength(double length) ;
-  void SetPrecision(double precision) throw(SALOME_Exception);
+  void SetPrecision(double precision) ;
 
   double GetLength() const;
   double GetPrecision() const;

src/StdMeshers/StdMeshers_MaxElementArea.cxx

@@ -73,7 +73,6 @@ StdMeshers_MaxElementArea::~StdMeshers_MaxElementArea()
 //=============================================================================
 
 void StdMeshers_MaxElementArea::SetMaxArea(double maxArea)
-  throw (SALOME_Exception)
 {
   double oldArea = _maxArea;
   if (maxArea <= 0) 

src/StdMeshers/StdMeshers_MaxElementArea.hxx

@@ -40,7 +40,7 @@ public:
   StdMeshers_MaxElementArea(int hypId, SMESH_Gen * gen);
   virtual ~ StdMeshers_MaxElementArea();
 
-  void SetMaxArea(double maxArea) throw(SALOME_Exception);
+  void SetMaxArea(double maxArea);
 
   double GetMaxArea() const;
 

src/StdMeshers/StdMeshers_MaxElementVolume.cxx

@@ -73,7 +73,6 @@ StdMeshers_MaxElementVolume::~StdMeshers_MaxElementVolume()
 //=============================================================================
 
 void StdMeshers_MaxElementVolume::SetMaxVolume(double maxVolume)
-  throw (SALOME_Exception)
 {
   double oldVolume = _maxVolume;
   if (maxVolume <= 0) 

src/StdMeshers/StdMeshers_MaxElementVolume.hxx

@@ -41,8 +41,7 @@ public:
   StdMeshers_MaxElementVolume(int hypId, SMESH_Gen* gen);
   virtual ~StdMeshers_MaxElementVolume();
 
-  void SetMaxVolume(double maxVolume)
+  void SetMaxVolume(double maxVolume);
-    throw (SALOME_Exception);
 
   double GetMaxVolume() const;
 

src/StdMeshers/StdMeshers_MaxLength.cxx

@@ -73,7 +73,7 @@ StdMeshers_MaxLength::~StdMeshers_MaxLength()
  */
 //=============================================================================
 
-void StdMeshers_MaxLength::SetLength(double length) throw(SALOME_Exception)
+void StdMeshers_MaxLength::SetLength(double length)
 {
   if (length <= 0)
     throw SALOME_Exception(LOCALIZED("length must be positive"));

src/StdMeshers/StdMeshers_MaxLength.hxx

@@ -35,7 +35,7 @@ class STDMESHERS_EXPORT StdMeshers_MaxLength: public SMESH_Hypothesis
   StdMeshers_MaxLength(int hypId, SMESH_Gen * gen);
   virtual ~ StdMeshers_MaxLength();
 
-  void SetLength(double length) throw(SALOME_Exception);
+  void SetLength(double length) ;
   double GetLength() const;
 
   bool HavePreestimatedLength() const  { return _preestimated > 0.; }

src/StdMeshers/StdMeshers_NumberOfLayers.cxx

@@ -72,7 +72,6 @@ StdMeshers_NumberOfLayers::~StdMeshers_NumberOfLayers()
 //=============================================================================
 
 void StdMeshers_NumberOfLayers::SetNumberOfLayers(int numberOfLayers)
-  throw ( SALOME_Exception )
 {
   if ( _nbLayers != numberOfLayers ) {
     if ( numberOfLayers <= 0 )

src/StdMeshers/StdMeshers_NumberOfLayers.hxx

@@ -54,7 +54,7 @@ public:
   virtual ~StdMeshers_NumberOfLayers();
 
   // Sets <number of segments> parameter value
-  void SetNumberOfLayers(int numberOfLayers) throw ( SALOME_Exception );
+  void SetNumberOfLayers(int numberOfLayers) ;
 
   // Returns <number of layers> parameter value
   int GetNumberOfLayers() const;

src/StdMeshers/StdMeshers_NumberOfSegments.cxx

@@ -87,7 +87,7 @@ StdMeshers_NumberOfSegments::~StdMeshers_NumberOfSegments()
 //=============================================================================
 const vector<double>&
 StdMeshers_NumberOfSegments::BuildDistributionExpr( const char* expr,int nbSeg,int conv )
-  throw ( SALOME_Exception )
+  
 {
   if( !buildDistribution( TCollection_AsciiString( ( Standard_CString )expr ), conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
     _distr.resize( 0 );
@@ -98,7 +98,7 @@ const vector<double>&
 StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab,
                                                    int nbSeg,
                                                    int conv )
-  throw ( SALOME_Exception )
+  
 {
   if( !buildDistribution( tab, conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
     _distr.resize( 0 );
@@ -112,7 +112,7 @@ StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab,
 //=============================================================================
 
 void StdMeshers_NumberOfSegments::SetNumberOfSegments(int segmentsNumber)
-throw(SALOME_Exception)
+
 {
   int oldNumberOfSegments = _numberOfSegments;
   if (segmentsNumber <= 0)
@@ -141,7 +141,7 @@ int StdMeshers_NumberOfSegments::GetNumberOfSegments() const
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetDistrType(DistrType typ)
-  throw(SALOME_Exception)
+  
 {
   if (typ < DT_Regular || typ > DT_ExprFunc)
     throw SALOME_Exception(LOCALIZED("distribution type is out of range"));
@@ -171,7 +171,7 @@ StdMeshers_NumberOfSegments::DistrType StdMeshers_NumberOfSegments::GetDistrType
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
-  throw(SALOME_Exception)
+  
 {
   if (scaleFactor < PRECISION)
     throw SALOME_Exception(LOCALIZED("scale factor must be positive"));
@@ -197,7 +197,7 @@ void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
 //================================================================================
 
 double StdMeshers_NumberOfSegments::GetScaleFactor() const
-  throw(SALOME_Exception)
+  
 {
   if (_distrType != DT_Scale)
     throw SALOME_Exception(LOCALIZED("not a scale distribution"));
@@ -211,7 +211,7 @@ double StdMeshers_NumberOfSegments::GetScaleFactor() const
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
-  throw(SALOME_Exception)
+  
 {
   if (_distrType != DT_TabFunc)
     _distrType = DT_TabFunc;
@@ -276,7 +276,7 @@ void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
 //================================================================================
 
 const vector<double>& StdMeshers_NumberOfSegments::GetTableFunction() const
-  throw(SALOME_Exception)
+  
 {
   if (_distrType != DT_TabFunc)
     throw SALOME_Exception(LOCALIZED("not a table function distribution"));
@@ -380,7 +380,7 @@ bool process( const TCollection_AsciiString& str, int convMode,
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
-  throw(SALOME_Exception)
+  
 {
   if (_distrType != DT_ExprFunc)
     _distrType = DT_ExprFunc;
@@ -402,7 +402,7 @@ void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
 std::string
 StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr,
                                                       const int          convMode)
-    throw (SALOME_Exception)
+    
 {
   // remove white spaces
   TCollection_AsciiString str((Standard_CString)expr.c_str());
@@ -442,7 +442,7 @@ StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr,
 //================================================================================
 
 const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
-  throw(SALOME_Exception)
+  
 {
   if (_distrType != DT_ExprFunc)
     throw SALOME_Exception(LOCALIZED("not an expression function distribution"));
@@ -456,7 +456,7 @@ const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
-  throw(SALOME_Exception)
+  
 {
 //   if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
 //     throw SALOME_Exception(LOCALIZED("not a functional distribution"));
@@ -475,7 +475,7 @@ void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
 //================================================================================
 
 int StdMeshers_NumberOfSegments::ConversionMode() const
-  throw(SALOME_Exception)
+  
 {
 //   if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
 //     throw SALOME_Exception(LOCALIZED("not a functional distribution"));

src/StdMeshers/StdMeshers_NumberOfSegments.hxx

@@ -48,15 +48,15 @@ public:
   virtual ~StdMeshers_NumberOfSegments();
 
   // Builds point distribution according to passed function
-  const std::vector<double>& BuildDistributionExpr( const char*, int, int ) throw ( SALOME_Exception );
+  const std::vector<double>& BuildDistributionExpr( const char*, int, int ) ;
-  const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int ) throw ( SALOME_Exception );
+  const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int ) ;
 
   /*!
    * \brief Set the number of segments
     * \param segmentsNumber - must be greater than zero
    */
   void SetNumberOfSegments(int segmentsNumber)
-    throw (SALOME_Exception);
+    ;
 
   /*!
    * \brief Get the number of segments
@@ -78,7 +78,7 @@ public:
    * \brief Set distribution type
    */
   void SetDistrType(DistrType typ)
-    throw (SALOME_Exception);
+    ;
 
   /*!
    * \brief Get distribution type
@@ -93,7 +93,7 @@ public:
    * or scaleFactor is not a positive value different from 1
    */
   virtual void SetScaleFactor(double scaleFactor)
-    throw (SALOME_Exception);
+    ;
 
   /*!
    * \brief Get scale factor for scale distribution
@@ -101,7 +101,7 @@ public:
    * Throws SALOME_Exception if distribution type is not DT_Scale
    */
   double GetScaleFactor() const
-    throw (SALOME_Exception);
+    ;
 
   /*!
    * \brief Set table function for distribution DT_TabFunc
@@ -113,7 +113,7 @@ public:
    * Throws SALOME_Exception if distribution type is not DT_TabFunc
    */
   void SetTableFunction(const std::vector<double>& table)
-    throw (SALOME_Exception);
+    ;
 
   /*!
    * \brief Get table function for distribution DT_TabFunc
@@ -121,7 +121,7 @@ public:
    * Throws SALOME_Exception if distribution type is not DT_TabFunc
    */
   const std::vector<double>& GetTableFunction() const
-    throw (SALOME_Exception);
+    ;
 
   /*!
    * \brief Set expression function for distribution DT_ExprFunc
@@ -131,7 +131,7 @@ public:
    * Throws SALOME_Exception if distribution type is not DT_ExprFunc
    */
   void SetExpressionFunction( const char* expr)
-    throw (SALOME_Exception);
+    ;
 
   /*!
    * \brief Get expression function for distribution DT_ExprFunc
@@ -139,7 +139,7 @@ public:
    * Throws SALOME_Exception if distribution type is not DT_ExprFunc
    */
   const char* GetExpressionFunction() const
-    throw (SALOME_Exception);
+    ;
 
   /*!
    * \brief Checks validity of  the expression of the function f(t), e.g. "sin(t)".
@@ -148,7 +148,7 @@ public:
    */
   static std::string CheckExpressionFunction( const std::string& expr,
                                               const int          convMode)
-    throw (SALOME_Exception);
+    ;
 
   /*!
    * \brief Set conversion mode. When it is 0, it means "exponent mode":
@@ -160,7 +160,7 @@ public:
    * Throws SALOME_Exception if distribution type is not functional
    */
   void SetConversionMode( int conv )
-    throw (SALOME_Exception);
+    ;
 
   /*!
    * \brief Returns conversion mode
@@ -168,7 +168,7 @@ public:
    * Throws SALOME_Exception if distribution type is not functional
    */
   int ConversionMode() const
-    throw (SALOME_Exception);
+    ;
 
   /*!
    * \brief Initialize number of segments by the mesh built on the geometry

src/StdMeshers/StdMeshers_ProjectionSource1D.cxx

@@ -72,7 +72,6 @@ StdMeshers_ProjectionSource1D::~StdMeshers_ProjectionSource1D()
 //=============================================================================
 
 void StdMeshers_ProjectionSource1D::SetSourceEdge(const TopoDS_Shape& edge)
-  throw ( SALOME_Exception )
 {
   if ( edge.IsNull() )
     throw SALOME_Exception(LOCALIZED("Null edge is not allowed"));
@@ -97,7 +96,6 @@ void StdMeshers_ProjectionSource1D::SetSourceEdge(const TopoDS_Shape& edge)
 
 void StdMeshers_ProjectionSource1D::SetVertexAssociation(const TopoDS_Shape& sourceVertex,
                                                          const TopoDS_Shape& targetVertex)
-  throw ( SALOME_Exception )
 {
   if ( sourceVertex.IsNull() != targetVertex.IsNull() )
     throw SALOME_Exception(LOCALIZED("Two or none vertices must be provided"));

src/StdMeshers/StdMeshers_ProjectionSource1D.hxx

@@ -57,7 +57,7 @@ public:
    * Sets source <edge> to take a mesh pattern from
    */
   void SetSourceEdge(const TopoDS_Shape& edge)
-    throw ( SALOME_Exception );
+    ;
 
   /*!
    * Returns the source edge or a group containing edges
@@ -86,7 +86,7 @@ public:
    */
   void SetVertexAssociation(const TopoDS_Shape& sourceVertex,
                             const TopoDS_Shape& targetVertex)
-    throw ( SALOME_Exception );
+    ;
 
   /*!
    * Returns the vertex associated with the target vertex.

src/StdMeshers/StdMeshers_ProjectionSource2D.cxx

@@ -73,7 +73,6 @@ StdMeshers_ProjectionSource2D::~StdMeshers_ProjectionSource2D()
 //=============================================================================
 
 void StdMeshers_ProjectionSource2D::SetSourceFace(const TopoDS_Shape& Face)
-  throw ( SALOME_Exception )
 {
   if ( Face.IsNull() )
     throw SALOME_Exception(LOCALIZED("Null Face is not allowed"));
@@ -101,7 +100,6 @@ void StdMeshers_ProjectionSource2D::SetVertexAssociation(const TopoDS_Shape& sou
                                                          const TopoDS_Shape& sourceVertex2,
                                                          const TopoDS_Shape& targetVertex1,
                                                          const TopoDS_Shape& targetVertex2) 
-  throw ( SALOME_Exception )
 {
   if ( sourceVertex1.IsNull() != targetVertex1.IsNull() ||
        sourceVertex2.IsNull() != targetVertex2.IsNull() )
@@ -173,7 +171,6 @@ TopoDS_Shape StdMeshers_ProjectionSource2D::GetSourceFace() const
 //=============================================================================
 
 TopoDS_Vertex StdMeshers_ProjectionSource2D::GetSourceVertex(int i) const
-  throw ( SALOME_Exception )
 {
   if ( i == 1 )
     return _sourceVertex1;
@@ -191,7 +188,6 @@ TopoDS_Vertex StdMeshers_ProjectionSource2D::GetSourceVertex(int i) const
 //=============================================================================
 
 TopoDS_Vertex StdMeshers_ProjectionSource2D::GetTargetVertex(int i) const
-  throw ( SALOME_Exception )
 {
   if ( i == 1 )
     return _targetVertex1;

src/StdMeshers/StdMeshers_ProjectionSource2D.hxx

@@ -57,7 +57,7 @@ public:
    * Sets a source <face> to take a mesh pattern from
    */
   void SetSourceFace(const TopoDS_Shape& face)
-    throw ( SALOME_Exception );
+    ;
 
   /*!
    * Returns the source face or a group containing faces
@@ -89,21 +89,21 @@ public:
                             const TopoDS_Shape& sourceVertex2,
                             const TopoDS_Shape& targetVertex1,
                             const TopoDS_Shape& targetVertex2)
-    throw ( SALOME_Exception );
+    ;
 
   /*!
    * Returns the <i>-th source vertex associated with the <i>-th target vertex.
    * Result may be nil if association not set.
    * Valid indices are 1 and 2
    */
-  TopoDS_Vertex GetSourceVertex(int i) const throw ( SALOME_Exception );
+  TopoDS_Vertex GetSourceVertex(int i) const ;
 
   /*!
    * Returns the <i>-th target vertex associated with the <i>-th source vertex.
    * Result may be nil if association not set.
    * Valid indices are 1 and 2
    */
-  TopoDS_Vertex GetTargetVertex(int i) const throw ( SALOME_Exception );
+  TopoDS_Vertex GetTargetVertex(int i) const ;
 
   /*!
    * \brief Test if vertex association defined

src/StdMeshers/StdMeshers_ProjectionSource3D.cxx

@@ -71,7 +71,6 @@ StdMeshers_ProjectionSource3D::~StdMeshers_ProjectionSource3D()
 //=============================================================================
 
 void StdMeshers_ProjectionSource3D::SetSource3DShape(const TopoDS_Shape& Shape)
-  throw ( SALOME_Exception )
 {
   if ( Shape.IsNull() )
     throw SALOME_Exception(LOCALIZED("Null Shape is not allowed"));
@@ -99,7 +98,6 @@ void StdMeshers_ProjectionSource3D::SetVertexAssociation(const TopoDS_Shape& sou
                                                          const TopoDS_Shape& sourceVertex2,
                                                          const TopoDS_Shape& targetVertex1,
                                                          const TopoDS_Shape& targetVertex2)
-  throw ( SALOME_Exception )
 {
   if ( sourceVertex1.IsNull() != targetVertex1.IsNull() ||
        sourceVertex2.IsNull() != targetVertex2.IsNull() ||
@@ -161,7 +159,6 @@ TopoDS_Shape StdMeshers_ProjectionSource3D::GetSource3DShape() const
 //=============================================================================
 
 TopoDS_Vertex StdMeshers_ProjectionSource3D::GetSourceVertex(int i) const
-  throw ( SALOME_Exception )
 {
   if ( i == 1 )
     return _sourceVertex1;
@@ -179,7 +176,6 @@ TopoDS_Vertex StdMeshers_ProjectionSource3D::GetSourceVertex(int i) const
 //=============================================================================
 
 TopoDS_Vertex StdMeshers_ProjectionSource3D::GetTargetVertex(int i) const
-  throw ( SALOME_Exception )
 {
   if ( i == 1 )
     return _targetVertex1;

src/StdMeshers/StdMeshers_ProjectionSource3D.hxx

@@ -57,7 +57,7 @@ public:
    * Sets a source <shape> to take a mesh pattern from
    */
   void SetSource3DShape(const TopoDS_Shape& shape)
-    throw ( SALOME_Exception );
+    ;
 
   /*!
    * Returns the source shape
@@ -83,19 +83,19 @@ public:
                             const TopoDS_Shape& sourceVertex2,
                             const TopoDS_Shape& targetVertex1,
                             const TopoDS_Shape& targetVertex2)
-    throw ( SALOME_Exception );
+    ;
 
   /*!
    * Returns the <i>-th source vertex associated with the <i>-th target vertex.
    * Result may be nil if association not set.
    */
-  TopoDS_Vertex GetSourceVertex(int i) const throw ( SALOME_Exception );
+  TopoDS_Vertex GetSourceVertex(int i) const ;
 
   /*!
    * Returns the <i>-th target vertex associated with the <i>-th source vertex.
    * Result may be nil if association not set.
    */
-  TopoDS_Vertex GetTargetVertex(int i) const throw ( SALOME_Exception );
+  TopoDS_Vertex GetTargetVertex(int i) const ;
 
   /*!
    * \brief Test if vertex association defined

src/StdMeshers/StdMeshers_SegmentLengthAroundVertex.cxx

@@ -75,7 +75,7 @@ StdMeshers_SegmentLengthAroundVertex::~StdMeshers_SegmentLengthAroundVertex()
  */
 //=============================================================================
 
-void StdMeshers_SegmentLengthAroundVertex::SetLength(double length) throw(SALOME_Exception)
+void StdMeshers_SegmentLengthAroundVertex::SetLength(double length)
 {
   if (length <= 0)
     throw SALOME_Exception(LOCALIZED("length must be positive"));

src/StdMeshers/StdMeshers_SegmentLengthAroundVertex.hxx

@@ -43,7 +43,7 @@ class STDMESHERS_EXPORT StdMeshers_SegmentLengthAroundVertex:public SMESH_Hypoth
   StdMeshers_SegmentLengthAroundVertex(int hypId, SMESH_Gen * gen);
   virtual ~ StdMeshers_SegmentLengthAroundVertex();
 
-  void SetLength(double length) throw(SALOME_Exception);
+  void SetLength(double length) ;
 
   double GetLength() const;
 

src/StdMeshers/StdMeshers_StartEndLength.cxx

@@ -73,7 +73,6 @@ StdMeshers_StartEndLength::~StdMeshers_StartEndLength()
 //=============================================================================
 
 void StdMeshers_StartEndLength::SetLength(double length, bool isStartLength)
-     throw(SALOME_Exception)
 {
   if ( (isStartLength ? _begLength : _endLength) != length ) {
     if (length <= 0)

src/StdMeshers/StdMeshers_StartEndLength.hxx

@@ -41,7 +41,7 @@ class STDMESHERS_EXPORT StdMeshers_StartEndLength: public StdMeshers_Reversible1
   StdMeshers_StartEndLength(int hypId, SMESH_Gen * gen);
   virtual ~ StdMeshers_StartEndLength();
 
-  void SetLength(double length, bool isStartLength) throw(SALOME_Exception);
+  void SetLength(double length, bool isStartLength) ;
 
   double GetLength(bool isStartLength) const;
 

src/StdMeshers_I/StdMeshers_Adaptive1D_i.cxx

@@ -62,7 +62,6 @@ StdMeshers_Adaptive1D_i::~StdMeshers_Adaptive1D_i()
 //=======================================================================
 
 void StdMeshers_Adaptive1D_i::SetMinSize( CORBA::Double minSegLen )
-  throw (SALOME::SALOME_Exception)
 {
   ASSERT( myBaseImpl );
   try {
@@ -93,7 +92,6 @@ CORBA::Double StdMeshers_Adaptive1D_i::GetMinSize()
 //=======================================================================
 
 void StdMeshers_Adaptive1D_i::SetMaxSize( CORBA::Double maxSegLen )
-  throw (SALOME::SALOME_Exception)
 {
   ASSERT( myBaseImpl );
   try {
@@ -124,7 +122,6 @@ CORBA::Double StdMeshers_Adaptive1D_i::GetMaxSize()
 //=======================================================================
 
 void StdMeshers_Adaptive1D_i::SetDeflection( CORBA::Double theValue )
-  throw ( SALOME::SALOME_Exception )
 {
   ASSERT( myBaseImpl );
   try {

src/StdMeshers_I/StdMeshers_Adaptive1D_i.hxx

@@ -53,20 +53,20 @@ class STDMESHERS_I_EXPORT StdMeshers_Adaptive1D_i:
   /*!
    * Sets minimal allowed segment length
    */
-  void SetMinSize( CORBA::Double minSegLen ) throw (SALOME::SALOME_Exception);
+  void SetMinSize( CORBA::Double minSegLen );
   CORBA::Double GetMinSize();
 
   /*!
    * Sets maximal allowed segment length
    */
-  void SetMaxSize( CORBA::Double maxSegLen ) throw (SALOME::SALOME_Exception);
+  void SetMaxSize( CORBA::Double maxSegLen );
   CORBA::Double GetMaxSize();
 
   /*!
    * Sets <deflection> parameter value, 
    * i.e. a maximal allowed distance between a segment and an edge.
    */
-  void SetDeflection( CORBA::Double theLength ) throw (SALOME::SALOME_Exception);
+  void SetDeflection( CORBA::Double theLength );
   CORBA::Double GetDeflection();
 
 

src/StdMeshers_I/StdMeshers_Arithmetic1D_i.cxx

@@ -77,7 +77,6 @@ StdMeshers_Arithmetic1D_i::~StdMeshers_Arithmetic1D_i()
 
 void StdMeshers_Arithmetic1D_i::SetLength(CORBA::Double theLength,
                                           CORBA::Boolean theIsStart )
-     throw ( SALOME::SALOME_Exception )
 {
   ASSERT( myBaseImpl );
   try {
@@ -101,7 +100,6 @@ void StdMeshers_Arithmetic1D_i::SetLength(CORBA::Double theLength,
 //=============================================================================
 
 void StdMeshers_Arithmetic1D_i::SetStartLength( CORBA::Double length)
-  throw (SALOME::SALOME_Exception)
 {
   SetLength( length, true );
 }
@@ -113,7 +111,6 @@ void StdMeshers_Arithmetic1D_i::SetStartLength( CORBA::Double length)
 //=============================================================================
 
 void StdMeshers_Arithmetic1D_i::SetEndLength( CORBA::Double length)
-  throw (SALOME::SALOME_Exception)
 {
   SetLength( length, false );
 }

src/StdMeshers_I/StdMeshers_Arithmetic1D_i.hxx

@@ -53,14 +53,13 @@ public:
 
   // Set length
   // * OBSOLETE *. Avoid such a way of interface design
-  void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart )
+  void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart );
-    throw ( SALOME::SALOME_Exception );
 
   // Sets <start segment length> parameter value
-  void SetStartLength( CORBA::Double length) throw (SALOME::SALOME_Exception);
+  void SetStartLength( CORBA::Double length);
 
   // Sets <end segment length> parameter value
-  void SetEndLength( CORBA::Double length) throw (SALOME::SALOME_Exception);
+  void SetEndLength( CORBA::Double length);
 
   // Get length
   CORBA::Double GetLength(CORBA::Boolean theIsStart);

src/StdMeshers_I/StdMeshers_AutomaticLength_i.cxx

@@ -76,7 +76,6 @@ StdMeshers_AutomaticLength_i::~StdMeshers_AutomaticLength_i()
 //=============================================================================
 
 void StdMeshers_AutomaticLength_i::SetFineness( CORBA::Double theFineness )
-     throw ( SALOME::SALOME_Exception )
 {
   ASSERT( myBaseImpl );
   try {

src/StdMeshers_I/StdMeshers_AutomaticLength_i.hxx

@@ -55,8 +55,7 @@ public:
   virtual ~StdMeshers_AutomaticLength_i();
 
   // Set Fineness
-  void SetFineness( CORBA::Double theFineness )
+  void SetFineness( CORBA::Double theFineness );
-    throw ( SALOME::SALOME_Exception );
 
   // Get Fineness
   CORBA::Double GetFineness();

src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.cxx

@@ -87,7 +87,7 @@ StdMeshers_CartesianParameters3D_i::~StdMeshers_CartesianParameters3D_i()
 
 void StdMeshers_CartesianParameters3D_i::SetGrid(const SMESH::double_array& coords,
                                                  CORBA::Short               axis)
-  throw (SALOME::SALOME_Exception)
+  
 {
   std::vector<double> coordVec;//, yCoords, zCoords;
   _array2vec( coords, coordVec, );
@@ -111,7 +111,7 @@ void StdMeshers_CartesianParameters3D_i::SetGrid(const SMESH::double_array& coor
 //=============================================================================
 
 SMESH::double_array* StdMeshers_CartesianParameters3D_i::GetGrid(CORBA::Short axis)
-  throw (SALOME::SALOME_Exception)
+  
 {
   std::vector<double> coordVec;
   ASSERT( myBaseImpl );
@@ -135,7 +135,7 @@ SMESH::double_array* StdMeshers_CartesianParameters3D_i::GetGrid(CORBA::Short ax
 //=============================================================================
 
 void StdMeshers_CartesianParameters3D_i::SetSizeThreshold(CORBA::Double threshold)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT( myBaseImpl );
   try {
@@ -172,7 +172,7 @@ CORBA::Double StdMeshers_CartesianParameters3D_i::GetSizeThreshold()
 void StdMeshers_CartesianParameters3D_i::SetGridSpacing(const SMESH::string_array& spaceFunctions,
                                                         const SMESH::double_array& internalPoints,
                                                         CORBA::Short               axis)
-  throw (SALOME::SALOME_Exception)
+  
 {
   std::vector<std::string> funVec;
   std::vector<double>      pointVec;
@@ -201,7 +201,7 @@ void StdMeshers_CartesianParameters3D_i::SetGridSpacing(const SMESH::string_arra
 void StdMeshers_CartesianParameters3D_i::GetGridSpacing(SMESH::string_array_out xSpaceFunctions,
                                                         SMESH::double_array_out xInternalPoints,
                                                         CORBA::Short            axis)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT( myBaseImpl );
   try {
@@ -228,7 +228,7 @@ void StdMeshers_CartesianParameters3D_i::GetGridSpacing(SMESH::string_array_out
 void StdMeshers_CartesianParameters3D_i::SetAxesDirs(const SMESH::DirStruct& xDir,
                                                      const SMESH::DirStruct& yDir,
                                                      const SMESH::DirStruct& zDir)
-  throw (SALOME::SALOME_Exception)
+  
 {
   double coords[9];
   coords[0] = xDir.PS.x;
@@ -440,7 +440,7 @@ ComputeOptimalAxesDirs(GEOM::GEOM_Object_ptr go,
                        SMESH::DirStruct&     xDir,
                        SMESH::DirStruct&     yDir,
                        SMESH::DirStruct&     zDir)
-  throw (SALOME::SALOME_Exception)
+  
 {
   TopoDS_Shape shape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( go );
   if ( shape.IsNull() )
@@ -471,7 +471,7 @@ StdMeshers_CartesianParameters3D_i::ComputeCoordinates(CORBA::Double
                                                        const SMESH::string_array& spaceFuns,
                                                        const SMESH::double_array& points,
                                                        const char*                axisName )
-  throw (SALOME::SALOME_Exception)
+  
 {
   std::vector<std::string> xFuns;
   std::vector<double>      xPoints, coords;

src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.hxx

@@ -56,15 +56,15 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
    * it's size is \athreshold times less than the size of the initial hexahedron. 
    * threshold must be > 1.0
    */
-  void SetSizeThreshold(CORBA::Double threshold) throw (SALOME::SALOME_Exception);
+  void SetSizeThreshold(CORBA::Double threshold) ;
   CORBA::Double GetSizeThreshold();
 
   /*!
    * \brief Set node coordinates along an axis (counterd from zero)
    */
   void SetGrid(const SMESH::double_array& coords,
-               CORBA::Short               axis) throw (SALOME::SALOME_Exception);
+               CORBA::Short               axis) ;
-  SMESH::double_array* GetGrid(CORBA::Short axis) throw (SALOME::SALOME_Exception);
+  SMESH::double_array* GetGrid(CORBA::Short axis) ;
 
   /*!
    * \brief Set grid spacing along an axis
@@ -77,17 +77,17 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
    */
   void SetGridSpacing(const SMESH::string_array& spaceFunctions,
                       const SMESH::double_array& internalPoints,
-                      CORBA::Short               axis) throw (SALOME::SALOME_Exception);
+                      CORBA::Short               axis) ;
 
   void GetGridSpacing(SMESH::string_array_out xSpaceFunctions,
                       SMESH::double_array_out xInternalPoints,
-                      CORBA::Short            axis) throw (SALOME::SALOME_Exception);
+                      CORBA::Short            axis) ;
   /*!
    * Set custom direction of axes
    */
   void SetAxesDirs(const SMESH::DirStruct& x,
                    const SMESH::DirStruct& y,
-                   const SMESH::DirStruct& z) throw (SALOME::SALOME_Exception);
+                   const SMESH::DirStruct& z) ;
   void GetAxesDirs(SMESH::DirStruct& x,
                    SMESH::DirStruct& y,
                    SMESH::DirStruct& z);
@@ -139,7 +139,7 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
                               CORBA::Boolean        isOrthogonal,
                               SMESH::DirStruct&     x,
                               SMESH::DirStruct&     y,
-                              SMESH::DirStruct&     z) throw (SALOME::SALOME_Exception);
+                              SMESH::DirStruct&     z) ;
   /*!
    * \brief Compute node coordinates by spacing functions
    *  \param x0 - lower coordinate
@@ -153,7 +153,7 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
                                           const SMESH::string_array& spaceFuns,
                                           const SMESH::double_array& points,
                                           const char*                axisName )
-    throw (SALOME::SALOME_Exception);
+    ;
 
   // Get implementation
   ::StdMeshers_CartesianParameters3D* GetImpl();

src/StdMeshers_I/StdMeshers_Deflection1D_i.cxx

@@ -76,7 +76,6 @@ StdMeshers_Deflection1D_i::~StdMeshers_Deflection1D_i()
 //=============================================================================
 
 void StdMeshers_Deflection1D_i::SetDeflection( CORBA::Double theValue )
-     throw ( SALOME::SALOME_Exception )
 {
   ASSERT( myBaseImpl );
   try {

src/StdMeshers_I/StdMeshers_Deflection1D_i.hxx

@@ -55,7 +55,7 @@ public:
 
   // Set deflection
   void SetDeflection( CORBA::Double theLength )
-    throw ( SALOME::SALOME_Exception );
+    ;
   // Get deflection
   CORBA::Double GetDeflection();
 

src/StdMeshers_I/StdMeshers_FixedPoints1D_i.cxx

@@ -72,7 +72,7 @@ StdMeshers_FixedPoints1D_i::~StdMeshers_FixedPoints1D_i()
 //=============================================================================
 
 void StdMeshers_FixedPoints1D_i::SetNbSegments(const SMESH::long_array& listNbSeg) 
-     throw ( SALOME::SALOME_Exception )
+     
 {
   ASSERT( myBaseImpl );
   try {
@@ -98,7 +98,7 @@ void StdMeshers_FixedPoints1D_i::SetNbSegments(const SMESH::long_array& listNbSe
 //=============================================================================
 
 void StdMeshers_FixedPoints1D_i::SetPoints(const SMESH::double_array& listParams) 
-     throw ( SALOME::SALOME_Exception )
+     
 {
   ASSERT( myBaseImpl );
   try {

src/StdMeshers_I/StdMeshers_FixedPoints1D_i.hxx

@@ -53,9 +53,9 @@ public:
   // create list of reversed edges if it is needed) and sets numbers
   // of segments between given points (default values are equals 1)
   void SetPoints(const SMESH::double_array& listParams) 
-    throw ( SALOME::SALOME_Exception );
+    ;
   void SetNbSegments(const SMESH::long_array& listNbSeg) 
-    throw ( SALOME::SALOME_Exception );
+    ;
 
   // Returns list of point's parameters
   SMESH::double_array* GetPoints();

src/StdMeshers_I/StdMeshers_Geometric1D_i.cxx

@@ -57,7 +57,6 @@ StdMeshers_Geometric1D_i::StdMeshers_Geometric1D_i( PortableServer::POA_ptr theP
 //=============================================================================
 
 void StdMeshers_Geometric1D_i::SetStartLength( CORBA::Double theLength )
-  throw (SALOME::SALOME_Exception)
 {
   try {
     this->GetImpl()->SetStartLength( theLength );
@@ -77,7 +76,6 @@ void StdMeshers_Geometric1D_i::SetStartLength( CORBA::Double theLength )
 //=============================================================================
 
 void StdMeshers_Geometric1D_i::SetCommonRatio( CORBA::Double factor )
-  throw (SALOME::SALOME_Exception)
 {
   try {
     this->GetImpl()->SetCommonRatio( factor );

src/StdMeshers_I/StdMeshers_Geometric1D_i.hxx

@@ -49,8 +49,8 @@ class STDMESHERS_I_EXPORT StdMeshers_Geometric1D_i:
   StdMeshers_Geometric1D_i( PortableServer::POA_ptr thePOA,
                             ::SMESH_Gen*            theGenImpl );
 
-  void SetStartLength(CORBA::Double length) throw(SALOME::SALOME_Exception);
+  void SetStartLength(CORBA::Double length) ;
-  void SetCommonRatio(CORBA::Double factor) throw(SALOME::SALOME_Exception);
+  void SetCommonRatio(CORBA::Double factor) ;
 
   CORBA::Double GetStartLength();
   CORBA::Double GetCommonRatio();

src/StdMeshers_I/StdMeshers_LayerDistribution_i.cxx

@@ -76,7 +76,6 @@ StdMeshers_LayerDistribution_i::~StdMeshers_LayerDistribution_i()
 //=============================================================================
 
 void StdMeshers_LayerDistribution_i::SetLayerDistribution(SMESH::SMESH_Hypothesis_ptr hyp1D)
-  throw ( SALOME::SALOME_Exception )
 {
   ASSERT( myBaseImpl );
   try {

src/StdMeshers_I/StdMeshers_LayerDistribution_i.hxx

@@ -58,8 +58,7 @@ public:
    * \brief Sets  1D hypothesis specifying distribution of layers
     * \param hyp1D - 1D hypothesis
    */
-  void SetLayerDistribution(SMESH::SMESH_Hypothesis_ptr hyp1D)
+  void SetLayerDistribution(SMESH::SMESH_Hypothesis_ptr hyp1D);
-    throw ( SALOME::SALOME_Exception );
 
   /*!
    * \brief Returns 1D hypothesis specifying distribution of layers

src/StdMeshers_I/StdMeshers_LengthFromEdges_i.cxx

@@ -73,7 +73,6 @@ StdMeshers_LengthFromEdges_i::~StdMeshers_LengthFromEdges_i()
 //=============================================================================
 
 void StdMeshers_LengthFromEdges_i::SetMode( CORBA::Long theMode )
-  throw (SALOME::SALOME_Exception)
 {
   ASSERT( myBaseImpl );
   try {

src/StdMeshers_I/StdMeshers_LengthFromEdges_i.hxx

@@ -53,8 +53,7 @@ public:
   virtual ~StdMeshers_LengthFromEdges_i();
 
   // Set mode
-  void SetMode( CORBA::Long theMode )
+  void SetMode( CORBA::Long theMode );
-    throw ( SALOME::SALOME_Exception );
   // Get mode
   CORBA::Long GetMode();