0024058: Eliminate compiler warning C4702 in MSVC++ with warning level 4
authoromy <omy@opencascade.com>
Fri, 12 Jul 2013 08:54:01 +0000 (12:54 +0400)
committeromy <omy@opencascade.com>
Fri, 12 Jul 2013 08:54:01 +0000 (12:54 +0400)
Got rid of most of warnings of C4702 type: unreachable code.
Returned some #ifdef DEB
Fixed tabs formatting
Fixed some mistakes in code

59 files changed:
src/AIS/AIS_Selection.cxx
src/APIHeaderSection/APIHeaderSection_EditHeader.cxx
src/Adaptor3d/Adaptor3d_IsoCurve.cxx
src/Adaptor3d/Adaptor3d_SurfaceOfLinearExtrusion.cxx
src/BOPTest/BOPTest_BOPCommands.cxx
src/BOPTools/BOPTools_AlgoTools_1.cxx
src/BRepAlgo/BRepAlgo_FaceRestrictor.cxx
src/BRepFill/BRepFill_Pipe.cxx
src/BRepGProp/BRepGProp_EdgeTool.cxx
src/BRepTest/BRepTest_CurveCommands.cxx
src/BRepTools/BRepTools_NurbsConvertModification.cxx
src/ChFi2d/ChFi2d_Builder_0.cxx
src/ChFi3d/ChFi3d_Builder_CnCrn.cxx
src/ChFi3d/ChFi3d_Builder_SpKP.cxx
src/DDataStd/DDataStd_DrawDriver.cxx
src/DPrsStd/DPrsStd_AISPresentationCommands.cxx
src/Draw/Draw_BasicCommands.cxx
src/Draw/Draw_Window.cxx
src/GCPnts/GCPnts_QuasiUniformDeflection.gxx
src/GCPnts/GCPnts_UniformDeflection.gxx
src/Geom2dGcc/Geom2dGcc_Circ2d2TanOn.cxx
src/Geom2dGcc/Geom2dGcc_Circ2d2TanRad.cxx
src/GeomFill/GeomFill.cxx
src/GeometryTest/GeometryTest_ConstraintCommands.cxx
src/IntPatch/IntPatch_LineConstructor.cxx
src/IntPatch/IntPatch_Polyhedron.cxx
src/IntSurf/IntSurf_Quadric.cxx
src/IntTools/IntTools_EdgeFace.cxx
src/MAT2d/MAT2d_Circuit.cxx
src/MNaming/MNaming_NamingRetrievalDriver.cxx
src/MNaming/MNaming_NamingRetrievalDriver_1.cxx
src/MeshVS/MeshVS_MeshOwner.cxx
src/OpenGl/OpenGl_GraphicDriver_7.cxx
src/ProjLib/ProjLib_ComputeApproxOnPolarSurface.cxx
src/QABugs/QABugs_10.cxx
src/QABugs/QABugs_4.cxx
src/QANewBRepNaming/QANewBRepNaming_BooleanOperationFeat.cxx
src/QANewBRepNaming/QANewBRepNaming_Gluing.cxx
src/QANewModTopOpe/QANewModTopOpe_Glue_wire.cxx
src/ShapeAnalysis/ShapeAnalysis.cxx
src/ShapeBuild/ShapeBuild_Edge.cxx
src/ShapeConstruct/ShapeConstruct_ProjectCurveOnSurface.cxx
src/ShapeCustom/ShapeCustom_BSplineRestriction.cxx
src/ShapeFix/ShapeFix_EdgeProjAux.cxx
src/ShapeFix/ShapeFix_Wireframe.cxx
src/TNaming/TNaming.cxx
src/TNaming/TNaming_Localizer.cxx
src/TNaming/TNaming_Name.cxx
src/TopOpeBRep/TopOpeBRep_FFDumper.cxx
src/TopOpeBRep/TopOpeBRep_sort.cxx
src/TopOpeBRep/TopOpeBRep_traceBOOPNINT.cxx
src/TopOpeBRepBuild/TopOpeBRepBuild_Builder1.cxx
src/TopOpeBRepBuild/TopOpeBRepBuild_GTopo.cxx
src/TopOpeBRepBuild/TopOpeBRepBuild_Tools_1.cxx
src/TopOpeBRepDS/TopOpeBRepDS.cxx
src/TopOpeBRepDS/TopOpeBRepDS_BuildTool.cxx
src/TopOpeBRepDS/TopOpeBRepDS_PointIterator.cxx
src/TopOpeBRepTool/TopOpeBRepTool_makeTransition.cxx
src/XSControl/XSControl_Functions.cxx

index 9e76206..69ccd6b 100755 (executable)
@@ -283,9 +283,7 @@ AIS_SelectStatus AIS_Selection::Select(const Handle(Standard_Transient)& anObjec
   S->myresult.Append( anObject, aListIter );
   S->myResultMap.Bind( anObject, aListIter );
   return AIS_SS_Added;
-#endif //USE_MAP
-  return AIS_SS_Removed;
-  
+#endif //USE_MAP  
 }
 
 //=======================================================================
index 945b62d..208e675 100755 (executable)
@@ -38,19 +38,16 @@ static Standard_Boolean IsTimeStamp
     case  4 : if (uncar < '0' || uncar > '9') return Standard_False; break;
     case  5 : if (uncar != '-') return Standard_False;
     case  6 : if (uncar != '0' && uncar != '1') return Standard_False;  break;
-    case  7 : if (uncar < '0' || uncar > '9') return Standard_False; break;
-      if (dizmois == '1' && (uncar < '0' || uncar > '2')) return Standard_False;
-      break;
+    case  7 : if (uncar < '0' || uncar > '9') return Standard_False; 
+      if (dizmois == '1' && (uncar < '0' || uncar > '2')) return Standard_False; break;
     case  8 : if (uncar != '-') return Standard_False;
     case  9 : if (uncar < '0' || uncar > '3') return Standard_False; break;
     case 10 : if (uncar < '0' || uncar > '9') return Standard_False;
-      if (dizjour == '3' && (uncar != '0' && uncar != '1')) return Standard_False;
-      break;
+      if (dizjour == '3' && (uncar != '0' && uncar != '1')) return Standard_False; break;
     case 11 : if (uncar != 'T') return Standard_False;
     case 12 : if (uncar < '0' || uncar > '2') return Standard_False; break;
     case 13 : if (uncar < '0' || uncar > '9') return Standard_False;
       if (dizheur == '2' && (uncar < '0' || uncar > '3')) return Standard_False; break;
-      break;
     case 14 : if (uncar != ':') return Standard_False;
     case 15 : if (uncar < '0' || uncar > '5') return Standard_False; break;
     case 16 : if (uncar < '0' || uncar > '9') return Standard_False; break;
index d2df8c3..9efdada 100755 (executable)
@@ -805,11 +805,8 @@ gp_Elips Adaptor3d_IsoCurve::Ellipse() const
   default:  
     {
       Standard_NoSuchObject::Raise("Adaptor3d_IsoCurve:Ellipse");
-    }
-    
+    } 
   }
-  // portage WNT
-  return gp_Elips();
 }
 
 //=======================================================================
index 9855ab5..0a48486 100755 (executable)
@@ -193,9 +193,8 @@ Handle(Adaptor3d_HSurface)  Adaptor3d_SurfaceOfLinearExtrusion::VTrim
  const Standard_Real Tol) const 
 {
   Handle(Adaptor3d_HCurve) newBasisCurve =
-  myBasisCurve->Trim(First,
-                    Last,
-                    Tol) ;
+  myBasisCurve->Trim(First, Last, Tol);
+  
   Adaptor3d_SurfaceOfLinearExtrusion * SurfacePtr =
   new  Adaptor3d_SurfaceOfLinearExtrusion(newBasisCurve, myDirection) ;
 
@@ -288,7 +287,7 @@ Standard_Real Adaptor3d_SurfaceOfLinearExtrusion::VPeriod() const
 //=======================================================================
 
 gp_Pnt Adaptor3d_SurfaceOfLinearExtrusion::Value(const Standard_Real U, 
-                                              const Standard_Real V)
+                                                 const Standard_Real V)
      const 
 {
   gp_Pnt P;
@@ -303,8 +302,8 @@ gp_Pnt Adaptor3d_SurfaceOfLinearExtrusion::Value(const Standard_Real U,
 //=======================================================================
 
 void Adaptor3d_SurfaceOfLinearExtrusion::D0(const Standard_Real U,
-                                         const Standard_Real V, 
-                                         gp_Pnt&             P) const 
+                                            const Standard_Real V, 
+                                            gp_Pnt&             P) const 
 {
   myBasisCurve->D0(U,P);
   P.Translate( V * gp_Vec(myDirection));
@@ -316,10 +315,10 @@ void Adaptor3d_SurfaceOfLinearExtrusion::D0(const Standard_Real U,
 //=======================================================================
 
 void Adaptor3d_SurfaceOfLinearExtrusion::D1(const Standard_Real U, 
-                                         const Standard_Real V, 
-                                               gp_Pnt& P, 
-                                               gp_Vec& D1U, 
-                                               gp_Vec& D1V) const 
+                                            const Standard_Real V, 
+                                                  gp_Pnt& P, 
+                                                  gp_Vec& D1U, 
+                                                  gp_Vec& D1V) const 
 {
   myBasisCurve->D1(U,P,D1U);
   D0(U,V,P);
@@ -332,13 +331,13 @@ void Adaptor3d_SurfaceOfLinearExtrusion::D1(const Standard_Real U,
 //=======================================================================
 
 void Adaptor3d_SurfaceOfLinearExtrusion::D2(const Standard_Real U, 
-                                         const Standard_Real V,
-                                          gp_Pnt& P, 
-                                         gp_Vec& D1U, gp_Vec& D1V,
-                                          gp_Vec& D2U, gp_Vec& D2V, 
-                                         gp_Vec& D2UV) const 
+                                            const Standard_Real V,
+                                            gp_Pnt& P, 
+                                            gp_Vec& D1U, gp_Vec& D1V,
+                                            gp_Vec& D2U, gp_Vec& D2V, 
+                                            gp_Vec& D2UV) const 
 {
-  myBasisCurve->D2(U,P,D1U,D2U);       
+  myBasisCurve->D2(U,P,D1U,D2U);
   D1V = gp_Vec(myDirection);
   D2V.SetCoord( 0., 0., 0.);
   D2UV.SetCoord( 0., 0., 0.);
@@ -351,13 +350,13 @@ void Adaptor3d_SurfaceOfLinearExtrusion::D2(const Standard_Real U,
 //=======================================================================
 
 void Adaptor3d_SurfaceOfLinearExtrusion::D3(const Standard_Real U, 
-                                         const Standard_Real V,
-                                          gp_Pnt& P,
-                                         gp_Vec& D1U, gp_Vec& D1V,
-                                          gp_Vec& D2U, gp_Vec& D2V, 
-                                         gp_Vec& D2UV,
-                                          gp_Vec& D3U, gp_Vec& D3V, 
-                                         gp_Vec& D3UUV, gp_Vec& D3UVV) const 
+                                            const Standard_Real V,
+                                            gp_Pnt& P,
+                                            gp_Vec& D1U, gp_Vec& D1V,
+                                            gp_Vec& D2U, gp_Vec& D2V, 
+                                            gp_Vec& D2UV,
+                                            gp_Vec& D3U, gp_Vec& D3V, 
+                                            gp_Vec& D3UUV, gp_Vec& D3UVV) const 
 {
   myBasisCurve->D3(U,P,D1U,D2U,D3U);
   D1V = gp_Vec(myDirection);
@@ -427,10 +426,10 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
     {
       gp_Dir D = myBasisCurve->Line().Direction();
       if (myDirection.IsParallel( D, Precision::Angular())) {
-       return GeomAbs_SurfaceOfExtrusion;
+        return GeomAbs_SurfaceOfExtrusion;
       }
       else {
-       return GeomAbs_Plane;
+        return GeomAbs_Plane;
       }
       break;
     }
@@ -439,14 +438,14 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
     {
       gp_Dir D = (myBasisCurve->Circle()).Axis().Direction();
       if ( myDirection.IsParallel( D, Precision::Angular())) {
-       return GeomAbs_Cylinder;
+        return GeomAbs_Cylinder;
       }
       // JAG 10.11.95
       else if (myDirection.IsNormal(D, Precision::Angular())) {
-       return GeomAbs_Plane;
+        return GeomAbs_Plane;
       }
       else {
-       return GeomAbs_SurfaceOfExtrusion;
+        return GeomAbs_SurfaceOfExtrusion;
       }
       break;
     }
@@ -456,10 +455,10 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
     {
       gp_Dir D = (myBasisCurve->Ellipse()).Axis().Direction();
       if (myDirection.IsNormal(D, Precision::Angular())) {
-       return GeomAbs_Plane;
+        return GeomAbs_Plane;
       }
       else {
-       return GeomAbs_SurfaceOfExtrusion;
+        return GeomAbs_SurfaceOfExtrusion;
       }
       break;
     }
@@ -468,10 +467,10 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
     {
       gp_Dir D = (myBasisCurve->Parabola()).Axis().Direction();
       if (myDirection.IsNormal(D, Precision::Angular())) {
-       return GeomAbs_Plane;
+        return GeomAbs_Plane;
       }
       else {
-       return GeomAbs_SurfaceOfExtrusion;
+        return GeomAbs_SurfaceOfExtrusion;
       }
       break;
     }
@@ -480,10 +479,10 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
     {
       gp_Dir D = (myBasisCurve->Hyperbola()).Axis().Direction();
       if (myDirection.IsNormal(D, Precision::Angular())) {
-       return GeomAbs_Plane;
+        return GeomAbs_Plane;
       }
       else {
-       return GeomAbs_SurfaceOfExtrusion;
+        return GeomAbs_SurfaceOfExtrusion;
       }
       break;
     }
@@ -502,7 +501,7 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
 gp_Pln Adaptor3d_SurfaceOfLinearExtrusion::Plane() const 
 { 
   Standard_NoSuchObject_Raise_if (GetType() != GeomAbs_Plane,
-                                 "Adaptor3d_SurfaceOfLinearExtrusion::Plane");
+                  "Adaptor3d_SurfaceOfLinearExtrusion::Plane");
 /*
   gp_Pnt P;
   gp_Vec Ox, Oy;
index b156207..54f8194 100755 (executable)
@@ -416,7 +416,6 @@ Standard_Integer  bsection(Draw_Interpretor& di,
     di << usage;
     return 1;
   }
-  return 0;
 }
 //=======================================================================
 //function : bsmt
index 6a04aa1..4d99c15 100644 (file)
@@ -169,7 +169,6 @@ void CorrectWires(const TopoDS_Face& aFx)
   GeomAbs_SurfaceType aType;
   //
   const Handle(Geom_Surface)& aS=BRep_Tool::Surface(aFx);
-  //BRepAdaptor_Surface aBAS (aFx, Standard_False);
   GeomAdaptor_Surface aGAS (aS);
   aType=aGAS.GetType();
   if (aType!=GeomAbs_Cylinder) {
@@ -205,7 +204,6 @@ void CorrectWires(const TopoDS_Face& aFx)
       aT=BRep_Tool::Parameter(aV, aE);
       const Handle(Geom2d_Curve)& aC2D=BRep_Tool::CurveOnSurface(aE, aF, aT1, aT2);
       aC2D->D0(aT, aP2D);
-      //aP=aBAS.Value(aP2D.X(), aP2D.Y());
       aS->D0(aP2D.X(), aP2D.Y(), aP);
       aD2=aPV.SquareDistance(aP);
       if (aD2>aD2max) {
@@ -325,7 +323,6 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
     Standard_Boolean SameRange = TE->SameRange();
     Standard_Real First = myHCurve->FirstParameter();
     Standard_Real Last  = myHCurve->LastParameter();
-    //Standard_Real Delta =1.e-14;
     Standard_Real Delta =1.e-12;
 
     Handle(BRep_TFace)& TF = *((Handle(BRep_TFace)*) &S.TShape());
@@ -333,7 +330,6 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
     const TopLoc_Location& TFloc = TF->Location();
     const Handle(Geom_Surface)& Su = TF->Surface();
     TopLoc_Location L = (Floc * TFloc).Predivided(myShape.Location());
-    //      Standard_Boolean checkclosed = Standard_False;
     Standard_Boolean pcurvefound = Standard_False;
 
     BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
@@ -345,10 +341,7 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
         Standard_Real f,l;
         GC->Range(f,l);
         if (SameRange && (f != First || l != Last)) {
-          return ;//BRepCheck_InvalidSameRangeFlag);
-          if (SameParameter) {
-            return; //BRepCheck_InvalidSameParameterFlag);
-          }
+          return ;//BRepCheck_InvalidSameRangeFlag;
         }
        
         Handle(Geom_Surface) Sb = cr->Surface();
index 099c329..4b664b3 100755 (executable)
@@ -54,8 +54,8 @@ BRepAlgo_FaceRestrictor::BRepAlgo_FaceRestrictor()
 //=======================================================================
 
 void BRepAlgo_FaceRestrictor::Init(const TopoDS_Face&     F,
-                                  const Standard_Boolean Proj,
-                                  const Standard_Boolean CorrectionOrientation)
+                                   const Standard_Boolean Proj,
+                                   const Standard_Boolean CorrectionOrientation)
 {
   myFace = F; modeProj = Proj;  myCorrection = CorrectionOrientation;
 }
@@ -89,8 +89,8 @@ void BRepAlgo_FaceRestrictor::Clear()
 //=======================================================================
 
 static Standard_Boolean  ChangePCurve (TopoDS_Edge&          E,
-                                      const Handle(Geom_Surface)& S,
-                                      TopLoc_Location&      L)
+                                       const Handle(Geom_Surface)& S,
+                                       TopLoc_Location&      L)
 {
   BRep_Builder         BB;
   Handle(Geom_Surface) SE;
@@ -110,8 +110,8 @@ static Standard_Boolean  ChangePCurve (TopoDS_Edge&          E,
 //=======================================================================
 
 static void ProjCurve3d (TopoDS_Edge&          E,
-                        const Handle(Geom_Surface)& S,
-                        TopLoc_Location&      L)
+                         const Handle(Geom_Surface)& S,
+                         TopLoc_Location&      L)
 {
   BRep_Builder              BB;
   TopLoc_Location           LE;
@@ -124,7 +124,7 @@ static void ProjCurve3d (TopoDS_Edge&          E,
   
   Handle(Geom2d_Curve) C2 = GeomProjLib::Curve2d (CT,S);
   BB.UpdateEdge(E,C2,S,L,Precision::Confusion());
-}        
+}
 
 //=======================================================================
 //function : Perform
@@ -168,19 +168,18 @@ void BRepAlgo_FaceRestrictor::Perform()
       Handle(Geom2d_Curve) C2 = BRep_Tool::CurveOnSurface(E,S,L,f,l);
       
       if (C2.IsNull()) {
-       // no pcurve on the reference surface.
-       if (modeProj) {
-         // Projection of the 3D curve on surface.
-         ProjCurve3d ( E, S, L);
-       }
-       else {
-         // return the first pcurve glued on <S>
-         Standard_Boolean YaPCurve = ChangePCurve (E, S, L);
-         if (!YaPCurve) {
-           ProjCurve3d (E, S, L);
-         }
-
-       }
+        // no pcurve on the reference surface.
+        if (modeProj) {
+          // Projection of the 3D curve on surface.
+          ProjCurve3d ( E, S, L);
+        }
+        else {
+          // return the first pcurve glued on <S>
+          Standard_Boolean YaPCurve = ChangePCurve (E, S, L);
+          if (!YaPCurve) {
+            ProjCurve3d (E, S, L);
+          }
+        }
       }
     }
     WTF.AddWire(W);
@@ -256,11 +255,9 @@ static Standard_Boolean IsClosed (const TopoDS_Wire& W)
 //=======================================================================
 
 static Standard_Boolean IsInside(const TopoDS_Wire&       wir,
-                                const TopoDS_Face&       F,
-                                BRepTopAdaptor_FClass2d& /*FClass2d*/)
+                                 const TopoDS_Face&       F,
+                                 BRepTopAdaptor_FClass2d& /*FClass2d*/)
 {
-
-//Standard_Real U,V;
   TopExp_Explorer exp;
   for (exp.Init(wir,TopAbs_EDGE);
        exp.More();
@@ -270,20 +267,18 @@ static Standard_Boolean IsInside(const TopoDS_Wire&       wir,
     Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(edg,F,f,l);
     Standard_Real prm;
 
-    if (!Precision::IsNegativeInfinite(f) && 
-       !Precision::IsPositiveInfinite(l)) {
+    if (!Precision::IsNegativeInfinite(f) && !Precision::IsPositiveInfinite(l)) {
       prm = (f+l)/2.;
     }
     else {
-      if (Precision::IsNegativeInfinite(f) && 
-         Precision::IsPositiveInfinite(l)){
-       prm = 0.;
+      if (Precision::IsNegativeInfinite(f) && Precision::IsPositiveInfinite(l)){
+        prm = 0.;
       }
       else if (Precision::IsNegativeInfinite(f)) {
-       prm = l-1.;
+        prm = l-1.;
       }
       else {
-       prm = f+1.;
+        prm = f+1.;
       }
     }
 
@@ -300,9 +295,9 @@ static Standard_Boolean IsInside(const TopoDS_Wire&       wir,
 //=======================================================================
 
 static void Store (const TopoDS_Wire& W2,
-                  const TopoDS_Wire& W1,
-                  TopTools_DataMapOfShapeListOfShape& keyIsIn,
-                  TopTools_DataMapOfShapeListOfShape& keyContains)
+                   const TopoDS_Wire& W1,
+                   TopTools_DataMapOfShapeListOfShape& keyIsIn,
+                   TopTools_DataMapOfShapeListOfShape& keyContains)
 {
   if (!keyIsIn.IsBound(W2)) {
     TopTools_ListOfShape empty;
@@ -320,12 +315,12 @@ static void Store (const TopoDS_Wire& W2,
 //purpose  : 
 //=======================================================================
 
-static void BuildFaceIn(      TopoDS_Face& F, 
-                       const TopoDS_Wire& W, 
-                       TopTools_DataMapOfShapeListOfShape& KeyContains, 
-                       TopTools_DataMapOfShapeListOfShape& KeyIsIn,
-                       TopAbs_Orientation                  Orientation,
-                       TopTools_ListOfShape&               Faces)
+static void BuildFaceIn(  TopoDS_Face& F, 
+                          const TopoDS_Wire& W, 
+                          TopTools_DataMapOfShapeListOfShape& KeyContains, 
+                          TopTools_DataMapOfShapeListOfShape& KeyIsIn,
+                          TopAbs_Orientation                  Orientation,
+                          TopTools_ListOfShape&               Faces)
 {
   BRep_Builder B;
   
@@ -341,8 +336,8 @@ static void BuildFaceIn(      TopoDS_Face& F,
     TopTools_ListIteratorOfListOfShape it2;
     for (it2.Initialize(L2); it2.More(); it2.Next()) {
       if (it2.Value().IsSame(W)) {
-       L2.Remove(it2);
-       break;
+        L2.Remove(it2);
+        break;
       }
     }
   }
@@ -363,19 +358,19 @@ static void BuildFaceIn(      TopoDS_Face& F,
     TopTools_ListOfShape& L2 = KeyIsIn(WI);
     if (L2.IsEmpty()) {
       if (Orientation == TopAbs_FORWARD) {
-       TopoDS_Wire NWI(WI);
-       NWI.Reverse();
-//     TopoDS_Wire NWI = TopoDS::Wire(WI.Reversed());
-       B.Add(F,NWI);
-       BuildFaceIn (F,WI,KeyContains, KeyIsIn,TopAbs_REVERSED,Faces);
+        TopoDS_Wire NWI(WI);
+        NWI.Reverse();
+        // TopoDS_Wire NWI = TopoDS::Wire(WI.Reversed());
+        B.Add(F,NWI);
+        BuildFaceIn (F,WI,KeyContains, KeyIsIn,TopAbs_REVERSED,Faces);
       }
       else {
-       TopoDS_Shape aLocalShape  = Faces.First().EmptyCopied();
-       TopoDS_Face NF = TopoDS::Face(aLocalShape);
-//     TopoDS_Face NF = TopoDS::Face(Faces.First().EmptyCopied());;
-       B.Add        (NF,WI);
-       Faces.Append (NF);
-       BuildFaceIn (NF, WI, KeyContains, KeyIsIn, TopAbs_FORWARD,Faces);
+        TopoDS_Shape aLocalShape  = Faces.First().EmptyCopied();
+        TopoDS_Face NF = TopoDS::Face(aLocalShape);
+        // TopoDS_Face NF = TopoDS::Face(Faces.First().EmptyCopied());;
+        B.Add        (NF,WI);
+        Faces.Append (NF);
+        BuildFaceIn (NF, WI, KeyContains, KeyIsIn, TopAbs_FORWARD,Faces);
       }
     }
   }
@@ -406,7 +401,7 @@ void BRepAlgo_FaceRestrictor::PerformWithCorrection()
     if (IsClosed(W)) {  
       BRepTopAdaptor_FClass2d FClass2d(NF,Precision::PConfusion());
       if(FClass2d.PerformInfinitePoint() != TopAbs_OUT) { 
-       W.Reverse();
+        W.Reverse();
       }
     }
   }
@@ -429,12 +424,12 @@ void BRepAlgo_FaceRestrictor::PerformWithCorrection()
       
       BRepTopAdaptor_FClass2d FClass2d(NF,Precision::PConfusion());
       while (it2.More()) {
-       const TopoDS_Wire& W2 = TopoDS::Wire(it2.Value());
-       if (!W1.IsSame(W2) && IsInside (W2,NF,FClass2d)) {
-         Store (W2,W1,keyIsIn,keyContains);
-       } 
-       it2.Next();
-       j++;
+        const TopoDS_Wire& W2 = TopoDS::Wire(it2.Value());
+        if (!W1.IsSame(W2) && IsInside (W2,NF,FClass2d)) {
+          Store (W2,W1,keyIsIn,keyContains);
+        } 
+        it2.Next();
+        j++;
       }
     }
     i++;
index 3184071..f0f1046 100755 (executable)
@@ -635,7 +635,6 @@ TopoDS_Shape BRepFill_Pipe::MakeShape(const TopoDS_Shape& S,
   else {
     return result;
   }
-  return result;
 }
 
 //============================================================================
index f70c716..0c4bf5d 100755 (executable)
@@ -65,8 +65,6 @@ Standard_Integer  BRepGProp_EdgeTool::IntegrationOrder(const BRepAdaptor_Curve&
     default :
       return 10;
   }
-  //POP WE should return something : -> Default
-  return 10;
 }
 
 gp_Pnt  BRepGProp_EdgeTool::Value(const BRepAdaptor_Curve& C, const Standard_Real U)
index 2d2ddde..9ec9169 100755 (executable)
@@ -73,7 +73,6 @@
 #include <TopOpeBRep_Point2d.hxx>
 #include <TopOpeBRepDS_Transition.hxx>
 
-//#ifdef WNT
 #include <stdio.h>
 #ifdef WNT
 Standard_IMPORT Draw_Viewer dout;
@@ -1142,11 +1141,6 @@ static Standard_Integer bsplineprof(Draw_Interpretor& di,
   DBRep::Set(a[1],S);
   
   return 0;
-
-#ifdef DEB  
-  di << "profile : bad number of arguments";
-  return 1;
-#endif
 }
 
 
index e32942c..16d876c 100755 (executable)
 #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
 
 static void GeomLib_ChangeUBounds(Handle(Geom_BSplineSurface)& aSurface,
-                                 const Standard_Real newU1,
-                                 const Standard_Real newU2)
+                                  const Standard_Real newU1,
+                                  const Standard_Real newU2)
 {
   TColStd_Array1OfReal  knots(1,aSurface->NbUKnots()) ;
   aSurface->UKnots(knots) ;
   BSplCLib::Reparametrize(newU1,
-                         newU2,
-                         knots) ;
+                          newU2,
+                          knots) ;
   aSurface->SetUKnots(knots) ;
 }
 static void GeomLib_ChangeVBounds(Handle(Geom_BSplineSurface)& aSurface,
-                                 const Standard_Real newV1,
-                                 const Standard_Real newV2)
+          const Standard_Real newV1,
+          const Standard_Real newV2)
 {
   TColStd_Array1OfReal  knots(1,aSurface->NbVKnots()) ;
   aSurface->VKnots(knots) ;
   BSplCLib::Reparametrize(newV1,
-                         newV2,
-                         knots) ;
+                          newV2,
+                          knots) ;
   aSurface->SetVKnots(knots) ;
 }
 
@@ -417,45 +417,45 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
     Handle(Standard_Type) myT = S->DynamicType();
     if(myT != STANDARD_TYPE(Geom_Plane)) {
       if(newF.IsNull()) {
-       Handle(Standard_Type) st = C2d->DynamicType();
-       if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
-           (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
-         if(isConvert2d) {
-           Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
-           return Standard_True;
-         }
-         return Standard_False;
-        }
-      }
-      else {
-       S = BRep_Tool::Surface(newF);
-       
+        Handle(Standard_Type) st = C2d->DynamicType();
+        if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
+            (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
+          if(isConvert2d) {
+            Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
+            return Standard_True;
+          }
+          return Standard_False;
+              }
+            }
+            else {
+        S = BRep_Tool::Surface(newF);
+        
       }
       S->Bounds(Uinf, Usup, Vinf, Vsup);
       //Uinf -= 1e-9; Usup += 1e-9; Vinf -= 1e-9; Vsup += 1e-9;
       u = (Usup - Uinf)*0.1;
       v = (Vsup - Vinf)*0.1;
       if(S->IsUPeriodic()) {
-       Standard_Real uperiod = S->UPeriod();
-       if(uperiod < (Usup+2*u-Uinf)) {
-         if(uperiod <= (Usup-Uinf))  {
-           u = 0;
-         } 
-         else {
-           u = (uperiod-(Usup-Uinf))*0.5;
-         }
-       }
+        Standard_Real uperiod = S->UPeriod();
+        if(uperiod < (Usup+2*u-Uinf)) {
+          if(uperiod <= (Usup-Uinf))  {
+            u = 0;
+          } 
+          else {
+            u = (uperiod-(Usup-Uinf))*0.5;
+          }
+        }
       }
       if(S->IsVPeriodic()) {
-       Standard_Real vperiod = S->VPeriod();
-       if(vperiod < (Vsup+2*v-Vinf)) {
-         if(vperiod <= (Vsup-Vinf)) {
-           v = 0;
-         }
-         else {
-           v = (vperiod-(Vsup-Vinf))*0.5;
-         }
-       }
+        Standard_Real vperiod = S->VPeriod();
+        if(vperiod < (Vsup+2*v-Vinf)) {
+          if(vperiod <= (Vsup-Vinf)) {
+            v = 0;
+          }
+          else {
+            v = (vperiod-(Vsup-Vinf))*0.5;
+          }
+        }
       }
     }
     else {
@@ -464,8 +464,8 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
       Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
       ProjLib_ComputeApprox ProjOnCurve(G3dAHC,GAHS,Tol);
       if(ProjOnCurve.BSpline().IsNull()) {
-       Curve2d = Geom2dConvert::CurveToBSplineCurve(ProjOnCurve.Bezier());
-       return Standard_True;
+        Curve2d = Geom2dConvert::CurveToBSplineCurve(ProjOnCurve.Bezier());
+        return Standard_True;
       }
       Curve2d = ProjOnCurve.BSpline();
       return Standard_True;
@@ -491,11 +491,12 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
     TColStd_ListIteratorOfListOfTransient itlcu;
     
     for (itled.Initialize(myled), itlcu.Initialize(mylcu);
-        itled.More(); // itlcu.More()
-        itled.Next(),itlcu.Next()) {
+          itled.More(); // itlcu.More()
+          itled.Next(),itlcu.Next()) 
+    {
       if (itled.Value().IsSame(E)) {
-       // deja traitee
-       break;
+        // deja traitee
+        break;
       }
     }
     if (!itled.More()) { // on stocke l`edge et la curve2d
@@ -521,10 +522,10 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
            return Standard_True;
          }
         
-       return Standard_False;
+        return Standard_False;
       }
       if(!newE.IsNull()) {
-       C3d = BRep_Tool::Curve(newE, f3d,l3d);
+        C3d = BRep_Tool::Curve(newE, f3d,l3d);
       }
       GeomAdaptor_Curve G3dAC(C3d, f3d, l3d);
       Handle(GeomAdaptor_HCurve) G3dAHC = new GeomAdaptor_HCurve(G3dAC);
@@ -532,19 +533,19 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
       Handle(Geom_Surface) S = BRep_Tool::Surface(F);
       Handle(Standard_Type) myT = S->DynamicType();
       if(newF.IsNull()) {
-       mylcu.Append(C2dBis);
-       Handle(Standard_Type) st = C2d->DynamicType();
-       if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
-           (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
-         if(isConvert2d) {
-           Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
-           return Standard_True;
-         }
-         return Standard_False;
-       }
+        mylcu.Append(C2dBis);
+        Handle(Standard_Type) st = C2d->DynamicType();
+        if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
+            (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
+          if(isConvert2d) {
+            Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
+            return Standard_True;
+          }
+          return Standard_False;
+        }
       }
       else {
-       S = BRep_Tool::Surface(newF);// S est une BSplineSurface : pas besoin de la trimmed
+        S = BRep_Tool::Surface(newF);// S est une BSplineSurface : pas besoin de la trimmed
       }
       Standard_Real Uinf, Usup, Vinf, Vsup, u = 0, v = 0;
       S->Bounds(Uinf, Usup, Vinf, Vsup);
@@ -552,52 +553,50 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
       u = (Usup - Uinf)*0.1;
       v = (Vsup - Vinf)*0.1;
       if(S->IsUPeriodic()) {
-       Standard_Real uperiod = S->UPeriod();
-       if(uperiod < (Usup+2*u-Uinf))
-         if(uperiod <= (Usup-Uinf))
-           u = 0;
-         else
-           u = (uperiod-(Usup-Uinf))*0.5;
+        Standard_Real uperiod = S->UPeriod();
+        if(uperiod < (Usup+2*u-Uinf))
+          if(uperiod <= (Usup-Uinf))
+            u = 0;
+          else
+            u = (uperiod-(Usup-Uinf))*0.5;
       }
       if(S->IsVPeriodic()) {
-       Standard_Real vperiod = S->VPeriod();
-       if(vperiod < (Vsup+2*v-Vinf))
-         if(vperiod <= (Vsup-Vinf))
-           v = 0;
-         else
-           v = (vperiod-(Vsup-Vinf))*0.5;
+        Standard_Real vperiod = S->VPeriod();
+        if(vperiod < (Vsup+2*v-Vinf))
+          if(vperiod <= (Vsup-Vinf))
+            v = 0;
+          else
+            v = (vperiod-(Vsup-Vinf))*0.5;
       }
       GeomAdaptor_Surface GAS(S, Uinf-u,Usup+u,Vinf-v,Vsup+v);
       Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
       myled.Append(E);
 
       ProjLib_ComputeApproxOnPolarSurface 
-       ProjOnCurve(G2dAHC,G2dAHCBis,G3dAHC,GAHS,Tol);
+      ProjOnCurve(G2dAHC,G2dAHCBis,G3dAHC,GAHS,Tol);
 
       if(ProjOnCurve.IsDone()) {
-       Curve2d = ProjOnCurve.BSpline();
-       mylcu.Append(ProjOnCurve.Curve2d());
-       return Standard_True;
+        Curve2d = ProjOnCurve.BSpline();
+        mylcu.Append(ProjOnCurve.Curve2d());
+        return Standard_True;
       }
       else {
-       Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
-       mylcu.Append(C2dBis);
-       return Standard_True;
+        Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
+        mylcu.Append(C2dBis);
+        return Standard_True;
       }
     }
     else { // on est au 2ieme tour 
       C2d = Handle(Geom2d_Curve)::DownCast(itlcu.Value());
       Handle(Standard_Type) st = C2d->DynamicType();
       if (!(st == STANDARD_TYPE(Geom2d_BSplineCurve)) &&
-         !(st == STANDARD_TYPE(Geom2d_BezierCurve))) {
-       return Standard_False;
+          !(st == STANDARD_TYPE(Geom2d_BezierCurve))) {
+        return Standard_False;
       }
       Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
       return Standard_True;
     }
   }
-  Curve2d = C2d;
-  return Standard_True;
 }
 
 //=======================================================================
@@ -632,7 +631,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewParameter
   if(proj.IsDone()) {
     Standard_Real Dist2Min = proj.SquareDistance();
     if (Dist2Min < Tol*Tol) {
-//     Standard_Real U_final_point,V_final_point;
+      // Standard_Real U_final_point,V_final_point;
       P = proj.Point().Parameter();
       return Standard_True;
     }
index 9b1440a..38a76d9 100755 (executable)
@@ -707,7 +707,6 @@ gp_Pnt ComputePoint(const TopoDS_Vertex& V,const TopoDS_Edge& E,
     thePoint = cc.Value(Param);
     return thePoint;
   } // else ...
-  return thePoint;
 } // ComputePoint
 
 
index a736a10..b650f00 100755 (executable)
@@ -917,7 +917,6 @@ static Standard_Integer SurfIndex(const ChFiDS_StripeArray1& StripeArray1,
   case FACE2:       return aSurfData->IndexOfS2();
   default:          return -1;
   }
-  return -1;
 }
 
 //=======================================================================
index 2a6960b..ecc5ebf 100755 (executable)
@@ -199,8 +199,6 @@ static Standard_Real ComputeAbscissa(const BRepAdaptor_Curve& C,
   default:
     return 0;
   }    
-  Standard_NotImplemented::Raise("calculate abscisse non-processed");
-  return 0.;
 }
 
 //=======================================================================
index 85e3b09..11f117e 100755 (executable)
@@ -209,13 +209,13 @@ Handle(Draw_Drawable3D) DDataStd_DrawDriver::DrawableConstraint (const Handle(TD
   case TDataXtd_RADIUS:
     {
       if (A->IsPlanar()) {
-       D = new DrawDim_PlanarRadius (TNaming_Tool::GetShape(A->GetGeometry(1)));
+        D = new DrawDim_PlanarRadius (TNaming_Tool::GetShape(A->GetGeometry(1)));
       }
       else {
-       TopoDS_Shape aLocalShape = Geometry(A,1,TopAbs_FACE);
-       TopoDS_Face F1 = TopoDS::Face(aLocalShape);
-//     TopoDS_Face F1 = TopoDS::Face(Geometry(A,1,TopAbs_FACE));
-       if (!F1.IsNull()) D = new DrawDim_Radius(F1);
+        TopoDS_Shape aLocalShape = Geometry(A,1,TopAbs_FACE);
+        TopoDS_Face F1 = TopoDS::Face(aLocalShape);
+        // TopoDS_Face F1 = TopoDS::Face(Geometry(A,1,TopAbs_FACE));
+        if (!F1.IsNull()) D = new DrawDim_Radius(F1);
       }
     }
     break;
@@ -250,25 +250,11 @@ Handle(Draw_Drawable3D) DDataStd_DrawDriver::DrawableConstraint (const Handle(TD
   case TDataXtd_DISTANCE:
     {
       if (A->IsPlanar()) {
-       D = new DrawDim_PlanarDistance (TNaming_Tool::GetShape(A->GetGeometry(1)),
-                                       TNaming_Tool::GetShape(A->GetGeometry(2)));
-      }
-      else {
-       break;
-       TopoDS_Shape aLocalShape = (Geometry (A, 1, TopAbs_FACE));
-       TopoDS_Face F1 = TopoDS::Face (aLocalShape);
-//     TopoDS_Face F1 = TopoDS::Face (Geometry (A, 1, TopAbs_FACE));
-       if (A->NbGeometries() == 1) D = new DrawDim_Distance (F1);
-       else {
-         TopoDS_Shape aLocalShape = Geometry(A,2,TopAbs_FACE);
-         TopoDS_Face F2 = TopoDS::Face(aLocalShape);
-//       TopoDS_Face F2 = TopoDS::Face(Geometry(A,2,TopAbs_FACE));
-         D = new DrawDim_Distance(F1,F2);
-       }
+        D = new DrawDim_PlanarDistance (TNaming_Tool::GetShape(A->GetGeometry(1)),
+                                        TNaming_Tool::GetShape(A->GetGeometry(2)));
       }
+      break;
     }
-    break;
-    
   case TDataXtd_ANGLE:
     {     
       if (A->IsPlanar()) {
index f316431..3c7e770 100755 (executable)
@@ -89,8 +89,6 @@ static Standard_Integer DPrsStd_AISDisplay (Draw_Interpretor& di,
     TPrsStd_AISViewer::Update(L);
     return 0;
   }
-  di << "DPrsStd_AISDisplay : Error" << "\n";
-  return 1;
 }
 
 //=======================================================================
index 219b3af..730c396 100755 (executable)
@@ -416,10 +416,9 @@ static unsigned int __stdcall CpuFunc (void * param)
     {
       cout << "Process killed by CPU limit (" << CPU_LIMIT << " sec)" << endl;
       ExitProcess (2);
-      return 0;
+//      return 0;
     }
   }
-  return 0;
 }
 #else
 static void CpuFunc (int)
index af3c796..4877796 100755 (executable)
@@ -1405,7 +1405,6 @@ LRESULT APIENTRY DrawWindow::DrawProc(HWND hWnd, UINT wMsg, WPARAM wParam, LPARA
     else
       return(DefMDIChildProc(hWnd, wMsg, wParam, lParam));
   }
-  return (0l);
 }
 
 
index ee13251..21b613a 100755 (executable)
@@ -229,7 +229,6 @@ static Standard_Boolean PerformComposite (TColStd_SequenceOfReal& Parameters,
 
     Ua = Ub;
   }
-  return Standard_True;
 }
 
 
index 703ad0c..150901f 100755 (executable)
@@ -194,7 +194,6 @@ static Standard_Boolean PerformComposite (TColStd_SequenceOfReal& Parameters,
 
     Ua = Ub;
   }
-  return Standard_True;
 }
 
 
index f9b6ad8..dd547cd 100755 (executable)
@@ -715,7 +715,6 @@ Standard_Boolean Geom2dGcc_Circ2d2TanOn::
     if (TheSame1(Index) == 0) { return Standard_False; }
     else { return Standard_True; }
   }
-  return Standard_False;
 }
 
 Standard_Boolean Geom2dGcc_Circ2d2TanOn::
@@ -731,5 +730,5 @@ Standard_Boolean Geom2dGcc_Circ2d2TanOn::
     if (TheSame1(Index) == 0) { return Standard_False; }
     else { return Standard_True; }
   }
-  return Standard_True;
+//  return Standard_True;
 }
index ef4d191..ea99c42 100755 (executable)
@@ -496,7 +496,6 @@ Standard_Boolean Geom2dGcc_Circ2d2TanRad::
     if (TheSame1(Index) == 0) { return Standard_False; }
     else { return Standard_True; }
   }
-  return Standard_True;
 }
 
 Standard_Boolean Geom2dGcc_Circ2d2TanRad::
@@ -512,5 +511,5 @@ Standard_Boolean Geom2dGcc_Circ2d2TanRad::
     if (TheSame1(Index) == 0) { return Standard_False; }
     else { return Standard_True; }
   }
-  return Standard_True;
+//  return Standard_True;
 }
index 6645b2f..c464a9f 100755 (executable)
@@ -579,7 +579,7 @@ Standard_Boolean GeomFill::GetCircle(const Convert_ParameterisationType  TConv,
     }
     return Standard_True;
   }
-  return Standard_False;
+//  return Standard_False;
 }
 
 Standard_Boolean GeomFill::GetCircle(const Convert_ParameterisationType  TConv, 
@@ -763,5 +763,4 @@ Standard_Boolean GeomFill::GetCircle(const Convert_ParameterisationType  TConv,
     }
     return Standard_True;
   }
-  return Standard_False;
 }
index 8cb6e1b..09bc835 100755 (executable)
@@ -344,45 +344,43 @@ static Standard_Integer cirtang (Draw_Interpretor& di,Standard_Integer n, const
       }
 
       else {
-       // R-C-R
-       di << "Radius - Curve - Radius ??"<<"\n";
-       return 1;
+        // R-C-R
+        di << "Radius - Curve - Radius ??"<<"\n";
+        return 1;
       }
     }
     else if (ip2) {
       // R-P-..
       if (!C3.IsNull()) {
-       // R-P-C
-       Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C3),
-                                   new Geom2d_CartesianPoint(P2),
-                                   Draw::Atof(a[2]),
-                                   tol);
-       return solutions(di,ct3,a[1]);
-      }
-      
-      else if (ip3) {
-       // R-P-P
-       Geom2dGcc_Circ2d2TanRad ct3(new Geom2d_CartesianPoint(P2),
-                                   new Geom2d_CartesianPoint(P3),
-                                   Draw::Atof(a[2]),
-                                   tol);
-       return solutions(di,ct3,a[1]);
+        // R-P-C
+        Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C3),
+                  new Geom2d_CartesianPoint(P2),
+                  Draw::Atof(a[2]),
+                  tol);
+        return solutions(di,ct3,a[1]);
       }
       
+      else if (ip3) 
+      {
+        // R-P-P
+        Geom2dGcc_Circ2d2TanRad ct3(new Geom2d_CartesianPoint(P2),
+                  new Geom2d_CartesianPoint(P3),
+                  Draw::Atof(a[2]),
+                  tol);
+        return solutions(di,ct3,a[1]);
+      }      
       else {
-       // R-P-R
-       di << "Radius - Point - Radius ??"<<"\n";
-       return 1;
+        // R-P-R
+        di << "Radius - Point - Radius ??"<<"\n";
+        return 1;
       }
     }
-
     else {
       // R-R-..
       di << "radius, radius ???"<<"\n";
       return 1;
     }
   }
-  return 0;
 }
 
 
index 31a93b8..d53af38 100755 (executable)
@@ -262,7 +262,7 @@ static Standard_Real LocalFirstParameter (const Handle(IntPatch_Line)& L)
       return firstp;
     }
   }
-  return firstp;
+//  return firstp;
 }
 
 //=======================================================================
@@ -344,7 +344,6 @@ static Standard_Real LocalLastParameter (const Handle(IntPatch_Line)& L)
       return lastp;
     }
   }
-  return lastp;
 }
 
 
index 0b8b2eb..0945053 100755 (executable)
@@ -518,8 +518,7 @@ Standard_Integer IntPatch_Polyhedron::TriConnex (const Standard_Integer Triang,
     TempOtherP = OtherP;
 
     return(0); //-- BUG NON CORRIGE ( a revoir le role de nbdeltaU et nbdeltaV)
-
-    return(TriConnex(TempTri,Pivot,TempOtherP,TriCon,OtherP));
+//    return(TriConnex(TempTri,Pivot,TempOtherP,TriCon,OtherP));
   }
   return TriCon;
 }
index a51ad7d..a9fe343 100755 (executable)
@@ -262,10 +262,10 @@ gp_Pnt IntSurf_Quadric::Value(const Standard_Real U,
       gp_Pnt p(0,0,0);
       return(p);
     }
-    break;
+    //break;
   }
 // pop : pour NT
-  return gp_Pnt(0,0,0);
+//  return gp_Pnt(0,0,0);
 }
 // ============================================================
 void IntSurf_Quadric::D1(const Standard_Real U,
@@ -313,10 +313,10 @@ gp_Vec IntSurf_Quadric::DN(const Standard_Real U,
       gp_Vec v(0,0,0);
       return(v);
     }
-    break;
+    //break;
   }
 // pop : pour NT
-  return gp_Vec(0,0,0);
+//  return gp_Vec(0,0,0);
 }
 // ============================================================
 gp_Vec IntSurf_Quadric::Normale(const Standard_Real U,
@@ -348,10 +348,10 @@ gp_Vec IntSurf_Quadric::Normale(const Standard_Real U,
       gp_Vec v(0,0,0);
       return(v);
     }     
-    break;
+  //  break;
   }
 // pop : pour NT
-  return gp_Vec(0,0,0);
+//  return gp_Vec(0,0,0);
 }
 // ============================================================
 gp_Vec IntSurf_Quadric::Normale (const gp_Pnt& P) const
@@ -394,10 +394,8 @@ gp_Vec IntSurf_Quadric::Normale (const gp_Pnt& P) const
     {
       gp_Vec v(0,0,0);
       return(v);
-    }     break;
+    } //    break;
   }
-// pop : pour NT
-  return gp_Vec(0,0,0);
 }
 // ============================================================
 void IntSurf_Quadric::Parameters (const gp_Pnt& P,
index 37a910a..649fec2 100755 (executable)
@@ -941,7 +941,7 @@ void IntTools_EdgeFace::CheckData()
     }
   }
   */
-  return 0;
+//  return 0;
 }
 
 
index d279aac..2206678 100755 (executable)
@@ -828,7 +828,6 @@ static Standard_Boolean IsSharpCorner (const Handle(Geom2d_Geometry)& Geom1,
   else {
     return Standard_True;
   }
-  return Standard_False;
 }
 
 
index 508cb22..3d39b3d 100755 (executable)
@@ -49,10 +49,9 @@ static TopAbs_ShapeEnum IntegerToShapeEnum (const Standard_Integer I)
     case  5 : return TopAbs_WIRE;
     case  6 : return TopAbs_EDGE;
     case  7 : return TopAbs_VERTEX;
-      default :
-       return TopAbs_SHAPE;
+      default : 
+        return TopAbs_SHAPE;
     }
-  return TopAbs_SHAPE;
 }
 
 //=======================================================================
index 15fb104..48971bd 100755 (executable)
@@ -51,10 +51,9 @@ static TopAbs_ShapeEnum IntegerToShapeEnum (const Standard_Integer I)
     case  5 : return TopAbs_WIRE;
     case  6 : return TopAbs_EDGE;
     case  7 : return TopAbs_VERTEX;
-      default :
-       return TopAbs_SHAPE;
+      default : 
+        return TopAbs_SHAPE;
     }
-  return TopAbs_SHAPE;
 }
 
 //=======================================================================
@@ -78,7 +77,7 @@ static  TNaming_NameType IntegerToNameType (const Standard_Integer I)
     case  9 : return TNaming_ORIENTATION;
     case  10 : return TNaming_WIREIN;
       default :
-       Standard_DomainError::Raise("TNaming_NameType; enum term unknown ");
+        Standard_DomainError::Raise("TNaming_NameType; enum term unknown ");
     }
   return TNaming_INTERSECTION;
 }
index 0b856d6..4374105 100755 (executable)
@@ -136,8 +136,8 @@ void MeshVS_MeshOwner::SetDetectedEntities (const Handle(TColStd_HPackedMapOfInt
 // Purpose  :
 //================================================================
 void MeshVS_MeshOwner::HilightWithColor (const Handle(PrsMgr_PresentationManager3d)& thePM,
-                                        const Quantity_NameOfColor theColor,
-                                        const Standard_Integer /*theMode*/)
+                                         const Quantity_NameOfColor theColor,
+                                         const Standard_Integer /*theMode*/)
 {
   Handle( SelectMgr_SelectableObject ) aSelObj;
   if ( HasSelectable() )
@@ -151,21 +151,17 @@ void MeshVS_MeshOwner::HilightWithColor (const Handle(PrsMgr_PresentationManager
     if( !aNodes.IsNull() && aNodes->Map().Extent() == 1 )
     {
       TColStd_MapIteratorOfPackedMapOfInteger anIt( aNodes->Map() );
-      for( ; anIt.More(); anIt.Next() )
+      if( myLastID != anIt.Key() )
       {
-       if( myLastID != anIt.Key() )
-         myLastID = anIt.Key();
-       break;
+        myLastID = anIt.Key();
       }
-    }  
+    }
     else if( !aElems.IsNull() && aElems->Map().Extent() == 1 )
     {
       TColStd_MapIteratorOfPackedMapOfInteger anIt( aElems->Map() );
-      for( ; anIt.More(); anIt.Next() )
+      if( myLastID != anIt.Key() )
       {
-       if( myLastID != anIt.Key() )
-         myLastID = anIt.Key();
-       break;
+        myLastID = anIt.Key();
       }
     }
 
@@ -201,24 +197,20 @@ Standard_Boolean MeshVS_MeshOwner::IsForcedHilight () const
     if( !aNodes.IsNull() && aNodes->Map().Extent() == 1 )
     {
       TColStd_MapIteratorOfPackedMapOfInteger anIt( aNodes->Map() );
-      for( ; anIt.More(); anIt.Next() )
-      {
-       aKey = anIt.Key();
-       if( myLastID == aKey )
-         aHilight = Standard_False;
-       break;
+      aKey = anIt.Key();
+      if( myLastID == aKey )
+      {  
+         aHilight = Standard_False;
       }
     }  
     Handle(TColStd_HPackedMapOfInteger) aElems = GetDetectedElements();
     if( !aElems.IsNull() && aElems->Map().Extent() == 1 )
     {
       TColStd_MapIteratorOfPackedMapOfInteger anIt( aElems->Map() );
-      for( ; anIt.More(); anIt.Next() )
+      aKey = anIt.Key();
+      if( myLastID == aKey )
       {
-       aKey = anIt.Key();
-       if( myLastID == aKey )
-         aHilight = Standard_False;
-       break;
+          aHilight = Standard_False;
       }
     }
   } 
index e079220..d48436d 100755 (executable)
@@ -345,7 +345,6 @@ Standard_Boolean OpenGl_GraphicDriver::BufferDump (const Graphic3d_CView&      t
 {
   const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
   return (aCView != NULL) && aCView->WS->BufferDump ((OpenGl_FrameBuffer* )theCView.ptrFBO, theImage, theBufferType);
-  return Standard_False;
 }
 
 Standard_Boolean OpenGl_Workspace::BufferDump (OpenGl_FrameBuffer*         theFBOPtr,
index 7f6bc8f..5e005f8 100755 (executable)
@@ -1207,11 +1207,10 @@ Handle(Adaptor2d_HCurve2d)
 //  Modified by Sergey KHROMOV - Thu Apr 18 10:57:51 2002 End
     return Handle(Adaptor2d_HCurve2d)();
   }
-  myProjIsDone = Standard_False;
+//  myProjIsDone = Standard_False;
 //  Modified by Sergey KHROMOV - Thu Apr 18 10:58:01 2002 Begin
 //   Standard_NoSuchObject_Raise_if(1,"ProjLib_ComputeOnPS: build echec");
 //  Modified by Sergey KHROMOV - Thu Apr 18 10:58:02 2002 End
-  return Handle(Adaptor2d_HCurve2d)();
 }
 
 
index 1e3f220..0d32df1 100755 (executable)
@@ -149,10 +149,10 @@ static Standard_Integer OCC426 (Draw_Interpretor& di, Standard_Integer argc, con
       TopLoc_Location loc;
       Handle(Poly_Triangulation) facing = BRep_Tool::Triangulation(TopologicalFace, loc);
       if (facing.IsNull())
-       {
-         di << "Triangulation FAILED for this face" << "\n";
-         continue;
-       }
+      {
+        di << "Triangulation FAILED for this face" << "\n";
+        continue;
+      }
       di << "No of Triangles = " << facing->NbTriangles() << "\n";
     }
   di<<"Triangulation of all Faces Completed. "<< "\n" << "\n";
@@ -246,40 +246,36 @@ static Standard_Integer OCC486(Draw_Interpretor& di, Standard_Integer argc, cons
       Standard_Integer nPSurf = ( myExtPS.IsDone() ? myExtPS.NbExt() : 0 );
 
       if ( nPSurf > 0 )
-       {
-
-         //Standard_Real distMin = myExtPS.Value ( 1 );
-         Standard_Real distMin = myExtPS.SquareDistance ( 1 );
-         Standard_Integer indMin=1;
-         for (Standard_Integer sol = 2; sol <= nPSurf ; sol++)
-           {
-             //Standard_Real dist = myExtPS.Value(sol);
-             Standard_Real dist = myExtPS.SquareDistance(sol);
-             if ( distMin > dist )
-               {
-                 distMin = dist;
-                 indMin = sol;
-               }
-           }
-//
-         distMin = sqrt(distMin);
-         Standard_Real S, T;
-         myExtPS.Point(indMin).Parameter ( S, T );
-         gp_Pnt aCheckPnt = aSurf.Value( S, T );
-         Standard_Real aCheckDist = P3D.Distance(aCheckPnt);
-         di << "Solution is : U = "<< S << "\t V = "<< T << "\n";
-         di << "Solution is : X = "<< aCheckPnt.X() << "\t Y = "<< aCheckPnt.Y() << "\t Z = "<< aCheckPnt.Z() << "\n";
-         di << "ExtremaDistance = " << distMin  << "\n";
-         di << "CheckDistance = " << aCheckDist << "\n";
-
-         if(fabs(distMin - aCheckDist) < Precision::Confusion()) return 0;
-         else return 1;
-       }
+      {
+        //Standard_Real distMin = myExtPS.Value ( 1 );
+        Standard_Real distMin = myExtPS.SquareDistance ( 1 );
+        Standard_Integer indMin=1;
+        for (Standard_Integer sol = 2; sol <= nPSurf ; sol++)
+        {
+          //Standard_Real dist = myExtPS.Value(sol);
+          Standard_Real dist = myExtPS.SquareDistance(sol);
+          if ( distMin > dist )
+          {
+            distMin = dist;
+            indMin = sol;
+          }
+        }
+        distMin = sqrt(distMin);
+        Standard_Real S, T;
+        myExtPS.Point(indMin).Parameter ( S, T );
+        gp_Pnt aCheckPnt = aSurf.Value( S, T );
+        Standard_Real aCheckDist = P3D.Distance(aCheckPnt);
+        di << "Solution is : U = "<< S << "\t V = "<< T << "\n";
+        di << "Solution is : X = "<< aCheckPnt.X() << "\t Y = "<< aCheckPnt.Y() << "\t Z = "<< aCheckPnt.Z() << "\n";
+        di << "ExtremaDistance = " << distMin  << "\n";
+        di << "CheckDistance = " << aCheckDist << "\n";
+
+        if(fabs(distMin - aCheckDist) < Precision::Confusion()) return 0;
+        else return 1;
+      }
       else return 1;
     }
   catch (Standard_Failure) {di << "OCC486 Exception \n" ;return 1;}
-  
-  return 0;
 }
 
 #include <GC_MakeArcOfCircle.hxx>
index a6b9592..11bed97 100755 (executable)
@@ -53,12 +53,12 @@ static Standard_Integer BUC60738 (Draw_Interpretor& di, Standard_Integer /*argc*
 
   //display mode = Shading
   theAISShape->SetDisplayMode(1);
-       
+
   //get the drawer
   Handle_AIS_Drawer theDrawer = theAISShape->Attributes();
   Handle_Prs3d_ShadingAspect theShadingAspect = theDrawer->ShadingAspect();
   Handle_Graphic3d_AspectFillArea3d theAspectFillArea3d = theShadingAspect->Aspect();
-       
+
   //allow to display the edges
   theAspectFillArea3d->SetEdgeOn();
   //set the style to Dash
@@ -76,80 +76,10 @@ static Standard_Integer BUC60738 (Draw_Interpretor& di, Standard_Integer /*argc*
   return 0;
 }
 
-static int BUC60606(Draw_Interpretor& di, Standard_Integer argc, const char ** argv) {
-
-  di << "Use satread command instead of " << argv[0] << "\n";
-  return -1;
-
-  if(argc!=3) {
-    di << "Usage : " << argv[0] << "name filename" << "\n";
-    return -1;
-  }
-//   Handle_AcisData_AcisModel satModel = new AcisData_AcisModel(); 
-//   Standard_Character *DD = Tcl_GetVar(di.Interp(),"Draw_DataDir",TCL_GLOBAL_ONLY);
-
-//   Standard_Character  *filename = new Standard_Character [strlen(DD)+strlen(argv[2])+1];
-//   Sprintf(filename,"%s/%s",DD,argv[2]);
-
-//   satModel->ReadSaveFile(filename);
-  
-//   Standard_Boolean success = !satModel.IsNull(); 
-//   cout << "n<-- SAT model read : " << (success?"true":"false") << endl << flush; 
-//   if ( success ) {
-//     Standard_Character *Ch=new Standard_Character [strlen(argv[1])+3];
-//     Handle_TopTools_HSequenceOfShape satShapes = satModel->GetShapes();
-//     Standard_Integer nbs=satShapes->Length();
-//     for(Standard_Integer i=1;i<=nbs;i++) {
-//       TopoDS_Shape xShape = satShapes->Value(i);
-//       if(!xShape.IsNull()) {
-//     Sprintf(Ch,"%s_%i",argv[1],i);
-//     DBRep::Set(Ch,xShape);
-//       } else cout << "The shape " << argv[1] << "_" << i << " is NULL !" << endl;
-//     }
-//   }
-  
-
-  return 0;
-}
-
-static int BUC60627(Draw_Interpretor& di, Standard_Integer argc, const char ** argv) {
-  di << "Use satread command instead of " << argv[0] << "\n";
-  return -1;
-
-  // perform the conversion
-  // as in AcisData.cdl --- that's alright
-//   if(argc!=3) {
-//     cerr << "Usage : " << argv[0] << " BREP file" << endl;
-//     return -1;
-//   }
-//   TopoDS_Shape shapeModel=DBRep::Get(argv[1]);
-//   Handle(AcisData_AcisModel) satModel = new AcisData_AcisModel();
-//   satModel->AddShape( shapeModel ); // memorizes "kegel2.brep"
-//   Standard_CString stringData;
-//   Standard_Integer nbChar; // write intermediate stringin order to compute ACIS data
-//   satModel->WriteStringData( stringData, nbChar );
-//   if ( satModel->IsDone() ) {
-//     satModel = new AcisData_AcisModel();
-//     satModel->ReadStringData( stringData );
-//     if ( satModel->IsDone() ) {
-//       // write into file
-//       satModel->WriteSaveFile( argv[2] );
-//       if ( ! satModel->IsDone() ) {
-//     cout << "The SAT madel does not wroute."   << endl;
-//       }
-//     } else cout << "The SAT model does not read from a string."   << endl;
-//     // satModel->ReadStringData( stringData );
-//   } else cout << "The SAT model does not wroute into a string."   << endl;
-//   // satModel->WriteStringData( stringData, nbChar );
-  return 1;
-}
-
 void QABugs::Commands_4(Draw_Interpretor& theCommands) {
   const char *group = "QABugs";
 
   theCommands.Add("BUC60738","BUC60738",__FILE__,BUC60738,group);
-  theCommands.Add("BUC60606","BUC60606 name",__FILE__,BUC60606,group);
-  theCommands.Add("BUC60627","BUC60627 name",__FILE__,BUC60627,group);
-  
+
   return;
 }
index b2fd994..6b76f98 100755 (executable)
@@ -129,8 +129,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::ModifiedFaces() const {
   const TDF_Label& ModifiedFacesLabel = ResultLabel().NewChild();
   TDataStd_Name::Set(ModifiedFacesLabel, "ModifiedFaces");
   return ModifiedFacesLabel;
-#endif
+#else
   return ResultLabel().NewChild();
+#endif
 }
 
 //=======================================================================
@@ -143,8 +144,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::ModifiedEdges() const {
   const TDF_Label& ModifiedEdgesLabel = ResultLabel().NewChild();
   TDataStd_Name::Set(ModifiedEdgesLabel, "ModifiedEdges");
   return ModifiedEdgesLabel;
-#endif
+#else
   return ResultLabel().NewChild();
+#endif
 }
 
 //=======================================================================
@@ -157,8 +159,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::DeletedFaces() const {
   const TDF_Label& DeletedFacesLabel = ResultLabel().NewChild();
   TDataStd_Name::Set(DeletedFacesLabel, "DeletedFaces");
   return DeletedFacesLabel;
-#endif
+#else
   return ResultLabel().NewChild();
+#endif
 }
 
 //=======================================================================
@@ -171,8 +174,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::DeletedEdges() const {
   const TDF_Label& DeletedEdgesLabel = ResultLabel().NewChild();
   TDataStd_Name::Set(DeletedEdgesLabel, "DeletedEdges");
   return DeletedEdgesLabel;
-#endif
+#else
   return ResultLabel().NewChild();
+#endif
 }
 
 //=======================================================================
@@ -185,8 +189,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::DeletedVertices() const {
   const TDF_Label& DeletedVerticesLabel = ResultLabel().NewChild();
   TDataStd_Name::Set(DeletedVerticesLabel, "DeletedVertices");
   return DeletedVerticesLabel;
-#endif
+#else
   return ResultLabel().NewChild();
+#endif
 }
 
 //=======================================================================
@@ -199,8 +204,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::NewShapes() const {
   const TDF_Label& NewShapesLabel = ResultLabel().NewChild();
   TDataStd_Name::Set(NewShapesLabel, "NewShapes");
   return NewShapesLabel;
-#endif
+#else
   return ResultLabel().NewChild();
+#endif
 }
 
 //=======================================================================
@@ -213,8 +219,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::Content() const {
   const TDF_Label& ContentLabel = ResultLabel().NewChild();
   TDataStd_Name::Set(ContentLabel, "Content");
   return ContentLabel;
-#endif
+#else
   return ResultLabel().NewChild();
+#endif
 }
 
 //=======================================================================
@@ -227,8 +234,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::DeletedDegeneratedEdges() const
   const TDF_Label& DegeneratedLabel = ResultLabel().NewChild();
   TDataStd_Name::Set(DegeneratedLabel, "DeletedDegeneratedEdges");
   return DegeneratedLabel;
-#endif
+#else
   return ResultLabel().NewChild();
+#endif
 }
 
 //=======================================================================
index 817339b..317fd28 100755 (executable)
@@ -497,8 +497,9 @@ TDF_Label QANewBRepNaming_Gluing::Content() const {
   const TDF_Label& ContentLabel = ResultLabel().NewChild();
   TDataStd_Name::Set(ContentLabel, "Content");
   return ContentLabel;
-#endif
+#else
   return ResultLabel().NewChild();
+#endif
 }
 
 //=======================================================================
index a958868..912d42e 100755 (executable)
@@ -928,8 +928,8 @@ static Standard_Boolean IsOverlapped(const TopoDS_Edge &theEdge1,
 //=======================================================================
 
 static void SplitEdge(const TopoDS_Edge                &theEdge,
-                     const TopTools_IndexedMapOfShape &theVertices,
-                           TopTools_ListOfShape       &theSplits)
+                      const TopTools_IndexedMapOfShape &theVertices,
+                            TopTools_ListOfShape       &theSplits)
 {
   //const TopoDS_Edge   aNewEdge;
   TopoDS_Vertex aV1;
@@ -945,7 +945,8 @@ static void SplitEdge(const TopoDS_Edge                &theEdge,
 
   Standard_Integer i;
 
-  for (i = 1; i <= theVertices.Extent(); i++) {
+  for (i = 1; i <= theVertices.Extent(); i++) 
+  {
     const TopoDS_Shape &theVtx = theVertices.FindKey(i);
 
     if (!aV1.IsSame(theVtx) && !aV2.IsSame(theVtx))
@@ -956,7 +957,7 @@ static void SplitEdge(const TopoDS_Edge                &theEdge,
 
   theSplits.Clear();
 
-// Splitting of the new edge.
+  // Splitting of the new edge.
   if (!TopOpeBRepTool_TOOL::SplitE(aNewEdge, theSplits)) {
     theSplits.Clear();
     theSplits.Append(theEdge);
@@ -964,32 +965,33 @@ static void SplitEdge(const TopoDS_Edge                &theEdge,
     return;
   }
 
-// Addition of the other internal vertices into the corresponding splits.
+  // Addition of the other internal vertices into the corresponding splits.
   TopoDS_Iterator anIter(theEdge, Standard_False);
 
-  for (; anIter.More(); anIter.Next()) {
+  for (; anIter.More(); anIter.Next()) 
+  {
     TopoDS_Vertex aCurVtx = TopoDS::Vertex(anIter.Value());
 
-// for each vertex which is not the same as aV1, aV2, theIntV1 or theIntV2.
-    if (!aCurVtx.IsSame(aV1) && !aCurVtx.IsSame(aV2) &&
-       !theVertices.Contains(aCurVtx)) {
+    // for each vertex which is not the same as aV1, aV2, theIntV1 or theIntV2.
+    if (!aCurVtx.IsSame(aV1) && !aCurVtx.IsSame(aV2) && !theVertices.Contains(aCurVtx)) 
+    {
       TopTools_ListIteratorOfListOfShape anEdgeIter(theSplits);
-      Standard_Real                      aCurPar;
-
-      aCurPar = BRep_Tool::Parameter(aCurVtx, theEdge);
+      Standard_Real aCurPar = BRep_Tool::Parameter(aCurVtx, theEdge);
 
-// Search for the split the current vertex belongs to.
-      for (; anEdgeIter.More(); anEdgeIter.Next()) {
-       TopoDS_Edge   anEdge = TopoDS::Edge(anEdgeIter.Value());
-       Standard_Real aFPar;
-       Standard_Real aLPar;
+      // Search for the split the current vertex belongs to.
+      for (; anEdgeIter.More(); anEdgeIter.Next()) 
+      {
+        TopoDS_Edge   anEdge = TopoDS::Edge(anEdgeIter.Value());
+        Standard_Real aFPar;
+        Standard_Real aLPar;
 
-       BRep_Tool::Range(anEdge, aFPar, aLPar);
+        BRep_Tool::Range(anEdge, aFPar, aLPar);
 
-       if (aCurPar > aFPar && aCurPar < aLPar) {
-         aBuilder.Add(anEdge, aCurVtx);
-       }
-       break;
+        if (aCurPar > aFPar && aCurPar < aLPar) 
+        {
+          aBuilder.Add(anEdge, aCurVtx);
+        }
+        break;
       }
     }
   }
@@ -998,9 +1000,9 @@ static void SplitEdge(const TopoDS_Edge                &theEdge,
   TopTools_ListIteratorOfListOfShape anEdgeIter(theSplits);
   TopAbs_Orientation                 anOri = theEdge.Orientation();
 
-  for (; anEdgeIter.More(); anEdgeIter.Next()) {
+  for (; anEdgeIter.More(); anEdgeIter.Next()) 
+  {
     TopoDS_Shape &anEdge = anEdgeIter.Value();
-
     anEdge.Orientation(anOri);
   }
 }
index 57fcd06..f8efaa2 100755 (executable)
@@ -249,7 +249,6 @@ Standard_Boolean ShapeAnalysis::IsOuterBound(const TopoDS_Face& face)
     Standard_Boolean rescl = (fcl.PerformInfinitePoint () == TopAbs_OUT);
     return rescl;
   }
-  return Standard_True;
 }
 
 //=======================================================================
index 983846c..3130400 100755 (executable)
@@ -566,7 +566,6 @@ Handle(Geom2d_Curve) ShapeBuild_Edge::TransformPCurve(const Handle(Geom2d_Curve)
     }
     return aBSpline2d;
   }
-  return result;
 }
 
 //=======================================================================
index c0af8c6..a7db264 100755 (executable)
@@ -1563,7 +1563,6 @@ Handle(Geom_Curve) ShapeConstruct_ProjectCurveOnSurface::InterpolateCurve3d(cons
 #endif
     return Standard_False;
   }
-  return Standard_False;  // ramasse-miette
 }
 
 /* S4135 : BestExtremum is commented after IsAnIsoparametric works with Precision::Confusion()
index fd2ba08..3f5b51d 100755 (executable)
@@ -760,7 +760,6 @@ Standard_Boolean ShapeCustom_BSplineRestriction::ConvertSurface(const Handle(Geo
   //else 
   //Surface is not BSpline or Bezier
   //  return Standard_False;
-  return Standard_True;
 }
 
 //=======================================================================
index 11dc383..5243b03 100755 (executable)
@@ -217,7 +217,6 @@ static Standard_Boolean FindParameterWithExt (const gp_Pnt& Pt1,
 #endif
     return Standard_False;
   }
-  return Standard_False;  // normalement, on n y passe jamais
 }
 
 //=======================================================================
index c6592cc..9d1666c 100755 (executable)
@@ -396,7 +396,6 @@ ShapeFix_Wireframe::ShapeFix_Wireframe(const TopoDS_Shape& shape)
 #endif
     return ReplaceFirst;
   }
-  return ReplaceFirst;
 }
 
 //=======================================================================
index c252268..42b3ec0 100755 (executable)
@@ -990,7 +990,8 @@ static Standard_Boolean IsInternal(const TopoDS_Shape& aSx)
   TopoDS_Iterator aIt;
   bInternal = Standard_False;
   aIt.Initialize(aSx);
-  for (; aIt.More(); aIt.Next()) {
+  for (; aIt.More(); aIt.Next()) 
+  {
     const TopoDS_Shape& aSy=aIt.Value();
     aOr=aSy.Orientation();
     bInternal = (aOr == TopAbs_INTERNAL || aOr == TopAbs_EXTERNAL);
index 7d0e529..fbdd70e 100755 (executable)
@@ -330,26 +330,26 @@ void TNaming_Localizer::GoBack (const TopoDS_Shape&         S,
       FindFeaturesInAncestors (S, Sol, AncInFeature); 
       TopTools_MapIteratorOfMapOfShape itF(AncInFeature);
       for ( ; itF.More(); itF.Next()) {
-       const TopoDS_Shape& AncOfS = itF.Key();
-       LBS  .Append(AncOfS);
-       LBNS.Append(TNaming_Tool::NamedShape(AncOfS,Lab));
+        const TopoDS_Shape& AncOfS = itF.Key();
+        LBS  .Append(AncOfS);
+        LBNS.Append(TNaming_Tool::NamedShape(AncOfS,Lab));
       }
     }
   } 
   else {
     for ( ; it.More(); it.Next()) {
-//      if (it.NamedShape()->Evolution() != TNaming_SELECTED) {
+  //      if (it.NamedShape()->Evolution() != TNaming_SELECTED) {
       if (it.NamedShape()->Evolution() == Evol) {
-       Handle(TNaming_NamedShape) NS = TNaming_Tool::NamedShape(it.Shape(),Lab);
-       if (!NS.IsNull()) {
-         LBS.Append  (it.Shape());
-         LBNS.Append (TNaming_Tool::NamedShape(it.Shape(),Lab));
-       }
-       else {
+        Handle(TNaming_NamedShape) NS = TNaming_Tool::NamedShape(it.Shape(),Lab);
+        if (!NS.IsNull()) {
+          LBS.Append  (it.Shape());
+          LBNS.Append (TNaming_Tool::NamedShape(it.Shape(),Lab));
+        }
+        else {
 #ifdef DEB
-         cout <<"TNaming_Localizer: Shape modifie sans avoir ete cree"<<endl;
+          cout <<"TNaming_Localizer: Shape modifie sans avoir ete cree"<<endl;
 #endif
-       }
+        }
       }
     }
   }
index 8667b36..22f5dfd 100755 (executable)
@@ -1185,13 +1185,13 @@ static TopoDS_Shape FindShape(const TNaming_DataMapOfShapeMapOfShape& DM)
       Standard_Boolean isCand(Standard_True); // aS is a Candidate
       TNaming_DataMapIteratorOfDataMapOfShapeMapOfShape it2(DM);
       for (;it2.More();it2.Next()) {
-       const TopoDS_Shape& aKey2 = it2.Key();
-       if(aKey2 == aKey1) continue;
-       const TNaming_MapOfShape& aMap2 = it2.Value();
-       if(!aMap2.Contains(aS)) isCand = Standard_False;
+        const TopoDS_Shape& aKey2 = it2.Key();
+        if(aKey2 == aKey1) continue;
+        const TNaming_MapOfShape& aMap2 = it2.Value();
+        if(!aMap2.Contains(aS)) isCand = Standard_False;
       } 
-      if(isCand)
-       List.Append(aS);
+      if(isCand) 
+        List.Append(aS);
     }
     break; 
   }
index 5008109..8a78386 100755 (executable)
@@ -258,6 +258,8 @@ void TopOpeBRep_FFDumper::DumpVP(const TopOpeBRep_VPointInter& VP,const Standard
 #ifndef DEB
 Standard_Integer TopOpeBRep_FFDumper::ExploreIndex(const TopoDS_Shape& , const Standard_Integer ) const
 {
+    return 0;
+}
 #else
 Standard_Integer TopOpeBRep_FFDumper::ExploreIndex(const TopoDS_Shape& S, const Standard_Integer ISI) const
 {
@@ -265,9 +267,8 @@ Standard_Integer TopOpeBRep_FFDumper::ExploreIndex(const TopoDS_Shape& S, const
   if (ISI == 1) r = myEM1.Find(S);
   if (ISI == 2) r = myEM2.Find(S);
   return r;
-#endif
-  return 0;
 }
+#endif
 
 //=======================================================================
 //function : DumpDSP
index 127f4f4..3405455 100755 (executable)
@@ -39,7 +39,6 @@ int compll(const void* v1, const void* v2) {
   if      (p1 < p2) return (-1);
   else if (p1 > p2) return (1);
   else return (0);
-  return (0);
 }
      
 Standard_EXPORT void BREP_sortonparameter2(TopOpeBRepDS_ListOfInterference& LOI)
index 210159b..6244af6 100755 (executable)
@@ -62,7 +62,6 @@ Standard_Integer BOOPNINTL::Set(const Standard_Boolean b,Standard_Integer n,char
   else {
     return 1;
   }
-  return 0;
 }
 
 Standard_Boolean BOOPNINTL::Get(Standard_Integer n,char**a){
index 2b66ab0..e9b2a9a 100755 (executable)
@@ -1732,59 +1732,58 @@ Standard_Integer TopOpeBRepBuild_Builder1::TwoPiecesON (const TopTools_SequenceO
     // case IV   !RevSense && DifOriented         
     if (!IsEdgesRevSense && IsFacesDifOriented) {
       if (Opefus()) {// Fusion
-       if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_OUT) {
-         Rejected1=Standard_False;
-         Rejected2=Standard_False;
-       }
-       else if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_IN) {
-         Rejected2=Standard_False;
-       }
-       else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_OUT) {
-         Rejected1=Standard_False;
-       }
-       else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) {
-         if(!myProcessedPartsON2d.Contains(aPieceObj)) {//we proceed IsSame only if we didn't it before
-           myProcessedPartsON2d.Add(aPieceObj);
-           IsSame2d (aSeq, aListOfPiecesOut2d); //Perform IsSame 2d and keep periodic parts
-         }
-       }
+        if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_OUT) {
+          Rejected1=Standard_False;
+          Rejected2=Standard_False;
+        }
+        else if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_IN) {
+          Rejected2=Standard_False;
+        }
+        else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_OUT) {
+          Rejected1=Standard_False;
+        }
+        else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) {
+          if(!myProcessedPartsON2d.Contains(aPieceObj)) {//we proceed IsSame only if we didn't it before
+            myProcessedPartsON2d.Add(aPieceObj);
+            IsSame2d (aSeq, aListOfPiecesOut2d); //Perform IsSame 2d and keep periodic parts
+          }
+        }
       }
       
       if (Opecom()) {// Common
-       if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) {
-         Rejected1=Standard_False;
-         Rejected2=Standard_False;
-       }
-       else if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_IN) {
-         Rejected1=Standard_False;
-       }
-       else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_OUT) {
-         Rejected2=Standard_False;
-       }
+        if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) {
+          Rejected1=Standard_False;
+          Rejected2=Standard_False;
+        }
+        else if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_IN) {
+          Rejected1=Standard_False;
+        }
+        else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_OUT) {
+          Rejected2=Standard_False;
+        }
       }
       
       if (Opec12()) { //Cut
-       if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_OUT) {
-         Rejected1=Standard_False;
-       }
-       else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) {
-         Rejected2=Standard_False;
-       }
+        if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_OUT) {
+          Rejected1=Standard_False;
+        }
+        else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) {
+          Rejected2=Standard_False;
+        }
       }
       if (!Rejected1) {
-       aListOfPieces.Append(aPieceObj);
-       aListOfFaces.Append (aFaceObj);
+        aListOfPieces.Append(aPieceObj);
+        aListOfFaces.Append (aFaceObj);
       }
       if (!Rejected2) {
-       aListOfPieces.Append(aPieceTool); 
-       aListOfFaces.Append (aFaceTool);
+        aListOfPieces.Append(aPieceTool); 
+        aListOfFaces.Append (aFaceTool);
       }
       return 4;
     }
     // Unknowm case for existing adjacents
     return 0;
   }
-  return -1;
 }
 
 //=======================================================================
index 8055df0..b4223d5 100755 (executable)
@@ -367,8 +367,8 @@ Standard_Boolean TopOpeBRepBuild_GTopo::IsToReverse1() const
     else IsToRev = (s1 == TopAbs_IN);
     return IsToRev;
   }
-  Standard_ProgramError::Raise("GTopo::IsToReverse1");
-  return Standard_False; // dummy
+//  Standard_ProgramError::Raise("GTopo::IsToReverse1");
+//  return Standard_False; // dummy
 }
 
 
@@ -390,8 +390,6 @@ Standard_Boolean TopOpeBRepBuild_GTopo::IsToReverse2() const
     else IsToRev = (s2 == TopAbs_IN);
     return IsToRev;
   }
-  Standard_ProgramError::Raise("GTopo::IsToReverse2");
-  return Standard_False; // dummy
 }
 
 //=======================================================================
index d751c08..a1be7f2 100755 (executable)
@@ -140,8 +140,8 @@ static
 // purpose :  Correct tolerances for Edge 
 //=======================================================================
 void CorrectEdgeTolerance (const TopoDS_Edge& myShape, 
-                          const TopoDS_Face& S,
-                          const Standard_Real aMaxTol)
+                           const TopoDS_Face& S,
+                           const Standard_Real aMaxTol)
 {
   // 
   // 1. Minimum of conditions to Perform
@@ -169,7 +169,7 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
     if (cr->IsCurve3D()) {
       unique++;
       if (myCref.IsNull() && !cr->Curve3D().IsNull()) {
-       myCref = cr;
+        myCref = cr;
       }
     }
     itcr.Next();
@@ -187,8 +187,8 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
     while (itcr.More()) {
       const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
       if (cr->IsCurveOnSurface()) {
-       myCref = cr;
-       break;
+        myCref = cr;
+        break;
       }
       itcr.Next();
     }
@@ -209,19 +209,19 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
     
     else {
       if (myCref->IsCurve3D()) {
-       Handle(Geom_Curve) C3d = Handle(Geom_Curve)::DownCast
-         (myCref->Curve3D()->Transformed (myCref->Location().Transformation()));
-       GeomAdaptor_Curve GAC3d(C3d,First,Last);
-       myHCurve = new GeomAdaptor_HCurve(GAC3d);
+        Handle(Geom_Curve) C3d = Handle(Geom_Curve)::DownCast
+          (myCref->Curve3D()->Transformed (myCref->Location().Transformation()));
+        GeomAdaptor_Curve GAC3d(C3d,First,Last);
+        myHCurve = new GeomAdaptor_HCurve(GAC3d);
       }
       else { // curve on surface
-       Handle(Geom_Surface) Sref = myCref->Surface();
-       Sref = Handle(Geom_Surface)::DownCast(Sref->Transformed(myCref->Location().Transformation()));
-       const  Handle(Geom2d_Curve)& PCref = myCref->PCurve();
-       Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref);
-       Handle(Geom2dAdaptor_HCurve) GHPCref = new Geom2dAdaptor_HCurve(PCref, First, Last);
-       Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref);
-       myHCurve = new Adaptor3d_HCurveOnSurface(ACSref);
+        Handle(Geom_Surface) Sref = myCref->Surface();
+        Sref = Handle(Geom_Surface)::DownCast(Sref->Transformed(myCref->Location().Transformation()));
+        const  Handle(Geom2d_Curve)& PCref = myCref->PCurve();
+        Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref);
+        Handle(Geom2dAdaptor_HCurve) GHPCref = new Geom2dAdaptor_HCurve(PCref, First, Last);
+        Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref);
+        myHCurve = new Adaptor3d_HCurveOnSurface(ACSref);
       }
     }
   }
@@ -244,62 +244,43 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
     const TopLoc_Location& TFloc = TF->Location();
     const Handle(Geom_Surface)& Su = TF->Surface();
     TopLoc_Location L = (Floc * TFloc).Predivided(myShape.Location());
-    //      Standard_Boolean checkclosed = Standard_False;
     Standard_Boolean pcurvefound = Standard_False;
 
     itcr.Initialize(TE->Curves());
     while (itcr.More()) {
       const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
       if (cr != myCref && cr->IsCurveOnSurface(Su,L)) {
-       pcurvefound = Standard_True;
-       const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr);
-       Standard_Real f,l;
-       GC->Range(f,l);
-       if (SameRange && (f != First || l != Last)) {
-         return ;//BRepCheck_InvalidSameRangeFlag);
-         if (SameParameter) {
-           return; //BRepCheck_InvalidSameParameterFlag);
-         }
+        pcurvefound = Standard_True;
+        const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr);
+        Standard_Real f,l;
+        GC->Range(f,l);
+        if (SameRange && (f != First || l != Last)) {
+          return ;//BRepCheck_InvalidSameRangeFlag;
+        }
+        
+        Handle(Geom_Surface) Sb = cr->Surface();
+        Sb = Handle(Geom_Surface)::DownCast (Su->Transformed(L.Transformation()));
+        Handle(Geom2d_Curve) PC = cr->PCurve();
+        Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(Sb);
+        Handle(Geom2dAdaptor_HCurve) GHPC = new Geom2dAdaptor_HCurve(PC,f,l);
+        Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
+        ok = Validate(myHCurve->Curve(), ACS, Tol, SameParameter, aNewTol);
+        if (ok) {
+          // printf("(Edge,1) Tolerance=%15.10lg\n", aNewTol);
+          if (aNewTol<aMaxTol)
+            TE->UpdateTolerance(aNewTol); 
+        }
+        if (cr->IsCurveOnClosedSurface()) {
+          // checkclosed = Standard_True;
+          GHPC->ChangeCurve2d().Load(cr->PCurve2(),f,l); // same bounds
+          ACS.Load(GAHS); // sans doute inutile
+          ACS.Load(GHPC); // meme remarque...
+          ok = Validate(myHCurve->Curve(),ACS,Tol,SameParameter, aNewTol);
+          if (ok) {
+            if (aNewTol<aMaxTol)
+              TE->UpdateTolerance(aNewTol); 
+          }
         }
-       
-       Handle(Geom_Surface) Sb = cr->Surface();
-       Sb = Handle(Geom_Surface)::DownCast (Su->Transformed(L.Transformation()));
-       Handle(Geom2d_Curve) PC = cr->PCurve();
-       Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(Sb);
-       Handle(Geom2dAdaptor_HCurve) GHPC = new Geom2dAdaptor_HCurve(PC,f,l);
-       Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
-       ok = Validate(myHCurve->Curve(), ACS, Tol, SameParameter, aNewTol);
-       if (ok) {
-         if (cr->IsCurveOnClosedSurface()) {
-           //return ;// BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
-         }
-         else {
-           //return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
-         }
-         if (SameParameter) {
-           //return;//BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
-         }
-//       printf("(Edge,1) Tolerance=%15.10lg\n", aNewTol);
-         if (aNewTol<aMaxTol)
-           TE->UpdateTolerance(aNewTol); 
-       }
-
-       if (cr->IsCurveOnClosedSurface()) {
-         //        checkclosed = Standard_True;
-         GHPC->ChangeCurve2d().Load(cr->PCurve2(),f,l); // same bounds
-         ACS.Load(GAHS); // sans doute inutile
-         ACS.Load(GHPC); // meme remarque...
-         ok = Validate(myHCurve->Curve(),ACS,Tol,SameParameter, aNewTol);
-         if (ok) {
-           //return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
-           if (SameParameter) {
-             //return;//BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
-           }
-//         printf("(Edge,2) Tolerance=%15.10lg\n", aNewTol);
-           if (aNewTol<aMaxTol)
-             TE->UpdateTolerance(aNewTol); 
-         }
-       }
       }
       itcr.Next();
     }
@@ -308,46 +289,44 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
       Handle(Geom_Plane) P;
       Handle(Standard_Type) styp = Su->DynamicType();
       if (styp == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
-       P = Handle(Geom_Plane)::DownCast(Handle(Geom_RectangularTrimmedSurface)::
-                                        DownCast(Su)->BasisSurface());
+        P = Handle(Geom_Plane)::DownCast(Handle(Geom_RectangularTrimmedSurface)::
+                 DownCast(Su)->BasisSurface());
       }
       else {
-       P = Handle(Geom_Plane)::DownCast(Su);
+        P = Handle(Geom_Plane)::DownCast(Su);
       }
       if (P.IsNull()) { // not a plane
-       return;//BRepCheck::Add(lst,BRepCheck_NoCurveOnSurface);
+        return;//BRepCheck::Add(lst,BRepCheck_NoCurveOnSurface);
       }
-      
-      else {// on fait la projection a la volee, comme BRep_Tool
-       P = Handle(Geom_Plane)::DownCast(P->Transformed(L.Transformation()));
-       //on projette Cref sur ce plan
-       Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(P);
-       
-       // Dub - Normalement myHCurve est une GeomAdaptor_HCurve
-       GeomAdaptor_Curve& Gac = Handle(GeomAdaptor_HCurve)::DownCast(myHCurve)->ChangeCurve();
-       Handle(Geom_Curve) C3d = Gac.Curve();
-       Handle(Geom_Curve) ProjOnPlane = GeomProjLib::ProjectOnPlane
-         (new Geom_TrimmedCurve(C3d,First,Last), P, P->Position().Direction(), Standard_True);
-
-       Handle(GeomAdaptor_HCurve) aHCurve = new GeomAdaptor_HCurve(ProjOnPlane);
-       
-       ProjLib_ProjectedCurve proj(GAHS,aHCurve);
-       Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj);
-       Handle(Geom2dAdaptor_HCurve) GHPC = 
-         new Geom2dAdaptor_HCurve(PC, myHCurve->FirstParameter(), myHCurve->LastParameter());
-       
-       Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
-       
-       ok = Validate(myHCurve->Curve(),ACS,
-                      Tol,Standard_True, aNewTol); // voir dub...
-       if (ok) {
-         //return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
-//       printf("(Edge,3) Tolerance=%15.10lg\n", aNewTol);
-         if (aNewTol<aMaxTol)
-           TE->UpdateTolerance(aNewTol); 
-       }
+      else 
+      { // on fait la projection a la volee, comme BRep_Tool
+        P = Handle(Geom_Plane)::DownCast(P->Transformed(L.Transformation()));
+        //on projette Cref sur ce plan
+        Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(P);
+        
+        // Dub - Normalement myHCurve est une GeomAdaptor_HCurve
+        GeomAdaptor_Curve& Gac = Handle(GeomAdaptor_HCurve)::DownCast(myHCurve)->ChangeCurve();
+        Handle(Geom_Curve) C3d = Gac.Curve();
+        Handle(Geom_Curve) ProjOnPlane = GeomProjLib::ProjectOnPlane
+          (new Geom_TrimmedCurve(C3d,First,Last), P, P->Position().Direction(), Standard_True);
+
+        Handle(GeomAdaptor_HCurve) aHCurve = new GeomAdaptor_HCurve(ProjOnPlane);
+        
+        ProjLib_ProjectedCurve proj(GAHS,aHCurve);
+        Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj);
+        Handle(Geom2dAdaptor_HCurve) GHPC = 
+          new Geom2dAdaptor_HCurve(PC, myHCurve->FirstParameter(), myHCurve->LastParameter());
+        
+        Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
+        
+        ok = Validate(myHCurve->Curve(),ACS,
+                            Tol,Standard_True, aNewTol); // voir dub...
+        if (ok) 
+        {
+          if (aNewTol<aMaxTol)
+            TE->UpdateTolerance(aNewTol); 
+        }
       }
-      
     }//end of if (!pcurvefound) {
   } // end of  2. Tolerances in InContext
 
@@ -499,45 +478,43 @@ void CheckEdge (const TopoDS_Edge& Ed, const Standard_Real aMaxTol)
       TopLoc_Location L = (Eloc * loc).Predivided(aVertex.Location());
       
       if (cr->IsCurve3D()) {
-       const Handle(Geom_Curve)& C = cr->Curve3D();
-       if (!C.IsNull()) {
-         itpr.Initialize(TV->Points());
-         while (itpr.More()) {
-           const Handle(BRep_PointRepresentation)& pr = itpr.Value();
-           if (pr->IsPointOnCurve(C,L)) {
-             Controlp = C->Value(pr->Parameter());
-             Controlp.Transform(L.Transformation());
-             aD2=prep.SquareDistance(Controlp);
-             if (aD2 > Tol) {
-               aNewTolerance=sqrt(aD2)+dd;
-//             printf("(Vert,1) Tolerance=%15.10lg\n", aNewTolerance);
-               if (aNewTolerance<aMaxTol)
-                 TV->UpdateTolerance(aNewTolerance);
-             }
-           }
-           itpr.Next();
-         }
-         
-         TopAbs_Orientation orv = aVertex.Orientation();
-         if (orv == TopAbs_FORWARD || orv == TopAbs_REVERSED) {
-           const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr);
-           
-           if (orv==TopAbs_FORWARD)
-             Controlp = C->Value(GC->First());
-           else 
-             Controlp = C->Value(GC->Last());
-
-           Controlp.Transform(L.Transformation());
-           aD2=prep.SquareDistance(Controlp);
-           
-           if (aD2 > Tol) {
-             aNewTolerance=sqrt(aD2)+dd;
-//           printf("(Vert,2) Tolerance=%15.10lg\n", aNewTolerance);
-             if (aNewTolerance<aMaxTol)
-               TV->UpdateTolerance(aNewTolerance);
-           }
-         }
-       }
+        const Handle(Geom_Curve)& C = cr->Curve3D();
+        if (!C.IsNull()) {
+          itpr.Initialize(TV->Points());
+          while (itpr.More()) {
+            const Handle(BRep_PointRepresentation)& pr = itpr.Value();
+            if (pr->IsPointOnCurve(C,L)) {
+              Controlp = C->Value(pr->Parameter());
+              Controlp.Transform(L.Transformation());
+              aD2=prep.SquareDistance(Controlp);
+              if (aD2 > Tol) {
+                aNewTolerance=sqrt(aD2)+dd;
+                if (aNewTolerance<aMaxTol)
+                  TV->UpdateTolerance(aNewTolerance);
+              }
+            }
+            itpr.Next();
+          }
+          
+          TopAbs_Orientation orv = aVertex.Orientation();
+          if (orv == TopAbs_FORWARD || orv == TopAbs_REVERSED) {
+            const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr);
+            
+            if (orv==TopAbs_FORWARD)
+              Controlp = C->Value(GC->First());
+            else 
+              Controlp = C->Value(GC->Last());
+
+            Controlp.Transform(L.Transformation());
+            aD2=prep.SquareDistance(Controlp);
+            
+            if (aD2 > Tol) {
+              aNewTolerance=sqrt(aD2)+dd;
+              if (aNewTolerance<aMaxTol)
+                TV->UpdateTolerance(aNewTolerance);
+            }
+          }
+        }
       }
       itcr.Next();
     }
index 893cece..26da75e 100755 (executable)
@@ -137,7 +137,6 @@ Standard_Boolean TopOpeBRepDS::IsTopology(const TopOpeBRepDS_Kind k)
   case TopOpeBRepDS_VERTEX  : return Standard_True; break;
   default : return Standard_False;
   }
-  return Standard_False;
 }
 
 //=======================================================================
index 616f1c4..b5613ee 100755 (executable)
@@ -168,7 +168,7 @@ static Standard_Boolean GetOrigin(const Handle(Geom2d_Curve)& PCIN, gp_Pnt2d& o)
   else  {
     return Standard_False;
   }
-  return Standard_False;
+//  return Standard_False;
 }
 #endif
 
@@ -199,7 +199,6 @@ static Standard_Boolean GetOrigin(const Handle(Geom_Curve)& CIN, gp_Pnt& o)
   else  {
     return Standard_False;
   }
-  return Standard_False;
 }
 #endif
 
index 4c064b3..3dfa088 100755 (executable)
@@ -100,7 +100,7 @@ Standard_Real  TopOpeBRepDS_PointIterator::Parameter()const
     Standard_ProgramError::Raise("TopOpeBRepDS_PointIterator::Parameter()");
     return 0.;  // windowsNT
   }
-  return 0.;  // windowsNT
+//  return 0.;  // windowsNT
 }
 
 //=======================================================================
@@ -139,7 +139,7 @@ Standard_Boolean TopOpeBRepDS_PointIterator::DiffOriented() const
     Standard_ProgramError::Raise("TopOpeBRepDS_PointIterator::DiffOriented()");
     return Standard_False; // windowsNT
   }
-  return Standard_False; // windowsNT
+//  return Standard_False; // windowsNT
 }
 
 //=======================================================================
@@ -158,7 +158,6 @@ Standard_Boolean TopOpeBRepDS_PointIterator::SameOriented() const
     Standard_ProgramError::Raise("TopOpeBRepDS_PointIterator::SameOriented()");
     return Standard_False; // windowsNT
   }
-  return Standard_False; // windowsNT
 }
 
 //=======================================================================
index 9528672..2f0d748 100755 (executable)
@@ -182,7 +182,7 @@ static Standard_Integer FUN_mkT2dquad(const Standard_Real curvC1, const Standard
   if (samec)           return isON2ifss;//is ON if curves are on same side/tg line
   if (curvC1 > curvC2) return isIN2ifss;//is IN if curves are on same side/tg line
   else                 return isOU2ifss;//is OU if curves are on same side/tg line
-  return 0;
+//  return 0;
 }
 
 static Standard_Boolean FUN_getnearpar(const TopoDS_Edge& e,const Standard_Real par,const Standard_Real f,const Standard_Real l,
@@ -255,7 +255,6 @@ static Standard_Boolean FUN_getsta(const Standard_Integer mkt,const gp_Dir& tga1
     sta = TopAbs_ON; 
     return Standard_True;
   } 
-  return Standard_False;
 } 
 static Standard_Boolean FUN_mkT2dquad(const TopoDS_Edge& e1,const Standard_Real par1,const Standard_Real f1,const Standard_Real l1,
                         const TopoDS_Edge& e2,const Standard_Real par2,
index 5f423d3..e83f740 100755 (executable)
@@ -140,7 +140,6 @@ static IFSelect_ReturnStatus XSControl_xnorm(const Handle(IFSelect_SessionPilot)
     IFSelect_Activator::SetCurrentAlias (WS->SelectedNorm(Standard_True));
     return IFSelect_RetDone;
   }
-  return IFSelect_RetVoid;
 }