Coding, TKDEIGES - Translation to English (#678)

- Updated comments in IGESGeom_ToolCircularArc, IGESGeom_ToolCurveOnSurface, IGESGeom_ToolOffsetCurve, IGESGeom_ToolPlane, IGESGeom_ToolSplineSurface, IGESGeom_ToolTransformationMatrix, IGESGraph_ToolColor, IGESGraph_ToolDrawingUnits, IGESSelect, IGESSelect_Activator, IGESSelect_RebuildGroups, IGESSelect_SelectBypassGroup, IGESSelect_SelectBypassSubfigure, IGESSelect_SignStatus, IGESSelect_ViewSorter, IGESSelect_WorkLibrary, IGESToBRep, IGESToBRep_BRepEntity, IGESToBRep_BasicCurve, IGESToBRep_BasicSurface, IGESToBRep_TopoCurve, IGESToBRep_TopoSurface to improve readability and understanding.
- Translated French comments to English where applicable.
- Ensured comments accurately reflect the functionality and intent of the code.

src/DataExchange/TKDEIGES/BRepToIGES/BRepToIGES_BREntity.cxx

@@ -140,8 +140,8 @@ Handle(IGESData_IGESEntity) BRepToIGES_BREntity::TransferShape(
   }
   else
   {
-    //    la fonction suivante force les surfaces indirectes en
+    //    the following function forces indirect surfaces to
-    //    surfaces directes (obligatoire dans IGES)
+    //    direct surfaces (mandatory in IGES)
     //    theShape = ShapeCustom::DirectFaces(start);
     // sprintf(Name,"res_%d",Nb++);
     // DBRep::Set(Name,theShape);
@@ -183,7 +183,7 @@ Handle(IGESData_IGESEntity) BRepToIGES_BREntity::TransferShape(
     }
     else
     {
-      // message d`erreur
+      // error message
     }
   }
 

src/DataExchange/TKDEIGES/BRepToIGES/BRepToIGES_BRShell.cxx

@@ -93,7 +93,7 @@ Handle(IGESData_IGESEntity) BRepToIGES_BRShell ::TransferShell(
   }
   else
   {
-    // message d`erreur
+    // error message
   }
   return res;
 }
@@ -113,7 +113,7 @@ Handle(IGESData_IGESEntity) BRepToIGES_BRShell ::TransferFace(const TopoDS_Face&
     return res;
   }
 
-  // pour explorer la face , il faut la mettre fORWARD.
+  // to explore the face, it must be set to FORWARD.
   TopoDS_Face aFace = start;
   // Associates the input face (start) and its sub-shapes with the reversed variant,
   // if the input face has a Reversed orientation
@@ -242,7 +242,7 @@ Handle(IGESData_IGESEntity) BRepToIGES_BRShell ::TransferFace(const TopoDS_Face&
   if (!Surf.IsNull())
   {
     Standard_Real U1, U2, V1, V2;
-    // pour limiter les surfaces de base
+    // to limit the base surfaces
     BRepTools::UVBounds(aFace, U1, U2, V1, V2);
     GeomToIGES_GeomSurface GS;
     GS.SetModel(GetModel());

src/DataExchange/TKDEIGES/BRepToIGESBRep/BRepToIGESBRep_Entity.cxx

@@ -14,7 +14,7 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-// modif le 25/03/96 mjm
+// modification on 25/03/96 mjm
 // implement ShapeCustom::DirectModification for indirect surfaces (out of norm IGES)
 //: l4 abv 12 Jan 99: CTS22022-2: correct writing reversed shells
 //: n3 abv 8 Feb 99: PRO17820: BRepTools::OuterWire() -> ShapeAnalysis::OuterWire

src/DataExchange/TKDEIGES/Geom2dToIGES/Geom2dToIGES_Geom2dCurve.cxx

@@ -46,7 +46,7 @@ Geom2dToIGES_Geom2dCurve::Geom2dToIGES_Geom2dCurve(const Geom2dToIGES_Geom2dEnti
 }
 
 //=============================================================================
-// Transfer des Entites Curve de Geom2d vers IGES
+// Transfer of Curve Entities from Geom2d to IGES
 // Transfer2dCurve
 //=============================================================================
 

src/DataExchange/TKDEIGES/Geom2dToIGES/Geom2dToIGES_Geom2dPoint.cxx

@@ -38,7 +38,7 @@ Geom2dToIGES_Geom2dPoint::Geom2dToIGES_Geom2dPoint(const Geom2dToIGES_Geom2dEnti
 }
 
 //=============================================================================
-// Transfer de Point2d de Geom2d vers IGES
+// Transfer of Point2d from Geom2d to IGES
 // Tranfer2dPoint
 //=============================================================================
 
@@ -59,7 +59,7 @@ Handle(IGESGeom_Point) Geom2dToIGES_Geom2dPoint::Transfer2dPoint(const Handle(Ge
 }
 
 //=============================================================================
-// Transfer de CartesianPoint de Geom2d vers IGES
+// Transfer of CartesianPoint from Geom2d to IGES
 // Tranfer2dPoint
 //=============================================================================
 

src/DataExchange/TKDEIGES/Geom2dToIGES/Geom2dToIGES_Geom2dVector.cxx

@@ -40,7 +40,7 @@ Geom2dToIGES_Geom2dVector::Geom2dToIGES_Geom2dVector(const Geom2dToIGES_Geom2dEn
 }
 
 //=============================================================================
-// Transfer des Entites Vector de Geom2d vers IGES
+// Transfer of Vector Entities from Geom2d to IGES
 // Transfer2dVector
 //=============================================================================
 
@@ -68,7 +68,7 @@ Handle(IGESGeom_Direction) Geom2dToIGES_Geom2dVector::Transfer2dVector(
 }
 
 //=============================================================================
-// Transfer des Entites VectorWithMagnitude de Geom2d vers IGES
+// Transfer of VectorWithMagnitude Entities from Geom2d to IGES
 // Transfer2dVector
 //=============================================================================
 
@@ -89,7 +89,7 @@ Handle(IGESGeom_Direction) Geom2dToIGES_Geom2dVector::Transfer2dVector(
 }
 
 //=============================================================================
-// Transfer des Entites Direction de Geom2d vers IGES
+// Transfer of Direction Entities from Geom2d to IGES
 // Transfer2dVector
 //=============================================================================
 

src/DataExchange/TKDEIGES/GeomToIGES/GeomToIGES_GeomCurve.cxx

@@ -69,9 +69,9 @@
 #include <TColStd_HArray1OfReal.hxx>
 
 // Pour toutes les courbes infinies soit
-// Udeb <= -Precision::Infinite() et/ou Ufin >= Precision::Infinite()
+// Udeb <= -Precision::Infinite() and/or Ufin >= Precision::Infinite()
-// on choisit arbitrairement de les construire entre
+// we arbitrarily choose to construct them between
-// Udeb = -Precision::Infinite() et Ufin = Precision::Infinite()
+// Udeb = -Precision::Infinite() and Ufin = Precision::Infinite()
 //=============================================================================
 // GeomToIGES_GeomCurve
 //=============================================================================
@@ -285,8 +285,8 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve(
   Standard_Boolean          IPlan = Standard_False;
   gp_XYZ                    Norm  = gp_XYZ(0., 0., 1.);
 
-  // Si la courbe est periodique, on passe par une fonction pour recuperer tous
+  // If the curve is periodic, we go through a function to recover all
-  // les parametres necessaires a l`ecriture IGES.
+  // the parameters necessary for IGES writing.
 
   Standard_Boolean IPerio = start->IsPeriodic();
 
@@ -349,7 +349,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve(
   Standard_Integer Index = Nbpoles - 1;
 
   // Sequence des Knots de [-Deg, Index+1] dans IGESGeom.
-  // et de [1, Nbpoles+Deg+1] dans Geom
+  // and from [1, Nbpoles+Deg+1] in Geom
   Standard_Integer     Knotindex;
   Standard_Real        rtampon;
   TColStd_Array1OfReal K(1, Nbpoles + Deg + 1);
@@ -909,7 +909,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve(
                 (start->Offset() / GetUnit()),
                 0.,
                 // clang-format off
-		start->Direction().XYZ().Reversed(), U1, U2);  //%11 pdn 12.01.99 // valeur (0,0,1) pour l'instant
+		start->Direction().XYZ().Reversed(), U1, U2);  //%11 pdn 12.01.99 // value (0,0,1) for now
   // clang-format on
 
   res = OffsetC;

src/DataExchange/TKDEIGES/GeomToIGES/GeomToIGES_GeomPoint.cxx

@@ -12,8 +12,8 @@
 // commercial license or contractual agreement.
 
 // modif du 14/09/95 mjm
-// prise en compte de l'unite choisi par l'utilisateur
+// taking into account the unit chosen by the user
-// pour l'ecriture du fichier IGES.
+// for writing the IGES file.
 
 #include <Geom_CartesianPoint.hxx>
 #include <Geom_Point.hxx>
@@ -41,7 +41,7 @@ GeomToIGES_GeomPoint::GeomToIGES_GeomPoint()
 }
 
 //=============================================================================
-// Transfer de Point de Geom vers IGES
+// Transfer of Point from Geom to IGES
 // TranferPoint
 //=============================================================================
 
@@ -61,7 +61,7 @@ Handle(IGESGeom_Point) GeomToIGES_GeomPoint::TransferPoint(const Handle(Geom_Poi
 }
 
 //=============================================================================
-// Transfer de Point de Geom vers IGES
+// Transfer of Point from Geom to IGES
 // TranferPoint
 //=============================================================================
 

src/DataExchange/TKDEIGES/GeomToIGES/GeomToIGES_GeomSurface.cxx

@@ -11,8 +11,8 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-// modif du 22/10/96 mjm
+// modification of 22/10/96 mjm
-// ajout du champ TheLength
+// addition of TheLength field
 //: l6 abv 15.01.99: CTS22022: writing full tori
 // szv#4:S4163:12Mar99
 // S4181 pdn 20.04.99 implementing of writing IGES elementary surfaces.
@@ -104,7 +104,7 @@ GeomToIGES_GeomSurface::GeomToIGES_GeomSurface(const GeomToIGES_GeomEntity& GE)
 }
 
 //=============================================================================
-// Transfer des Entites Surface de Geom vers IGES
+// Transfer of Surface Entities from Geom to IGES
 // TransferSurface
 //=============================================================================
 
@@ -146,7 +146,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
 }
 
 //=============================================================================
-// Transfer des Entites BoundedSurface de Geom vers IGES
+// Transfer of BoundedSurface Entities from Geom to IGES
 // TransferSurface
 //=============================================================================
 
@@ -183,7 +183,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
 }
 
 //=============================================================================
-// Transfer des Entites BSplineSurface de Geom vers IGES
+// Transfer of BSplineSurface Entities from Geom to IGES
 // TransferSurface
 //=============================================================================
 
@@ -334,7 +334,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   Standard_Boolean Polynom  = !(RationU || RationV); // szv#10:PRO19566:05Oct99 && was wrong
 
   // filling knots array for U :
-  // Sequence des Knots de [-DegU, IndexU+1] dans IGESGeom.
+  // Knots sequence from [-DegU, IndexU+1] in IGESGeom.
   Standard_Integer     Knotindex;
   Standard_Real        rtampon;
   Standard_Integer     itampon;
@@ -350,7 +350,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   }
 
   // filling knots array for V :
-  // Sequence des Knots de [-DegV, IndexV+1] dans IGESGeom.
+  // Knots sequence from [-DegV, IndexV+1] in IGESGeom.
   TColStd_Array1OfReal KV(1, NbVPoles + DegV + 1);
   mysurface->VKnotSequence(KV);
   itampon                              = -DegV;
@@ -362,7 +362,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
     itampon++;
   }
 
-  // filling Weights array de [0, IndexU, 0, IndexV]
+  // filling Weights array from [0, IndexU, 0, IndexV]
   // ----------------------------------------------
   Handle(TColStd_HArray2OfReal) Weights   = new TColStd_HArray2OfReal(0, IndexU, 0, IndexV);
   Standard_Integer              WeightRow = Weights->LowerRow();
@@ -390,7 +390,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
     }
   }
 
-  // filling Poles array de [0, IndexU, 0, IndexV]
+  // filling Poles array from [0, IndexU, 0, IndexV]
   // ---------------------------------------------
   Handle(TColgp_HArray2OfXYZ) Poles  = new TColgp_HArray2OfXYZ(0, IndexU, 0, IndexV);
   Standard_Integer            UIndex = Poles->LowerRow();
@@ -433,7 +433,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
 }
 
 //=============================================================================
-// Transfer des Entites BezierSurface de Geom vers IGES
+// Transfer of BezierSurface Entities from Geom to IGES
 // TransferSurface
 //=============================================================================
 
@@ -458,7 +458,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
 }
 
 //=============================================================================
-// Transfer des Entites RectangularTrimmedSurface de Geom vers IGES
+// Transfer of RectangularTrimmedSurface Entities from Geom to IGES
 // TransferSurface
 //=============================================================================
 
@@ -478,8 +478,8 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   Handle(Geom_Surface) st = start->BasisSurface();
   if (st->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
   {
-    // message d'erreur pas de trimmed a partir d'une trimmed ,
+    // error message no trimmed from a trimmed,
-    // on peut eventuellement ecrire la surface de base : st.
+    // we can possibly write the base surface: st.
     return res;
   }
 
@@ -488,7 +488,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
 }
 
 //=============================================================================
-// Transfer des Entites ElementarySurface de Geom vers IGES
+// Transfer of ElementarySurface Entities from Geom to IGES
 // TransferSurface
 //=============================================================================
 
@@ -555,7 +555,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
 }
 
 //=============================================================================
-// Transfer des Entites Plane de Geom vers IGES
+// Transfer of Plane Entities from Geom to IGES
 // TransferSurface
 //=============================================================================
 
@@ -565,7 +565,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(const Handle
                                                                     const Standard_Real       Vdeb,
                                                                     const Standard_Real       Vfin)
 {
-  // on va ecrire une BSplineSurface pour pouvoir etre coherent avec les courbes 2d
+  // we will write a BSplineSurface to be able to be coherent with 2d curves
   Handle(IGESData_IGESEntity) res;
   TheLength = 1;
   if (start.IsNull())
@@ -640,7 +640,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(const Handle
 }
 
 //=============================================================================
-// Transfer des Entites CylindricalSurface de Geom vers IGES
+// Transfer of CylindricalSurface Entities from Geom to IGES
 // TransferSurface
 //=============================================================================
 
@@ -678,7 +678,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   if (Precision::IsPositiveInfinite(Vfin))
     V2 = Precision::Infinite();
 
-  // creation de la generatrice : Generatrix
+  // creation of the generatrix : Generatrix
   Handle(Geom_Line) Ligne =
     new Geom_Line(gp_Pnt(start->Cylinder().Radius(), 0.0, 0.0), gp_Dir(0.0, 0.0, 1.0));
   GeomToIGES_GeomCurve        GC(*this);
@@ -687,7 +687,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   gp_Pnt                      gen2       = Ligne->Value(V2);
   TheLength                              = gen1.Distance(gen2);
 
-  // creation de l`axe : Axis .
+  // creation of the axis : Axis .
   Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
   // #30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
   // Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
@@ -695,8 +695,8 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   Axis->Init(gp_XYZ(0, 0, 1.), gp_XYZ(0, 0, 0));
   Surf->Init(Axis, Generatrix, 2 * M_PI - U2, 2 * M_PI - U1);
 
-  // creation de la Trsf (#124)
+  // creation of the Trsf (#124)
-  // il faut tenir compte de l`unite pour la matrice de transformation
+  // we must take into account the unit for the transformation matrix
   // (partie translation).
   IGESConvGeom_GeomBuilder Build;
   Standard_Real            xloc, yloc, zloc;
@@ -717,7 +717,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
 }
 
 //=============================================================================
-// Transfer des Entites ConicalSurface de Geom vers IGES
+// Transfer of ConicalSurface Entities from Geom to IGES
 // TransferSurface
 //=============================================================================
 
@@ -755,7 +755,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   if (Precision::IsPositiveInfinite(Vfin))
     V2 = Precision::Infinite();
 
-  // creation de la generatrice : Generatrix
+  // creation of the generatrix : Generatrix
   Handle(Geom_Line) Ligne =
     new Geom_Line(gp_Pnt(start->Cone().RefRadius(), 0.0, 0.0),
                   gp_Dir(sin(start->Cone().SemiAngle()), 0., cos(start->Cone().SemiAngle())));
@@ -766,7 +766,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   //  TheLength = gen1.Distance(gen2)*Cos(start->Cone().SemiAngle());
   TheLength = gen1.Distance(gen2);
 
-  // creation de l`axe : Axis .
+  // creation of the axis : Axis .
   Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
   // #30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
   // Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
@@ -774,8 +774,8 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   Axis->Init(gp_XYZ(0, 0, 1.), gp_XYZ(0, 0, 0));
   Surf->Init(Axis, Generatrix, 2 * M_PI - U2, 2 * M_PI - U1);
 
-  // creation de la Trsf (#124)
+  // creation of the Trsf (#124)
-  // il faut tenir compte de l`unite pour la matrice de transformation
+  // we must take into account the unit for the transformation matrix
   // (partie translation).
   IGESConvGeom_GeomBuilder Build;
   Standard_Real            xloc, yloc, zloc;
@@ -796,7 +796,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
 }
 
 //=============================================================================
-// Transfer des Entites SphericalSurface de Geom vers IGES
+// Transfer of SphericalSurface Entities from Geom to IGES
 // TransferSurface
 //=============================================================================
 
@@ -833,13 +833,13 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   Standard_Real V1 = Vdeb;
   Standard_Real V2 = Vfin;
 
-  // creation de la generatrice : Generatrix (1/2 cercle)
+  // creation of the generatrix : Generatrix (1/2 cercle)
   gp_Ax2                      Axe(gp::Origin(), -gp::DY(), gp::DX());
   Handle(Geom_Circle)         Cercle = new Geom_Circle(Axe, start->Sphere().Radius());
   GeomToIGES_GeomCurve        GC(*this);
   Handle(IGESData_IGESEntity) Gen = GC.TransferCurve(Cercle, V1, V2);
 
-  // creation de l`axe : Axis .
+  // creation of the axis : Axis .
   Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
   // #30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
   // Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
@@ -900,13 +900,13 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   Standard_Real                        V1   = Vdeb;
   Standard_Real                        V2   = Vfin;
 
-  // creation de la generatrice : Generatrix (cercle)
+  // creation of the generatrix : Generatrix (cercle)
   gp_Ax2 Axe = gp_Ax2(gp_Pnt((start->Torus().MajorRadius()), 0., 0.), -gp::DY(), gp::DX());
   Handle(Geom_Circle)         Cercle = new Geom_Circle(Axe, start->Torus().MinorRadius());
   GeomToIGES_GeomCurve        GC(*this);
   Handle(IGESData_IGESEntity) Gen = GC.TransferCurve(Cercle, V1, V2);
 
-  // creation de l`axe : Axis .
+  // creation of the axis : Axis .
   Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
   // #30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
   // Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
@@ -1014,7 +1014,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
 
   // dans IGES l'origine de la generatrice est identique a l'origine
   // de la directrice , il faut translater la courbe si les deux
-  // points ne sont pas confondus dans Geom et donc la copier !!!!!!!
+  // points are not coincident in Geom and therefore copy it !!!!!!!
   gp_Pnt        TheEnd = start->Value(U1, V2);
   Standard_Real Xe, Ye, Ze;
   TheEnd.Coord(Xe, Ye, Ze);
@@ -1085,7 +1085,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
   if (Precision::IsPositiveInfinite(Vfin))
     V2 = Precision::Infinite();
 
-  // creation de la generatrice : Generatrix
+  // creation of the generatrix : Generatrix
   Handle(Geom_Curve)          Curve = start->BasisCurve();
   GeomToIGES_GeomCurve        GC(*this);
   Handle(IGESData_IGESEntity) Generatrix = GC.TransferCurve(Curve, V1, V2);
@@ -1104,7 +1104,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
     TheLength   = gen1.Distance(gen2);
   }
 
-  // creation de l`axe : Axis .
+  // creation of the axis : Axis .
   Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
   gp_Ax1                Axe  = start->Axis();
   Standard_Real         X1, Y1, Z1, X2, Y2, Z2;
@@ -1170,7 +1170,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
 }
 
 //=============================================================================
-// Transfer des Entites Plane de Geom vers IGESSolid
+// Transfer of Plane Entities from Geom to IGESSolid
 // TransferPlaneSurface
 //=============================================================================
 

src/DataExchange/TKDEIGES/GeomToIGES/GeomToIGES_GeomVector.cxx

@@ -12,8 +12,8 @@
 // commercial license or contractual agreement.
 
 // modif du 14/09/95 mjm
-// prise en compte de l'unite choisi par l'utilisateur
+// taking into account the unit chosen by the user
-// pour l'ecriture du fichier IGES.
+// for writing the IGES file.
 
 #include <Geom_Direction.hxx>
 #include <Geom_Vector.hxx>
@@ -42,7 +42,7 @@ GeomToIGES_GeomVector::GeomToIGES_GeomVector(const GeomToIGES_GeomEntity& GE)
 }
 
 //=============================================================================
-// Transfer des Entites Vector de Geom vers IGES
+// Transfer of Vector Entities from Geom to IGES
 // TransferVector
 //=============================================================================
 
@@ -69,7 +69,7 @@ Handle(IGESGeom_Direction) GeomToIGES_GeomVector::TransferVector(const Handle(Ge
 }
 
 //=============================================================================
-// Transfer des Entites VectorWithMagnitude de Geom vers IGES
+// Transfer of VectorWithMagnitude Entities from Geom to IGES
 // TransferVector
 //=============================================================================
 
@@ -90,7 +90,7 @@ Handle(IGESGeom_Direction) GeomToIGES_GeomVector::TransferVector(
 }
 
 //=============================================================================
-// Transfer des Entites Direction de Geom vers IGES
+// Transfer of Direction Entities from Geom to IGES
 // TransferVector
 //=============================================================================
 

src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolDrilledHole.cxx

@@ -104,7 +104,7 @@ Standard_Boolean IGESAppli_ToolDrilledHole::OwnCorrect(
     Handle(IGESData_LevelListEntity) nulevel;
     ent->InitLevel(nulevel, 0);
     res = Standard_True;
-  } // NbPropertyvalues = 5 + RAZ level selon subordinate
+  } // NbPropertyvalues = 5 + RAZ level according to subordinate
   return res;
 }
 

src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolElementResults.cxx

@@ -473,8 +473,8 @@ void IGESAppli_ToolElementResults::OwnDump(const Handle(IGESAppli_ElementResults
   S << "\nResult Data Locations : ";
   S << " TO BE DONE  ";
 
-  //  ??  A VERIFIER DE PRES, pas du tout sur que ce soit bon
+  //  ??  TO VERIFY CLOSELY, not at all sure this is correct
-  //      cf aussi Write et Copy
+  //      see also Write and Copy
   if (level <= 4)
     S << " [ ask level > 4 for more, > 5 for complete ]\n";
   else

src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolLineWidening.cxx

@@ -108,7 +108,7 @@ Standard_Boolean IGESAppli_ToolLineWidening::OwnCorrect(
     ent->InitLevel(nulevel, 0);
     res = Standard_True;
   }
-  return res; // nbpropertyvalues = 5 + RAZ level selon subordinate
+  return res; // nbpropertyvalues = 5 + reset level according to subordinate
 }
 
 IGESData_DirChecker IGESAppli_ToolLineWidening::DirChecker(

src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolPinNumber.cxx

@@ -80,7 +80,7 @@ Standard_Boolean IGESAppli_ToolPinNumber::OwnCorrect(const Handle(IGESAppli_PinN
     Handle(IGESData_LevelListEntity) nulevel;
     ent->InitLevel(nulevel, 0);
   }
-  return res; // RAZ level selon subordibate
+  return res; // RAZ level according to subordinate
 }
 
 IGESData_DirChecker IGESAppli_ToolPinNumber::DirChecker(

src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolReferenceDesignator.cxx

@@ -89,7 +89,7 @@ Standard_Boolean IGESAppli_ToolReferenceDesignator::OwnCorrect(
     ent->InitLevel(nulevel, 0);
     res = Standard_True;
   }
-  return res; // + RAZ level selon subordibate
+  return res; // + RAZ level according to subordinate
 }
 
 IGESData_DirChecker IGESAppli_ToolReferenceDesignator::DirChecker(

src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolRegionRestriction.cxx

@@ -91,7 +91,7 @@ Standard_Boolean IGESAppli_ToolRegionRestriction::OwnCorrect(
     ent->InitLevel(nulevel, 0);
     res = Standard_True;
   }
-  return res; // + RAZ level selon subordibate
+  return res; // + reset level according to subordinate
 }
 
 IGESData_DirChecker IGESAppli_ToolRegionRestriction::DirChecker(

src/DataExchange/TKDEIGES/IGESBasic/IGESBasic_ExternalRefFileName.cxx

@@ -30,7 +30,7 @@ void IGESBasic_ExternalRefFileName::Init(const Handle(TCollection_HAsciiString)&
   theExtRefFileIdentifier = aFileIdent;
   theExtRefEntitySymbName = anExtName;
   InitTypeAndForm(416, FormNumber());
-  //  FormNumber 0-2 : sens pas clair. Pourrait etre 0:Definition  2:Entity
+  //  FormNumber 0-2 : meaning not clear. Could be 0:Definition  2:Entity
 }
 
 void IGESBasic_ExternalRefFileName::SetForEntity(const Standard_Boolean F)

src/DataExchange/TKDEIGES/IGESControl/IGESControl_ActorWrite.cxx

@@ -107,8 +107,8 @@ Handle(Transfer_Binder) IGESControl_ActorWrite::Transfer(const Handle(Transfer_F
     DeclareAndCast(Geom_Curve, Curve, geom);
     DeclareAndCast(Geom_Surface, Surf, geom);
 
-    //  On reconnait : Curve et Surface de Geom
+    //  We recognize: Curve and Surface from Geom
-    //   quid de Point; Geom2d ?
+    //   what about Point; Geom2d ?
 
     //  GeomToIGES_GeomPoint GP;
     GeomToIGES_GeomCurve GC;

src/DataExchange/TKDEIGES/IGESControl/IGESControl_Controller.cxx

@@ -92,7 +92,7 @@ IGESControl_Controller::IGESControl_Controller(const Standard_Boolean mod)
   flf->SetDefault(12);
   AddSessionItem(flf, "iges-float-digits-12", Standard_True);
 
-  //  --   Sender Product Identification   --  (pas un statique ...)
+  //  --   Sender Product Identification   --  (not a static ...)
   Handle(IGESSelect_SetGlobalParameter) set3 = new IGESSelect_SetGlobalParameter(3);
   Handle(TCollection_HAsciiString)      pa3 =
     Interface_Static::Static("write.iges.header.product")->HStringValue();
@@ -102,7 +102,7 @@ IGESControl_Controller::IGESControl_Controller(const Standard_Boolean mod)
 
   AddSessionItem(new IGESSelect_UpdateFileName, "iges-update-file-name", Standard_True);
 
-  //  --   Receiver   --   Acces par Static, ajustable
+  //  --   Receiver   --   Access by Static, adjustable
   Handle(IGESSelect_SetGlobalParameter) set12 = new IGESSelect_SetGlobalParameter(12);
   Handle(TCollection_HAsciiString)      pa12 =
     Interface_Static::Static("write.iges.header.receiver")->HStringValue();
@@ -110,7 +110,7 @@ IGESControl_Controller::IGESControl_Controller(const Standard_Boolean mod)
   AddSessionItem(pa12, "iges-header-val-receiver");
   AddSessionItem(set12, "iges-header-set-receiver", Standard_True);
 
-  //  --   Auteur   --   acces par Static (demarre par whoami), ajustable
+  //  --   Author   --   access by Static (started by whoami), adjustable
   Handle(IGESSelect_SetGlobalParameter) set21 = new IGESSelect_SetGlobalParameter(21);
   Handle(TCollection_HAsciiString)      pa21 =
     Interface_Static::Static("write.iges.header.author")->HStringValue();
@@ -118,7 +118,7 @@ IGESControl_Controller::IGESControl_Controller(const Standard_Boolean mod)
   AddSessionItem(pa21, "iges-header-val-author");
   AddSessionItem(set21, "iges-header-set-author", Standard_True);
 
-  //  --   Compagnie (de l auteur)   --   acces par Static, ajustable
+  //  --   Company (of the author)   --   access by Static, adjustable
   Handle(IGESSelect_SetGlobalParameter) set22 = new IGESSelect_SetGlobalParameter(22);
   Handle(TCollection_HAsciiString)      pa22 =
     Interface_Static::Static("write.iges.header.company")->HStringValue();
@@ -301,7 +301,7 @@ void IGESControl_Controller::Customise(Handle(XSControl_WorkSession)& WS)
 
 Handle(Interface_InterfaceModel) IGESControl_Controller::NewModel() const
 {
-  //  On prend un modele qu on prepare avec les statiques enregistres
+  //  We take a model that we prepare with registered statics
   DeclareAndCast(IGESData_IGESModel, igm, Interface_InterfaceModel::Template("iges"));
   IGESData_GlobalSection GS = igm->GlobalSection();
 
@@ -332,8 +332,8 @@ Handle(Transfer_ActorOfTransientProcess) IGESControl_Controller::ActorRead(
   return myAdaptorRead;
 }
 
-//  ####    TRANSFERT (ECRITURE SHAPE)    ####
+//  ####    TRANSFER (SHAPE WRITING)    ####
-//  modetrans : 0  <5.1 (groupe de faces),  1 BREP-5.1
+//  modetrans : 0  <5.1 (group of faces),  1 BREP-5.1
 
 //=================================================================================================
 

src/DataExchange/TKDEIGES/IGESControl/IGESControl_Reader.cxx

@@ -105,7 +105,7 @@ Standard_Integer IGESControl_Reader::NbRootsForTransfer()
     Handle(IGESData_IGESEntity) ent = model->Entity(i);
     if (SH.IsShared(ent) || !actor->Recognize(ent))
       continue;
-    // on ajoute un traitement pour ne prendre que les entites visibles
+    // add processing to take only visible entities
     if (!theReadOnlyVisible || ent->BlankStatus() == 0)
     {
       theroots.Append(ent);
@@ -115,7 +115,7 @@ Standard_Integer IGESControl_Reader::NbRootsForTransfer()
   return theroots.Length();
 }
 
-//  ####    Reliquat de methodes a reprendre    ####
+//  ####    Remainder of methods to be reworked    ####
 
 //=======================================================================
 // Function : PrintTransferInfo

src/DataExchange/TKDEIGES/IGESControl/IGESControl_Writer.cxx

@@ -186,8 +186,8 @@ Standard_Boolean IGESControl_Writer::AddGeom(const Handle(Standard_Transient)& g
   DeclareAndCast(Geom_Surface, Surf, geom);
   Handle(IGESData_IGESEntity) ent;
 
-  //  On reconnait : Curve et Surface de Geom
+  //  We recognize: Curve and Surface from Geom
-  //   quid de Point; Geom2d ?
+  //   what about Point; Geom2d ?
 
   //  GeomToIGES_GeomPoint GP;
   GeomToIGES_GeomCurve GC;
@@ -254,7 +254,7 @@ Standard_Boolean IGESControl_Writer::Write(Standard_OStream& S, const Standard_B
   if (!nbEnt)
     return Standard_False;
   IGESData_IGESWriter IW(myModel);
-  //  ne pas oublier le mode fnes ... a transmettre a IW
+  //  do not forget the fnes mode ... to transmit to IW
   IW.SendModel(IGESSelect_WorkLibrary::DefineProtocol());
   if (fnes)
     IW.WriteMode() = 10;

src/DataExchange/TKDEIGES/IGESConvGeom/IGESConvGeom.cxx

@@ -41,12 +41,12 @@ Standard_Integer IGESConvGeom::SplineCurveFromIGES(const Handle(IGESGeom_SplineC
 {
   Standard_Integer returned = 0;
 
-  // on recupere le degre
+  // we retrieve the degree
   Standard_Integer degree = st->SplineType();
   if (degree > 3)
     degree = 3;
 
-  // on recupere le nombre de segments.
+  // we retrieve the number of segments.
   Standard_Integer nbSegs = st->NbSegments();
   if (nbSegs < 1)
     return 5; // FAIL : no segment
@@ -71,8 +71,8 @@ Standard_Integer IGESConvGeom::SplineCurveFromIGES(const Handle(IGESGeom_SplineC
 
   TColgp_Array1OfPnt bspoles(1, nbSegs * degree + 1);
   Standard_Integer   ibspole = bspoles.Lower() - 1; // Bspole Index.
-  // il faut reparametrer avant de passer dans PLib.
+  // we need to reparameterize before passing to PLib.
-  // on est entre[0, T(i+1)-T(i)] et on veut [0,1]
+  // we are between [0, T(i+1)-T(i)] and we want [0,1]
 
   for (i = 1; i <= nbSegs; i++)
   {

src/DataExchange/TKDEIGES/IGESConvGeom/IGESConvGeom_GeomBuilder.cxx

@@ -78,7 +78,7 @@ Handle(IGESGeom_CopiousData) IGESConvGeom_GeomBuilder::MakeCopiousData(
   if (datatype < 1 || datatype > 3 || nb == 0 || (polyline && datatype == 3))
     throw Standard_DomainError("IGESConvGeom_GeomBuilder : MakeCopiousData");
 
-  Standard_Integer nbd = datatype + 1; // 1->2  2->3   et   3->6
+  Standard_Integer nbd = datatype + 1; // 1->2  2->3   and   3->6
   if (datatype == 3)
     nbd = 6;
   Handle(TColStd_HArray1OfReal) data = new TColStd_HArray1OfReal(1, nb * nbd);
@@ -144,7 +144,7 @@ Standard_Boolean IGESConvGeom_GeomBuilder::IsIdentity() const
 {
   if (thepos.Form() == gp_Identity)
     return Standard_True;
-  //   sinon, regarder de plus pres  ...
+  //   otherwise, look more closely  ...
   if (!IsTranslation())
     return Standard_False;
   if (!thepos.TranslationPart().IsEqual(gp_XYZ(0., 0., 0.), epsl))
@@ -156,7 +156,7 @@ Standard_Boolean IGESConvGeom_GeomBuilder::IsTranslation() const
 {
   if (thepos.Form() == gp_Identity || thepos.Form() == gp_Translation)
     return Standard_True;
-  //   sinon, regarder de plus pres  ...
+  //   otherwise, look more closely  ...
 
   Standard_Integer i, j;
   for (i = 1; i <= 3; i++)

src/DataExchange/TKDEIGES/IGESData/IGESData.cxx

@@ -39,7 +39,7 @@ void IGESData::Init()
     stmod = new IGESData_DefaultGeneral;
   if (speci.IsNull())
     speci = new IGESData_DefaultSpecific;
-  //  et modele template "iges"
+  //  and template model "iges"
   if (Interface_InterfaceModel::HasTemplate("iges"))
     return;
 
@@ -206,9 +206,9 @@ void IGESData::Init()
       (host.SystemVersion().ToCString());
   #endif
 
-  //  SendName : nom significatif de la piece transmise par exemple
+  //  SendName : significant name of the transmitted part for example
-  //  SystemId : c est MDTV etc
+  //  SystemId : it is MDTV etc
-  //  InterfaceVersion : la version en cours de XSTEP; incluant la plateforme
+  //  InterfaceVersion : the current version of XSTEP; including the platform
 
     char nomsys[100]; int istat; long lstat;
     struct utsname infosy;
@@ -261,7 +261,7 @@ void IGESData::Init()
   //  new TCollection_HAsciiString (process.UserName());
   GS.SetCompanyName(Interface_Static::Static("write.iges.header.company")->HStringValue());
   //  new TCollection_HAsciiString("Matra Datavision");
-  GS.SetIGESVersion(11); // pour IGES-5.3 //gka 19.01.99
+  GS.SetIGESVersion(11); // for IGES-5.3 //gka 19.01.99
   GS.SetDraftingStandard(0);
   GS.SetLastChangeDate(datestr);
   GS.SetApplicationProtocol(new TCollection_HAsciiString("")); // gka 19.01.99

src/DataExchange/TKDEIGES/IGESData/IGESData_BasicEditor.cxx

@@ -69,7 +69,7 @@ Handle(IGESData_IGESModel) IGESData_BasicEditor::Model() const
   return themodel;
 }
 
-// ####   Travaux sur le Header (GlobalSection)    ####
+// ####   Work on the Header (GlobalSection)    ####
 
 Standard_Boolean IGESData_BasicEditor::SetUnitFlag(const Standard_Integer flag)
 {
@@ -96,7 +96,7 @@ Standard_Boolean IGESData_BasicEditor::SetUnitValue(const Standard_Real val)
   Standard_Real vmm = val * themodel->GlobalSection().CascadeUnit();
   // #73 rln 10.03.99 S4135: "read.scale.unit" does not affect GlobalSection
   // if (Interface_Static::IVal("read.scale.unit") == 1) vmm = vmm * 1000.;
-  // vmm est exprime en MILLIMETRES
+  // vmm is expressed in MILLIMETERS
   Standard_Integer aFlag = GetFlagByValue(vmm);
   return (aFlag > 0) ? SetUnitFlag(aFlag) : Standard_False;
 }
@@ -170,7 +170,7 @@ void IGESData_BasicEditor::ApplyUnit(const Standard_Boolean enforce)
   theunit = Standard_False;
 }
 
-// ####   Travaux globaux sur les entites    ####
+// ####   Global work on entities    ####
 
 void IGESData_BasicEditor::ComputeStatus()
 {
@@ -184,34 +184,34 @@ void IGESData_BasicEditor::ComputeStatus()
   Interface_Graph G(themodel, theglib); // gere & memorise UseFlag
   G.ResetStatus();
 
-  //  2 phases : d abord on fait un calcul d ensemble. Ensuite on applique
+  //  2 phases : first we do an overall calculation. Then we apply
-  //             Tout le modele est traite, pas de jaloux
+  //             The whole model is processed, no favorites
 
-  //  Chaque entite va donner une contribution sur ses descendents propres :
+  //  Each entity will give a contribution on its own descendants :
-  //  pour Subordinate (1 ou 2 cumulables), pour UseFlag (1 a 6 exclusifs)
+  //  for Subordinate (1 or 2 cumulative), for UseFlag (1 to 6 exclusive)
-  //    (6 depuis IGES-5.2)
+  //    (6 since IGES-5.2)
 
-  //  Pour Subordinate : Drawing et 402 (sauf p-e dimensioned geometry ?) donnent
+  //  For Subordinate : Drawing and 402 (except maybe dimensioned geometry ?) give
-  //   Logical, le reste implique Physical (sur descendants directs propres)
+  //   Logical, the rest implies Physical (on direct descendants)
 
-  //  Pour UseFlag, un peu plus complique :
+  //  For UseFlag, a bit more complicated :
-  //  D une part, les UseFlag se propagent aux descendants directs ou non
+  //  On one hand, UseFlags propagate to direct descendants or not
-  //  D autre part les cas sont plus compliques (et pas aussi clairs)
+  //  On the other hand cases are more complicated (and not as clear)
 
-  //  ATTENTION, on ne peut traiter que ce qui se deduit du graphe en s appuyant
+  //  WARNING, we can only process what can be deduced from the graph by relying
-  //  sur les "IGES Type Number", on n a pas le droit ici d acceder a la
+  //  on "IGES Type Number", we don't have the right here to access the
-  //  description specifique des differents types : traites par AutoCorrect.
+  //  specific description of different types : handled by AutoCorrect.
-  //  Exemple : une courbe est 3D ou parametrique 2D(UV), non seulement selon son
+  //  Example : a curve is 3D or parametric 2D(UV), not only according to its
-  //  ascendant, mais selon le role qu elle y joue (ex. pour CurveOnSurface :
+  //  ancestor, but according to the role it plays there (ex. for CurveOnSurface :
   //  CurveUV/Curve3D)
-  //  Traites actuellement (necessaires) :
+  //  Currently handled (necessary) :
-  //  1(Annotation), aussi 4(pour maillage). 5(ParamUV) traite par AutoCorrect
+  //  1(Annotation), also 4(for meshing). 5(ParamUV) handled by AutoCorrect
 
   Standard_Integer CN;
   Standard_Integer i; // svv Jan11 2000 : porting on DEC
   for (i = 1; i <= nb; i++)
   {
-    //  Subordinate (sur directs en propre seulement)
+    //  Subordinate (on direct descendants only)
     Handle(IGESData_IGESEntity)     ent = themodel->Entity(i);
     Standard_Integer                igt = ent->TypeNumber();
     Handle(Interface_GeneralModule) gmodule;
@@ -241,7 +241,7 @@ void IGESData_BasicEditor::ComputeStatus()
       Interface_EntityIterator sh = G.Sharings(ent); // Maillage ...
       if (sh.NbEntities() > 0)
         G.GetFromEntity(ent, Standard_True, 4);
-      //  UV : voir AutoCorrect des classes concernees (Boundary et CurveOnSurface)
+      //  UV : see AutoCorrect of concerned classes (Boundary and CurveOnSurface)
       /*
           } else if (ent->IsKind(STANDARD_TYPE(IGESGeom_CurveOnSurface))) {
             DeclareAndCast(IGESGeom_CurveOnSurface,cos,ent);    // Curve UV
@@ -258,8 +258,8 @@ void IGESData_BasicEditor::ComputeStatus()
     }
   }
 
-  //  A present, on va appliquer tout cela "de force"
+  //  Now, we will apply all this "by force"
-  //  Seule exception : des UseFlags non nuls deja en place sont laisses
+  //  Only exception: non-zero UseFlags already in place are left
 
   for (i = 1; i <= nb; i++)
   {
@@ -289,9 +289,9 @@ Standard_Boolean IGESData_BasicEditor::AutoCorrect(const Handle(IGESData_IGESEnt
   Standard_Boolean done = Standard_False;
   if (ent.IsNull())
     return done;
-  //    Corrections dans l entete (entites presentes)
+  //    Corrections in the header (present entities)
-  //    On ne verifie pas les items "Shared", presents de toute facon
+  //    We don't check "Shared" items, present anyway
-  //    Entete : traite par DirChecker pour les cas standard
+  //    Header : handled by DirChecker for standard cases
   /*
     linefont = ent->LineFont();
     if (!linefont.IsNull() && themodel->Number(linefont) == 0) {
@@ -331,7 +331,7 @@ Standard_Boolean IGESData_BasicEditor::AutoCorrect(const Handle(IGESData_IGESEnt
     }
   */
 
-  //    Corrections dans les Assocs (les Props restent attachees a l Entite)
+  //    Corrections in Assocs (Props remain attached to the Entity)
   Interface_EntityIterator iter = ent->Associativities();
   for (iter.Start(); iter.More(); iter.Next())
   {

src/DataExchange/TKDEIGES/IGESData/IGESData_ColorEntity.cxx

@@ -16,4 +16,4 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(IGESData_ColorEntity, IGESData_IGESEntity)
 
-// ColorEntity ne sert qu'au controle de type (entite Color du directory part)
+// ColorEntity is only used for type control (Color entity of the directory part)

src/DataExchange/TKDEIGES/IGESData/IGESData_DefSwitch.cxx

@@ -13,9 +13,9 @@
 
 #include <IGESData_DefSwitch.hxx>
 
-//  DefSwitch : represente une definition, soit vide (-> valeur = 0),
+//  DefSwitch : represents a definition, either empty (-> value = 0),
-//  soit comme rang dans une table (-> valeur > 0 ce rang),
+//  or as rank in a table (-> value > 0 this rank),
-//  soit comme reference (-> valeur < 0), la reference elle-meme est ailleurs
+//  or as reference (-> value < 0), the reference itself is elsewhere
 
 //=================================================================================================
 

src/DataExchange/TKDEIGES/IGESData/IGESData_DefaultGeneral.cxx

@@ -58,14 +58,14 @@ IGESData_DirChecker IGESData_DefaultGeneral::DirChecker(const Standard_Integer,
 {
   IGESData_DirChecker dc;
   return dc;
-} // aucun critere specifique
+} // no specific criteria
 
 void IGESData_DefaultGeneral::OwnCheckCase(const Standard_Integer,
                                            const Handle(IGESData_IGESEntity)&,
                                            const Interface_ShareTool&,
                                            Handle(Interface_Check)&) const
 {
-} // aucun critere specifique
+} // no specific criteria
 
 Standard_Boolean IGESData_DefaultGeneral::NewVoid(const Standard_Integer      CN,
                                                   Handle(Standard_Transient)& entto) const
@@ -89,12 +89,12 @@ void IGESData_DefaultGeneral::OwnCopyCase(const Standard_Integer             CN,
     return;
   DeclareAndCast(IGESData_UndefinedEntity, enfr, entfrom);
   DeclareAndCast(IGESData_UndefinedEntity, ento, entto);
-  //  ShallowCopy aura passe DirStatus
+  //  ShallowCopy will have passed DirStatus
-  //  transmettre les contenus des UndefinedContents
+  //  transmit the contents of UndefinedContents
   Handle(Interface_UndefinedContent) cont = new Interface_UndefinedContent;
   cont->GetFromAnother(enfr->UndefinedContent(), TC);
   ento->SetNewContent(cont);
-  //  FreeFormat, encore des choses
+  //  FreeFormat, more things
   if (enfr->IsKind(STANDARD_TYPE(IGESData_FreeFormatEntity)))
   {
     DeclareAndCast(IGESData_FreeFormatEntity, enf, entfrom);

src/DataExchange/TKDEIGES/IGESData/IGESData_DirChecker.cxx

@@ -23,17 +23,17 @@
 
 #include <stdio.h>
 
-//  Pour Correct :
+//  For Correct :
 // MGE 23/07/98
-// Chaque critere est par defaut inhibe
+// Each criterion is inhibited by default
 //=================================================================================================
 
 IGESData_DirChecker::IGESData_DirChecker()
 {
   thetype = theform1 = theform2 = 0;
   thestructure = thelinefont = thelineweig = thecolor = IGESData_ErrorRef;
-  thegraphier                                         = -100; // ne pas tester GraphicsIgnored
+  thegraphier                                         = -100; // do not test GraphicsIgnored
-  theblankst = thesubordst = theuseflag = thehierst = -100;   // ne pas tester
+  theblankst = thesubordst = theuseflag = thehierst = -100;   // do not test
 }
 
 //=================================================================================================
@@ -42,10 +42,10 @@ IGESData_DirChecker::IGESData_DirChecker(const Standard_Integer atype)
 {
   thetype      = atype;
   theform1     = 0;
-  theform2     = -1; // test de forme inhibe
+  theform2     = -1; // form test inhibited
   thestructure = thelinefont = thelineweig = thecolor = IGESData_ErrorRef;
-  thegraphier                                         = -100; // ne pas tester GraphicsIgnored
+  thegraphier                                         = -100; // do not test GraphicsIgnored
-  theblankst = thesubordst = theuseflag = thehierst = -100;   // ne pas tester
+  theblankst = thesubordst = theuseflag = thehierst = -100;   // do not test
 }
 
 //=================================================================================================
@@ -53,10 +53,10 @@ IGESData_DirChecker::IGESData_DirChecker(const Standard_Integer atype)
 IGESData_DirChecker::IGESData_DirChecker(const Standard_Integer atype, const Standard_Integer aform)
 {
   thetype  = atype;
-  theform1 = theform2 = aform; // forme : valeur requise
+  theform1 = theform2 = aform; // form : required value
   thestructure = thelinefont = thelineweig = thecolor = IGESData_ErrorRef;
-  thegraphier                                         = -100; // ne pas tester GraphicsIgnored
+  thegraphier                                         = -100; // do not test GraphicsIgnored
-  theblankst = thesubordst = theuseflag = thehierst = -100;   // ne pas tester
+  theblankst = thesubordst = theuseflag = thehierst = -100;   // do not test
 }
 
 //=================================================================================================
@@ -67,10 +67,10 @@ IGESData_DirChecker::IGESData_DirChecker(const Standard_Integer atype,
 {
   thetype      = atype;
   theform1     = aform1;
-  theform2     = aform2; // forme : [...]
+  theform2     = aform2; // form : [...]
   thestructure = thelinefont = thelineweig = thecolor = IGESData_ErrorRef;
-  thegraphier                                         = -100; // ne pas tester GraphicsIgnored
+  thegraphier                                         = -100; // do not test GraphicsIgnored
-  theblankst = thesubordst = theuseflag = thehierst = -100;   // ne pas tester
+  theblankst = thesubordst = theuseflag = thehierst = -100;   // do not test
 }
 
 //=================================================================================================
@@ -85,7 +85,7 @@ Standard_Boolean IGESData_DirChecker::IsSet() const
 void IGESData_DirChecker::SetDefault()
 {
   Structure(IGESData_DefVoid);
-} // Option par defaut
+} // Default option
 
 //=================================================================================================
 
@@ -377,14 +377,14 @@ Standard_Boolean IGESData_DirChecker::Correct(const Handle(IGESData_IGESEntity)&
     }
   }
 
-  Handle(IGESData_IGESEntity) structure; // par defaut Nulle
+  Handle(IGESData_IGESEntity) structure; // by default Null
   if (thestructure != IGESData_DefVoid)
     structure = ent->Structure();
   Handle(IGESData_ViewKindEntity)     nulview;
   Handle(IGESData_LineFontEntity)     nulfont;
   Handle(IGESData_LevelListEntity)    nulevel;
   Handle(IGESData_ColorEntity)        nulcolor;
-  Handle(IGESData_LabelDisplayEntity) label; // par defaut Nulle
+  Handle(IGESData_LabelDisplayEntity) label; // by default Null
   if (thegraphier != -1)
     label = ent->LabelDisplay();
   Standard_Integer linew = 0;

src/DataExchange/TKDEIGES/IGESData/IGESData_DirPart.cxx

@@ -69,7 +69,7 @@ void IGESData_DirPart::Init(const Standard_Integer i1,
   thesubs[8] = '\0';
 }
 
-//   CString : on modifie leur CONTENU, pas le POINTEUR LUI-MEME
+//   CString : we modify their CONTENT, not the POINTER ITSELF
 
 //=================================================================================================
 

src/DataExchange/TKDEIGES/IGESData/IGESData_FreeFormatEntity.cxx

@@ -21,8 +21,8 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(IGESData_FreeFormatEntity, IGESData_UndefinedEntity)
 
-//  Donne un acces simple a la constitution d une UndefinedEntity :
+//  Provides simple access to the constitution of an UndefinedEntity :
-//  Methodes de UndefinedContent, + Type & Form, + AddEntities (little gadget)
+//  Methods of UndefinedContent, + Type & Form, + AddEntities (little gadget)
 IGESData_FreeFormatEntity::IGESData_FreeFormatEntity() {}
 
 void IGESData_FreeFormatEntity::SetTypeNumber(const Standard_Integer typenum)
@@ -140,7 +140,7 @@ void IGESData_FreeFormatEntity::ClearNegativePointers()
 
 void IGESData_FreeFormatEntity::WriteOwnParams(IGESData_IGESWriter& IW) const
 {
-  //  Redefini de UndefinedEntity pour : NegativePointers
+  //  Redefined from UndefinedEntity for : NegativePointers
   Standard_Integer neg  = 0;
   Standard_Integer fneg = 0;
   if (!thenegptrs.IsNull())

src/DataExchange/TKDEIGES/IGESData/IGESData_GeneralModule.cxx

@@ -74,7 +74,7 @@ void IGESData_GeneralModule::OwnImpliedCase(const Standard_Integer,
                                             const Handle(IGESData_IGESEntity)&,
                                             Interface_EntityIterator&) const
 {
-} // par defaut, rien  (redefinissable)
+} // by default, nothing (redefinable)
 
 void IGESData_GeneralModule::CheckCase(const Standard_Integer            CN,
                                        const Handle(Standard_Transient)& ent,
@@ -103,7 +103,7 @@ void IGESData_GeneralModule::CopyCase(const Standard_Integer            CN,
   DeclareAndCast(IGESData_IGESEntity, enfr, entfrom);
   ////  ento->Clear();
 
-  // ...                Reprendre entete                ...
+  // ...                Resume header                ...
   //?  ento->InitTypeAndForm (enfr->TypeNumber(), enfr->FormNumber());ShallowCopy
 
   if (enfr->DefLineFont() == IGESData_DefReference)
@@ -206,7 +206,7 @@ void IGESData_GeneralModule::WhenDeleteCase(const Standard_Integer            CN
 void IGESData_GeneralModule::OwnDeleteCase(const Standard_Integer,
                                            const Handle(IGESData_IGESEntity)&) const
 {
-} // par defaut, rien  (redefinissable)
+} // by default, nothing (redefinable)
 
 Handle(TCollection_HAsciiString) IGESData_GeneralModule::Name(const Standard_Integer,
                                                               const Handle(Standard_Transient)& ent,

src/DataExchange/TKDEIGES/IGESData/IGESData_GlobalSection.cxx

@@ -30,13 +30,13 @@
 
 #include <stdio.h>
 
-//  Routines locales copiant une string [l`ideal serait : astr = astr->Copy()]
+//  Local routines copying a string [the ideal would be : astr = astr->Copy()]
-//    et transformant un CString (Hollerith ou non) en HAsciiString non Holl.
+//    and transforming a CString (Hollerith or not) to non-Hollerith HAsciiString.
-//    et l inverse
+//    and the reverse
 static void CopyString(Handle(TCollection_HAsciiString)& astr)
 {
   if (astr.IsNull())
-    return; // ne rien faire si String pas definie !
+    return; // do nothing if String not defined !
   Handle(TCollection_HAsciiString) S = new TCollection_HAsciiString("");
   S->AssignCat(astr);
   astr = S;
@@ -66,7 +66,7 @@ static void MakeHollerith(const Handle(TCollection_HAsciiString)& astr,
 IGESData_GlobalSection::IGESData_GlobalSection()
     : theSeparator(','),
       theEndMark(';'),
-      theIntegerBits(32), // simple = entier = 32b, double = 64
+      theIntegerBits(32), // simple = integer = 32b, double = 64
       theMaxPower10Single(38),
       theMaxDigitsSingle(6),
       theMaxPower10Double(308),
@@ -127,7 +127,7 @@ void IGESData_GlobalSection::Init(const Handle(Interface_ParamSet)& params,
   theFileName.Nullify();
   theSystemId.Nullify();
   theInterfaceVersion.Nullify();
-  theIntegerBits      = 32; // par defaut, simple = entier = 32b, double = 64
+  theIntegerBits      = 32; // by default, simple = integer = 32b, double = 64
   theMaxPower10Single = 38;
   theMaxDigitsSingle  = 6;
   theMaxPower10Double = 308;
@@ -149,8 +149,8 @@ void IGESData_GlobalSection::Init(const Handle(Interface_ParamSet)& params,
   // clang-format on
   theDraftingStandard = 0;
   theCascadeUnit      = UnitsMethods::GetCasCadeLengthUnit();
-  theLastChangeDate.Nullify(); // nouveaute 5.1 (peut etre absente)
+  theLastChangeDate.Nullify(); // new in 5.1 (may be absent)
-  theAppliProtocol.Nullify();  // nouveaute 5.3 (peut etre absente)
+  theAppliProtocol.Nullify();  // new in 5.3 (may be absent)
 
   Standard_Integer nbp = params->NbParams();
 

src/DataExchange/TKDEIGES/IGESData/IGESData_IGESDumper.cxx

@@ -38,7 +38,7 @@ IGESData_IGESDumper::IGESData_IGESDumper(const Handle(IGESData_IGESModel)& model
 void IGESData_IGESDumper::PrintDNum(const Handle(IGESData_IGESEntity)& ent,
                                     Standard_OStream&                  S) const
 {
-  //   Affichage garanti sur  12 caracteres 12345/D24689
+  //   Display guaranteed on 12 characters 12345/D24689
   Standard_Integer num = 0;
   if (!ent.IsNull())
   {
@@ -239,7 +239,7 @@ void IGESData_IGESDumper::Dump(const Handle(IGESData_IGESEntity)& ent,
     }
   }
 
-  //   Donnees attachees : Properties, Associativities, et Sharings
+  //   Attached data : Properties, Associativities, and Sharings
   if (att < 0)
     return;
   Interface_EntityIterator iter   = ent->Properties();

src/DataExchange/TKDEIGES/IGESData/IGESData_IGESEntity.cxx

@@ -66,7 +66,7 @@ IGESData_IGESEntity::IGESData_IGESEntity()
 
 void IGESData_IGESEntity::Clear()
 {
-  //  Handle et DefSwitch
+  //  Handle and DefSwitch
   theStructure.Nullify();
   theDefLineFont.SetVoid();
   theLineFont.Nullify();
@@ -222,8 +222,8 @@ Handle(IGESData_LabelDisplayEntity) IGESData_IGESEntity::LabelDisplay() const
   return GetCasted(IGESData_LabelDisplayEntity, theLabDisplay);
 }
 
-// Status : un Integer pour BlankStatus,SubrodinateStatus,USeFlag,HierarchySt.
+// Status : an Integer for BlankStatus,SubordinateStatus,UseFlag,HierarchySt.
-// Decoupage : 4 bits chacun (BlankStatus tout a droite, etc)
+// Division : 4 bits each (BlankStatus on the right, etc)
 
 Standard_Integer IGESData_IGESEntity::BlankStatus() const
 {
@@ -446,7 +446,7 @@ gp_GTrsf IGESData_IGESEntity::VectorLocation() const
 {
   if (!HasTransf())
     return gp_GTrsf();               // Identite
-                                     //    Prendre Location et anuler TranslationPart
+                                     //    Take Location and cancel TranslationPart
   gp_GTrsf loca = Transf()->Value(); // c-a-d Compoound
   loca.SetTranslationPart(gp_XYZ(0., 0., 0.));
   return loca;

src/DataExchange/TKDEIGES/IGESData/IGESData_IGESModel.cxx

@@ -32,7 +32,7 @@ IMPLEMENT_STANDARD_RTTIEXT(IGESData_IGESModel, Interface_InterfaceModel)
 
 static Standard_CString voidline = "";
 
-// Routine interne utilisee pour VerifyCheck
+// Internal routine used for VerifyCheck
 void IGESData_VerifyDate(const Handle(TCollection_HAsciiString)& str,
                          Handle(Interface_Check)&                ach,
                          const Standard_CString                  mess);
@@ -396,7 +396,7 @@ void IGESData_IGESModel::VerifyCheck(Handle(Interface_Check)& ach) const
     ach->SendFail(Msg48);
   }
 
-  // ..  verifie-t-on UnitName en accord avec UnitFlag ?
+  // ..  should we verify UnitName in accordance with UnitFlag ?
   if (theheader.UnitName().IsNull())
   {
     // Sending of message : Unit Name parameter is undefined.
@@ -465,7 +465,7 @@ void IGESData_IGESModel::VerifyCheck(Handle(Interface_Check)& ach) const
     Message_Msg Msg52("XSTEP_52");
     ach->SendFail(Msg52);
   }
-  // ..  comment verifier les coordonnees max ?
+  // ..  how to verify the max coordinates ?
 
   // Sending of message : Version Flag parameter is incorrect.
   if (theheader.IGESVersion() < 1
@@ -506,7 +506,7 @@ void IGESData_VerifyDate(const Handle(TCollection_HAsciiString)& str,
   Message_Msg Msg57("XSTEP_57");
   // =====================================
 
-  //  Attention c est du Hollerith
+  //  Warning this is Hollerith format
   if (str.IsNull())
   {
     ach->SendFail(Msg57);

src/DataExchange/TKDEIGES/IGESData/IGESData_IGESReaderData.cxx

@@ -108,7 +108,7 @@ void IGESData_IGESReaderData::SetDirPart(const Standard_Integer num,
           res2,
           label,
           subs);
-  ////  thedirs(num) = DP;  // verifier si utile
+  ////  thedirs(num) = DP;  // check if useful
   // InitParams(num); gka optimization memory
 }
 
@@ -181,18 +181,18 @@ Standard_Integer IGESData_IGESReaderData::FindNextRecord(const Standard_Integer
     return (num + 1);
 }
 
-// Reference a d'autres entites : c'est a la fois tres simple et problematique
+// Reference to other entities: this is both very simple and problematic
-// Tres simple : une reference a une entite est un numero (dans directory list)
+// Very simple: a reference to an entity is a number (in directory list)
-// qui vaut (2*N-1) si N est le rang vrai de l'entite
+// which equals (2*N-1) if N is the true rank of the entity
-// Problematique : ce numero est un Entier ... rien ne le distingue d'un autre
+// Problematic: this number is an Integer... nothing distinguishes it from another
-// D'ou critere : tout entier impair inferieur a 2*NbRecords PEUT etre une
+// Hence criterion: any odd integer less than 2*NbRecords CAN be a
-// reference ... C'est a chaque entite de faire ensuite son tri ...
+// reference... It's up to each entity to sort it out afterwards...
-//  Attention, une reference peut etre donnee en "Pointeur Negatif"
+//  Attention, a reference can be given as "Negative Pointer"
-// N.B.: DirPart non concernes (lecture specifique assuree par IGESEntity)
+// N.B.: DirPart not concerned (specific reading ensured by IGESEntity)
 
 void IGESData_IGESReaderData::SetEntityNumbers()
 {
-  //   On essaie de se baser uniquement sur calcul de IGESRead
+  //   We try to rely solely on IGESRead calculation
   /*
     Standard_Integer nbd = thedirs.Upper();
     for (Standard_Integer i = 1; i <= nbd; i ++) {

src/DataExchange/TKDEIGES/IGESData/IGESData_IGESReaderTool.cxx

@@ -82,9 +82,9 @@ Standard_Boolean IGESData_IGESReaderTool::Recognize(const Standard_Integer
 }
 
 //  ###########################################################################
-//  ########                LECTURE  (Controle General)                ########
+//  ########                READING  (General Control)                ########
 
-//    (Elements enchaines par la classe de base Interface_FileReaderTool)
+//    (Elements chained by the base class Interface_FileReaderTool)
 
 void IGESData_IGESReaderTool::BeginRead(const Handle(Interface_InterfaceModel)& amodel)
 {
@@ -106,7 +106,7 @@ void IGESData_IGESReaderTool::BeginRead(const Handle(Interface_InterfaceModel)&
   thedefweight = igesdat->DefaultLineWeight();
 }
 
-// Manquent les procedures de reprise sur erreur en cours de route ...
+// Missing error recovery procedures during the process ...
 Standard_Boolean IGESData_IGESReaderTool::AnalyseRecord(const Standard_Integer            num,
                                                         const Handle(Standard_Transient)& anent,
                                                         Handle(Interface_Check)&          ach)
@@ -117,29 +117,29 @@ Standard_Boolean IGESData_IGESReaderTool::AnalyseRecord(const Standard_Integer
   DeclareAndCast(IGESData_IGESEntity, ent, anent);
   DeclareAndCast(IGESData_IGESReaderData, igesdat, Data());
 
-  //  Demarrage de la lecture : Faire Clear
+  //  Start of reading : Do Clear
   ent->Clear();
 
-  //  UndefinedEntity : une pre-analyse est faite
+  //  UndefinedEntity : a pre-analysis is done
   DeclareAndCast(IGESData_UndefinedEntity, undent, ent);
   if (!undent.IsNull())
   {
-    IGESData_DirPart DP = igesdat->DirPart(num); // qui le copie ...
+    IGESData_DirPart DP = igesdat->DirPart(num); // which copies it ...
-    undent->ReadDir(igesdat, DP, ach);           // DP a pu etre modifie
+    undent->ReadDir(igesdat, DP, ach);           // DP may have been modified
-    ReadDir(ent, igesdat, DP, ach);              // Lecture avec ce DP
+    ReadDir(ent, igesdat, DP, ach);              // Reading with this DP
   }
   else
     ReadDir(ent, igesdat, igesdat->DirPart(num), ach);
 
   thestep = IGESData_ReadDir;
 
-  //   Liste de Parametres : controle de son entete
+  //   Parameter List : control of its header
   //  Handle(Interface_ParamList) list = Data()->Params(num);
   Standard_Integer nbpar = Data()->NbParams(num);
   Standard_Integer n0par = (num == 1 ? 1 : (Data()->ParamFirstRank(num - 1) + 1));
   if (nbpar < 1)
   {
-    //   Liste vide non admise, sauf si Undefined (par exemple type nul)
+    //   Empty list not allowed, except if Undefined (for example null type)
     if (!undent.IsNull())
       return Standard_True;
     // Sending of message : DE : no parameter
@@ -196,7 +196,7 @@ void IGESData_IGESReaderTool::EndRead(const Handle(Interface_InterfaceModel)& /*
 }
 
 //  ###########################################################################
-//  ########                        UNE  ENTITE                        ########
+//  ########                        ONE  ENTITY                        ########
 
 //  ########                      Directory  Part                      ########
 
@@ -354,10 +354,10 @@ void IGESData_IGESReaderTool::ReadDir(const Handle(IGESData_IGESEntity)&     ent
   ent->InitMisc(Structure, Lbd, LWeightNum);
   ent->InitDirFieldEntity(8, fieldlab);
 
-  // ignores : 1(type),2(ptrPsect),13(type),16(lignesPsect),17(form)
+  // ignores : 1(type),2(ptrPsect),13(type),16(linesPsect),17(form)
-  // type et forme sont lus directement du DirPart; autres infos recalculees
+  // type and form are read directly from DirPart; other info recalculated
 
-  //    Restent a analyser nom (short label) et snum (subscript number)
+  //    Remaining to analyze name (short label) and snum (subscript number)
   Handle(TCollection_HAsciiString) ShortLabel;
   Standard_Integer                 SubScriptN = -1;
   Standard_Integer                 iacar      = 0;
@@ -381,7 +381,7 @@ void IGESData_IGESReaderTool::ReadDir(const Handle(IGESData_IGESEntity)&     ent
     SubScriptN = atoi(snum);
   ent->SetLabel(ShortLabel, SubScriptN);
 
-  //    Enfin, SetLineWeight, tenant compte du defaut
+  //    Finally, SetLineWeight, taking into account the default
   ent->SetLineWeight(IR->DefaultLineWeight(), themaxweight, thegradweight);
 }
 
@@ -395,7 +395,7 @@ void IGESData_IGESReaderTool::ReadOwnParams(const Handle(IGESData_IGESEntity)&
   Handle(Interface_ReaderModule) imodule;
   Standard_Integer               CN;
 
-  //  Les Modules font tout
+  //  The Modules do everything
   if (therlib.Select(ent, imodule, CN))
   {
     Handle(IGESData_ReadWriteModule) module = Handle(IGESData_ReadWriteModule)::DownCast(imodule);
@@ -408,13 +408,13 @@ void IGESData_IGESReaderTool::ReadOwnParams(const Handle(IGESData_IGESEntity)&
     Message_Msg Msg35("XSTEP_35");
     Msg35.Arg(thecnum);
     ach->SendFail(Msg35);
-    //  Cas de UndefinedEntity
+    //  Case of UndefinedEntity
   }
   else if (ent->IsKind(STANDARD_TYPE(IGESData_UndefinedEntity)))
   {
     DeclareAndCast(IGESData_UndefinedEntity, undent, ent);
     undent->ReadOwnParams(IR, PR);
-    //    IGESEntity creee puis non reconnue ... (bizarre, non ?)
+    //    IGESEntity created then not recognized ... (strange, isn't it ?)
   }
   else
   {

src/DataExchange/TKDEIGES/IGESData/IGESData_IGESWriter.cxx

@@ -40,7 +40,7 @@
 
 // #define PATIENCELOG
 
-// Constructeur complet : taille OK, et se remplit depuis le modele en direct
+// Complete constructor: size OK, and fills from the model directly
 
 IGESData_IGESWriter::IGESData_IGESWriter(const Handle(IGESData_IGESModel)& amodel)
     : thedirs(0, amodel->NbEntities()),
@@ -54,10 +54,10 @@ IGESData_IGESWriter::IGESData_IGESWriter(const Handle(IGESData_IGESModel)& amode
   thesep   = ',';
   theendm  = ';';
   thepars  = new TColStd_HSequenceOfHAsciiString();
-  thepnum.SetValue(1, 1); // debut des parametres de la 1re entite
+  thepnum.SetValue(1, 1); // start of parameters for the 1st entity
   thesect = 0;
   thepnum.Init(0);
-  //  Format flottant : cf FloatWriter
+  //  Floating format : see FloatWriter
 }
 
 IGESData_IGESWriter::IGESData_IGESWriter()
@@ -76,7 +76,7 @@ IGESData_IGESWriter::IGESData_IGESWriter(const IGESData_IGESWriter&)
 {
 }
 
-//  ....                Controle d Envoi des Flottants                ....
+//  ....                Float Sending Control                ....
 
 Interface_FloatWriter& IGESData_IGESWriter::FloatWriter()
 {
@@ -109,7 +109,7 @@ void IGESData_IGESWriter::SendStartLine(const Standard_CString startline)
     thestar->Append(new TCollection_HAsciiString(startline));
     return;
   }
-  //  Trop longue : on passe par bouts
+  //  Too long: we go piece by piece
   char startchar       = startline[MaxcarsG];
   pstartline[MaxcarsG] = '\0';
   SendStartLine(startline);
@@ -141,7 +141,7 @@ void IGESData_IGESWriter::SendModel(const Handle(IGESData_Protocol)& protocol)
     if (i % 1000 == 1)
       std::cout << "*" << std::flush;
 #endif
-    //  Attention aux cas d erreur : contenu redefini
+    //  Watch out for error cases : redefined content
     if (themodel->IsRedefinedContent(i))
     {
       sout << " --  IGESWriter : Erroneous Entity N0." << i << "  --" << std::endl;
@@ -153,12 +153,12 @@ void IGESData_IGESWriter::SendModel(const Handle(IGESData_Protocol)& protocol)
     }
 
     DirPart(cnt);
-    OwnParams(ent); // preparation : porte sur le vrai <ent> ...
+    OwnParams(ent); // preparation: applies to the real <ent> ...
 
-    //  Envoi proprement dit des Parametres proprement definis
+    //  Actual sending of properly defined Parameters
     Handle(IGESData_ReadWriteModule) module;
     Standard_Integer                 CN;
-    //  Differents cas
+    //  Different cases
     if (lib.Select(cnt, module, CN))
       module->WriteOwnParams(CN, cnt, *this);
     else if (cnt->IsKind(STANDARD_TYPE(IGESData_UndefinedEntity)))
@@ -175,7 +175,7 @@ void IGESData_IGESWriter::SendModel(const Handle(IGESData_Protocol)& protocol)
     EndEntity();
   }
 #ifdef PATIENCELOG
-  std::cout << " Envoi des Entites Termine" << std::endl;
+  std::cout << " Entity Sending Finished" << std::endl;
 #endif
   SectionT();
 }
@@ -195,8 +195,8 @@ void IGESData_IGESWriter::SectionG(const IGESData_GlobalSection& header)
   thesep  = header.Separator();
   theendm = header.EndMark();
   thecurr.SetMax(MaxcarsG);
-  //   Important : les Parametres sont sortis sous leur forme definitive
+  //   Important : Parameters are output in their final form
-  //   (c-a-d Hollerith pour les Textes ...)
+  //   (i.e. Hollerith for Texts ...)
   Handle(Interface_ParamSet) gl = header.Params();
   Standard_Integer           nb = gl->NbParams();
   for (Standard_Integer i = 1; i <= nb; i++)
@@ -239,9 +239,9 @@ void IGESData_IGESWriter::DirPart(const Handle(IGESData_IGESEntity)& anent)
   if (nument == 0)
     return;
   IGESData_DirPart& DP = thedirs.ChangeValue(nument);
-  //                                            Remplissage du DirPart
+  //                                            Filling the DirPart
   v[0] = anent->TypeNumber();
-  v[1] = 0; // numero en section P : calcule ulterieurement
+  v[1] = 0; // number in section P: calculated later
   if (anent->HasStructure())
     v[2] = -themodel->DNum(anent->DirFieldEntity(3));
   else
@@ -294,7 +294,7 @@ void IGESData_IGESWriter::DirPart(const Handle(IGESData_IGESEntity)& anent)
   else
     v[14] = 0;
 
-  v[15] = 0; // nb lignes section P : calcule plus tard
+  v[15] = 0; // number of lines in section P: calculated later
   v[16] = anent->FormNumber();
 
   anent->CResValues(res1, res2);
@@ -378,7 +378,7 @@ void IGESData_IGESWriter::Associativities(const Handle(IGESData_IGESEntity)& ane
     throw Interface_InterfaceError("IGESWriter : Associativities");
   thestep = IGESData_ReadAssocs;
   if (!anent->ArePresentAssociativities() && !anent->ArePresentProperties())
-    return; // Properties suivent : ne pas les omettre !
+    return; // Properties follow : do not omit them !
   Send(anent->NbAssociativities());
   for (Interface_EntityIterator iter = anent->Associativities(); iter.More(); iter.Next())
   {
@@ -398,7 +398,7 @@ void IGESData_IGESWriter::EndEntity()
   thestep = IGESData_ReadEnd;
 }
 
-//  ....                    Alimentation des parametres                    ....
+//  ....                    Parameter feeding                    ....
 
 void IGESData_IGESWriter::AddString(const Handle(TCollection_HAsciiString)& val,
                                     const Standard_Integer                  more)
@@ -417,7 +417,7 @@ void IGESData_IGESWriter::AddString(const Standard_CString val,
     lnstr = (Standard_Integer)strlen(val);
   if (!thecurr.CanGet(lnstr + more + 1))
   {
-    // + 1 (18-SEP-1996) pour etre sur que le separateur n est pas en tete de ligne
+    // + 1 (18-SEP-1996) to be sure that the separator n is not at the head of line
     if (thesect < 3)
       thehead->Append(thecurr.Moved());
     else
@@ -425,7 +425,7 @@ void IGESData_IGESWriter::AddString(const Standard_CString val,
   }
   Standard_Integer maxcars = (thesect == 3 ? MaxcarsP : MaxcarsG);
   Standard_Integer n2      = 0;
-  // ..  pb de taille limite (30-DEC-1996)
+  // ..  size limit issue (30-DEC-1996)
   while (lnstr > maxcars)
   {
     thecurr.Add(&val[n2], lnstr);
@@ -441,7 +441,7 @@ void IGESData_IGESWriter::AddString(const Standard_CString val,
 
 void IGESData_IGESWriter::AddChar(const Standard_Character val, const Standard_Integer more)
 {
-  //   1 seul caractere : cas particulier simplifie
+  //   1 single character : simplified special case
   char text[2];
   text[0] = val;
   text[1] = '\0';
@@ -479,7 +479,7 @@ void IGESData_IGESWriter::SendBoolean(const Standard_Boolean val)
 
 void IGESData_IGESWriter::Send(const Standard_Real val)
 {
-  //    Valeur flottante, expurgee de "0000" qui trainent et de "E+00"
+  //    Floating value, purged of trailing "0000" and "E+00"
   char lval[24];
   AddChar(thesep);
   Standard_Integer lng = thefloatw.Write(val, lval);
@@ -508,7 +508,7 @@ void IGESData_IGESWriter::Send(const Handle(IGESData_IGESEntity)& val,
     num = themodel->DNum(val);
   if (negative)
     num = -num;
-  Send(num); // qui faut tout, une fois Entity convertie en Integer
+  Send(num); // which handles everything, once Entity converted to Integer
 }
 
 void IGESData_IGESWriter::Send(const gp_XY& val)
@@ -527,7 +527,7 @@ void IGESData_IGESWriter::Send(const gp_XYZ& val)
 void IGESData_IGESWriter::SendString(const Handle(TCollection_HAsciiString)& val)
 {
   AddChar(thesep);
-  AddString(val); // envoi en l etat
+  AddString(val); // send as is
 }
 
 //  ....                            Envoi final                            ....
@@ -559,12 +559,12 @@ static void writefnes(Standard_OStream& S, const Standard_CString ligne)
 
 Standard_Boolean IGESData_IGESWriter::Print(Standard_OStream& S) const
 {
-  //  ATTENTION MODEFNES : si themodew = 10 ... alors on ecrit du FNES
+  //  WARNING MODEFNES : if themodew = 10 ... then we write FNES
-  //  quesaco ? fnes = iges + xor sur les caracteres (150,151,152,153,150...)
+  //  what is it? fnes = iges + xor on characters (150,151,152,153,150...)
-  //   avec en plus une ligne qcq en tete ...
+  //   with additionally some line at the head ...
-  //  donc tous les 4 car.s, on fait un tour de modulo. ainsi a 64 et a 72 ...
+  //  so every 4 chars, we do a modulo round. thus at 64 and at 72 ...
-  //  On a une mini-routine qui ecrit un morceau de texte "en fnes", et les
+  //  We have a mini-routine that writes a piece of text "in fnes", and the
-  //  blancs qui sont optimises (quand meme ...)
+  //  blanks that are optimized (anyway ...)
 
   Standard_Boolean isGood = (S.good());
   Standard_Boolean fnes   = (themodew >= 10);
@@ -587,7 +587,7 @@ Standard_Boolean IGESData_IGESWriter::Print(Standard_OStream& S) const
 
   if (thesect != 4)
     throw Interface_InterfaceError("IGESWriter not ready for Print");
-  //  Start Section (assez simple, somme toute). Attention si commentaires
+  //  Start Section (quite simple, all in all). Watch out for comments
   Handle(TCollection_HAsciiString) line;
   Standard_Integer                 nbs = 1;
   if (thestar.IsNull())
@@ -629,7 +629,7 @@ Standard_Boolean IGESData_IGESWriter::Print(Standard_OStream& S) const
   std::cout << "Global Section : " << std::flush;
 #endif
   isGood = S.good();
-  //  Global Section  :  convertie dans <thehead>
+  //  Global Section  :  converted in <thehead>
   Standard_Integer nbg = thehead->Length();
   for (i = 1; i <= nbg && isGood; i++)
   {
@@ -686,8 +686,8 @@ Standard_Boolean IGESData_IGESWriter::Print(Standard_OStream& S) const
                             res2,
                             lab,
                             num);
-    v[1]  = thepnum.Value(i);                        // debut en P
+    v[1]  = thepnum.Value(i);                        // start in P
-    v[15] = thepnum.Value(i + 1) - thepnum.Value(i); // nb de lignes en P
+    v[15] = thepnum.Value(i + 1) - thepnum.Value(i); // nb of lines in P
     sprintf(ligne,
             "%8d%8d%8d%8d%8d%8d%8d%8d%2.2d%2.2d%2.2d%2.2dD%7.7d",
             v[0],
@@ -747,7 +747,7 @@ Standard_Boolean IGESData_IGESWriter::Print(Standard_OStream& S) const
       char finlin[32];
       sprintf(finlin, " %7.7dP%7.7d", 2 * i - 1, j);
       line = thepars->Value(j);
-      //      line->LeftJustify(MaxcarsP,' ');  remplace par plus economique ! :
+      //      line->LeftJustify(MaxcarsP,' ');  replaced by more economical ! :
 
       if (fnes)
         writefnes(S, line->ToCString());

src/DataExchange/TKDEIGES/IGESData/IGESData_LabelDisplayEntity.cxx

@@ -16,4 +16,4 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(IGESData_LabelDisplayEntity, IGESData_IGESEntity)
 
-// LabelDisplayEntity ne sert qu'au controle de type (pour le directory part)
+// LabelDisplayEntity is only used for type control (for the directory part)

src/DataExchange/TKDEIGES/IGESData/IGESData_LevelListEntity.cxx

@@ -17,7 +17,7 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(IGESData_LevelListEntity, IGESData_IGESEntity)
 
-// LevelListEntity ne sert qu'au controle de type (pour le directory part)
+// LevelListEntity is only used for type control (for the directory part)
 Standard_Boolean IGESData_LevelListEntity::HasLevelNumber(const Standard_Integer level) const
 {
   Standard_Integer nb = NbLevelNumbers();

src/DataExchange/TKDEIGES/IGESData/IGESData_LineFontEntity.cxx

@@ -16,4 +16,4 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(IGESData_LineFontEntity, IGESData_IGESEntity)
 
-// LineTypeEntity ne sert qu'au controle de type (pour le directory part)
+// LineTypeEntity is only used for type control (for the directory part)

src/DataExchange/TKDEIGES/IGESData/IGESData_NameEntity.cxx

@@ -17,4 +17,4 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(IGESData_NameEntity, IGESData_IGESEntity)
 
-// NameEntity sert a decrire des entites "propriete nom" (Value a definir)
+// NameEntity is used to describe entities "name property" (Value to be defined)

src/DataExchange/TKDEIGES/IGESData/IGESData_ParamCursor.cxx

@@ -69,5 +69,5 @@ void IGESData_ParamCursor::SetAdvance(const Standard_Boolean advance)
   theadv = advance;
 }
 
-//  LA SUITE : inline , cf lxx
+//  THE REST : inline , see lxx
 //     (Start,Limit,Count,ItemSize,TermSize,Offset,Advance)

src/DataExchange/TKDEIGES/IGESData/IGESData_ParamReader.cxx

@@ -31,7 +31,7 @@
 
 #include <stdio.h>
 // MGE 03/08/98
-static Standard_Integer testconv = -1; // cf parametre de session
+static Standard_Integer testconv = -1; // see session parameter
 
 //  ....              Gestion generale (etat, courant ...)              ....
 
@@ -107,7 +107,7 @@ void IGESData_ParamReader::EndAll()
   thestage = IGESData_ReadEnd;
 }
 
-//  ....                  Acces de base aux parametres                  ....
+//  ....                  Basic parameter access                  ....
 
 //=================================================================================================
 
@@ -165,19 +165,19 @@ Handle(IGESData_IGESEntity) IGESData_ParamReader::ParamEntity(
   return GetCasted(IGESData_IGESEntity, IR->BoundEntity(n));
 }
 
-//  ....                    Assistance a la lecture                    ....
+//  ....                    Reading assistance                    ....
 
-//  Les fonctions Read* offrent les services suivants :
+//  The Read* functions offer the following services :
-//  Gestion des erreurs : le Check est alimente, par Fail ou Corrected selon
+//  Error management : the Check is fed, by Fail or Corrected accordingly
-//  Si Fail, retour de fonction False (peut etre utile), sinon True
+//  If Fail, function returns False (may be useful), otherwise True
-//  En outre, un Status est gere (de type enum DataState)
+//  Furthermore, a Status is managed (of type enum DataState)
-//    (peut etre interroge suite a appel Read* si retour True/False trop court)
+//    (can be queried following Read* call if True/False return too short)
 //
-//  Gestion du pointeur courant (sur option, nais elle est mise par defaut) :
+//  Current pointer management (optional, but set by default) :
-//  Les parametres sont designes via un ParmCursor, qui peut etre fabrique par
+//  Parameters are designated via a ParmCursor, which can be manufactured by
-//  les methodes ad hoc  Current et CurrentList, et qui peut demander a avancer
+//  the ad hoc methods Current and CurrentList, and which can request to advance
-//  le pointeur courant une fois la lecture faite
+//  the current pointer once reading is done
-//  En outre, pour un HArray1, on peut preciser index de depart
+//  Furthermore, for an HArray1, you can specify starting index
 
 //=================================================================================================
 
@@ -271,17 +271,17 @@ Standard_Boolean IGESData_ParamReader::PrepareRead(const IGESData_ParamCursor& P
   return Standard_True;
 }
 
-//  theindex donne le debut de la lecture; tjrs cale sur debut d item
+//  theindex gives the start of reading; always aligned on item start
-//  thenbterm donne debut a lire dans l item
+//  thenbterm gives start to read in the item
-//  Ainsi, l indice vrai est   theindex + thenbterm
+//  Thus, the true index is   theindex + thenbterm
-//  thenbterm avance par +nb. Quand il a depasse thetermsz, item suivant
+//  thenbterm advances by +nb. When it has exceeded thetermsz, next item
-//  theindex est lui-meme limite (critere d arret) a themaxind
+//  theindex is itself limited (stop criterion) to themaxind
 
 //=================================================================================================
 
 Standard_Integer IGESData_ParamReader::FirstRead(const Standard_Integer nb)
 {
-  theindex += theoffset; // On se cale d office sur le debut du terme a lire
+  theindex += theoffset; // We automatically align on the start of the term to read
   Standard_Integer res = theindex;
   thenbterm            = nb;
   if (thenbterm >= thetermsz)
@@ -299,7 +299,7 @@ Standard_Integer IGESData_ParamReader::NextRead(const Standard_Integer nb)
   Standard_Integer res = theindex;
   if (theindex >= themaxind)
     res = 0;
-  thenbterm += nb; // Par Item : en lire thetermsz, puis item suivant
+  thenbterm += nb; // Per Item: read thetermsz, then next item
   if (thenbterm >= thetermsz)
   {
     theindex += theitemsz;
@@ -389,8 +389,8 @@ Standard_Boolean IGESData_ParamReader::ReadBoolean(const IGESData_ParamCursor& P
     return Standard_False;
   }
 
-  //  Un Booleen, c est 0/1. Mais on peut tolerer d autres valeurs
+  //  A Boolean is 0/1. But we can tolerate other values
-  //  On peut toujours consulter LastReadStatus apres la lecture pour etre sur
+  //  One can always consult LastReadStatus after reading to be sure
   Standard_Integer flag = atoi(FP.CValue());
   if (flag != 0 && flag != 1)
   {
@@ -430,8 +430,8 @@ Standard_Boolean IGESData_ParamReader::ReadBoolean(const IGESData_ParamCursor& P
     return Standard_False;
   }
 
-  //  Un Booleen, c est 0/1. Mais on peut tolerer d autres valeurs
+  //  A Boolean is 0/1. But we can tolerate other values
-  //  On peut toujours consulter LastReadStatus apres la lecture pour etre sur
+  //  One can always consult LastReadStatus after reading to be sure
   Standard_Integer flag = atoi(FP.CValue());
   if (flag != 0 && flag != 1)
   {
@@ -668,11 +668,11 @@ Standard_Boolean IGESData_ParamReader::ReadEntity(const Handle(IGESData_IGESRead
     val = GetCasted(IGESData_IGESEntity, IR->BoundEntity(nval));
   if (val.IsNull())
     return canbenul;
-  //    Cas du "Nul IGES"
+  //    Case of "Null IGES"
   if (val->TypeNumber() == 0)
-  { // Null ou pas encore rempli ...
+  { // Null or not yet filled ...
     if (IR->DirType(nval).Type() == 0)
-    { // le vrai critere (un peu cher)
+    { // the real criterion (a bit expensive)
       val.Nullify();
       if (!canbenul)
       {
@@ -718,11 +718,11 @@ Standard_Boolean IGESData_ParamReader::ReadEntity(const Handle(IGESData_IGESRead
     val = GetCasted(IGESData_IGESEntity, IR->BoundEntity(nval));
   if (val.IsNull())
     return canbenul;
-  //    Cas du "Nul IGES"
+  //    Case of "Null IGES"
   if (val->TypeNumber() == 0)
-  { // Null ou pas encore rempli ...
+  { // Null or not yet filled ...
     if (IR->DirType(nval).Type() == 0)
-    { // le vrai critere (un peu cher)
+    { // the real criterion (a bit expensive)
       val.Nullify();
       if (!canbenul)
       {
@@ -1061,12 +1061,12 @@ Standard_Boolean IGESData_ParamReader::ReadEnts(const Handle(IGESData_IGESReader
   }
   if (ind == indmax + 1)
   {
-  } // tableau complet
+  } // complete array
   else if (ind == index)
-    val.Nullify(); // tableau vide
+    val.Nullify(); // empty array
   else
   {
-    // Trous : ils ont ete elimines, mais le tableau est a retailler
+    // Gaps: they have been eliminated, but the array needs to be resized
     Handle(IGESData_HArray1OfIGESEntity) tab = new IGESData_HArray1OfIGESEntity(index, ind - 1);
     for (i = index; i < ind; i++)
       tab->SetValue(i, val->Value(i));
@@ -1120,12 +1120,12 @@ Standard_Boolean IGESData_ParamReader::ReadEnts(const Handle(IGESData_IGESReader
   }
   if (ind == indmax + 1)
   {
-  } // tableau complet
+  } // complete array
   else if (ind == index)
-    val.Nullify(); // tableau vide
+    val.Nullify(); // empty array
   else
   {
-    // Trous : ils ont ete elimines, mais le tableau est a retailler
+    // Gaps: they have been eliminated, but the array needs to be resized
     Handle(IGESData_HArray1OfIGESEntity) tab = new IGESData_HArray1OfIGESEntity(index, ind - 1);
     for (i = index; i < ind; i++)
       tab->SetValue(i, val->Value(i));
@@ -1283,10 +1283,10 @@ Standard_Boolean IGESData_ParamReader::ReadingReal(const Standard_Integer num, S
         //  AddWarning (mess,ssem,"Real with no decimal point (added), 1st rank=%d");
       }
     }
-    // Par convention (pas d enum explicite dans IGES), signifie
+    // By convention (no explicit enum in IGES), means
-    // "reconnu comme flottant mais pas blanc-bleu" c-a-d sans point decimal
+    // "recognized as floating but not clean" i.e. without decimal point
-    // mais avec exposant (sinon ce serait un entier)
+    // but with exponent (otherwise it would be an integer)
-    // -> un message avertissement + on ajoute le point puis on convertit
+    // -> a warning message + we add the point then convert
 
     val = Atof(text);
   }
@@ -1361,10 +1361,10 @@ Standard_Boolean IGESData_ParamReader::ReadingReal(const Standard_Integer num,
         AddWarning(mess, ssem, "Real with no decimal point (added), 1st rank=%d");
       }
     }
-    // Par convention (pas d enum explicite dans IGES), signifie
+    // By convention (no explicit enum in IGES), means
-    // "reconnu comme flottant mais pas blanc-bleu" c-a-d sans point decimal
+    // "recognized as floating but not clean" i.e. without decimal point
-    // mais avec exposant (sinon ce serait un entier)
+    // but with exponent (otherwise it would be an integer)
-    // -> un message avertissement + on ajoute le point puis on convertit
+    // -> a warning message + we add the point then convert
 
     val = Atof(text);
   }
@@ -1450,7 +1450,7 @@ void IGESData_ParamReader::SendWarning(const Message_Msg& amsg)
   thelast = Standard_False;
 }
 
-//  ....              Gestion courante du statut de lecture              ....
+//  ....              Current reading status management              ....
 
 //=================================================================================================
 

src/DataExchange/TKDEIGES/IGESData/IGESData_Protocol.cxx

@@ -35,7 +35,7 @@ Handle(Interface_Protocol) IGESData_Protocol::Resource(const Standard_Integer /*
   return nulpro;
 }
 
-//  TypeNumber : Ici, on reconnait UndefinedEntity (faut bien quelqu un)
+//  TypeNumber : Here, we recognize UndefinedEntity (someone has to)
 
 Standard_Integer IGESData_Protocol::TypeNumber(const Handle(Standard_Type)& atype) const
 {

src/DataExchange/TKDEIGES/IGESData/IGESData_ReadWriteModule.cxx

@@ -41,4 +41,4 @@ void IGESData_ReadWriteModule::Read(const Standard_Integer,
 #endif
 }
 
-// IGESReaderTool fait tout
+// IGESReaderTool does everything

src/DataExchange/TKDEIGES/IGESData/IGESData_SingleParentEntity.cxx

@@ -17,5 +17,5 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(IGESData_SingleParentEntity, IGESData_IGESEntity)
 
-// SingleParentEntity sert a decrire des entites "associativite parent"
+// SingleParentEntity is used to describe "parent associativity" entities
-// (methode Parent a definir)
+// (Parent method to be defined)

src/DataExchange/TKDEIGES/IGESData/IGESData_SpecificModule.cxx

@@ -21,4 +21,4 @@ Standard_Boolean IGESData_SpecificModule::OwnCorrect(const Standard_Integer,
                                                      const Handle(IGESData_IGESEntity)&) const
 {
   return Standard_False;
-} // par defaut, ne fait rien
+} // by default, does nothing

src/DataExchange/TKDEIGES/IGESData/IGESData_ToolLocation.cxx

@@ -49,15 +49,15 @@ IGESData_ToolLocation::IGESData_ToolLocation(const Handle(IGESData_IGESModel)& a
 
 void IGESData_ToolLocation::Load()
 {
-  // Pour chaque Entite, sauf Transf et Assoc (sauf SingleParent), on considere
+  // For each Entity, except Transf and Assoc (except SingleParent), we consider
-  // ses "OwnShared" comme etant dependents
+  // its "OwnShared" as being dependents
   Standard_Integer nb = themodel->NbEntities();
   for (Standard_Integer i = 1; i <= nb; i++)
   {
     Handle(IGESData_IGESEntity) ent = themodel->Entity(i);
     if (ent->IsKind(STANDARD_TYPE(IGESData_TransfEntity)))
       continue;
-    // Cas de SingleParentEntity
+    // Case of SingleParentEntity
     if (ent->IsKind(STANDARD_TYPE(IGESData_SingleParentEntity)))
     {
       DeclareAndCast(IGESData_SingleParentEntity, assoc, ent);
@@ -68,9 +68,9 @@ void IGESData_ToolLocation::Load()
       continue;
     }
     if (ent->TypeNumber() == TYPEFORASSOC)
-      continue; // Assoc sauf SingleParent
+      continue; // Assoc except SingleParent
-    // Cas courant
+    // Current case
-    SetOwnAsDependent(ent); // qui opere
+    SetOwnAsDependent(ent); // which operates
   }
 }
 
@@ -121,9 +121,9 @@ void IGESData_ToolLocation::SetOwnAsDependent(const Handle(IGESData_IGESEntity)&
   Handle(IGESData_GeneralModule) module = Handle(IGESData_GeneralModule)::DownCast(gmodule);
   Interface_EntityIterator       list;
   module->OwnSharedCase(CN, ent, list);
-  // Remarque : en toute rigueur, il faudrait ignorer les entites referencees
+  // Remark : strictly speaking, we should ignore the referenced entities
-  // dont le SubordinateStatus vaut 0 ou 2 ...
+  // whose SubordinateStatus is 0 or 2 ...
-  // Question : ce Status est-il toujours bien comme il faut ?
+  // Question : is this Status always correct as it should be ?
   for (list.Start(); list.More(); list.Next())
     SetReference(ent, GetCasted(IGESData_IGESEntity, list.Value()));
 }
@@ -213,7 +213,7 @@ Standard_Boolean IGESData_ToolLocation::HasParentByAssociativity(
 
 gp_GTrsf IGESData_ToolLocation::ParentLocation(const Handle(IGESData_IGESEntity)& ent) const
 {
-  gp_GTrsf                    locat; // par defaut, identite
+  gp_GTrsf                    locat; // by default, identity
   Handle(IGESData_IGESEntity) parent = Parent(ent);
   // Definition recursive
   if (!parent.IsNull())
@@ -224,8 +224,8 @@ gp_GTrsf IGESData_ToolLocation::ParentLocation(const Handle(IGESData_IGESEntity)
 gp_GTrsf IGESData_ToolLocation::EffectiveLocation(const Handle(IGESData_IGESEntity)& ent) const
 {
   gp_GTrsf locat = ent->Location();
-  // Combiner Transf et ParentLocation
+  // Combine Transf and ParentLocation
-  locat.PreMultiply(ParentLocation(ent)); // ne pas se tromper de sens !
+  locat.PreMultiply(ParentLocation(ent)); // don't confuse the direction !
   return locat;
 }
 
@@ -240,19 +240,19 @@ Standard_Boolean IGESData_ToolLocation::ConvertLocation(const Standard_Real prec
                                                         const Standard_Real unit)
 {
   if (result.Form() != gp_Identity)
-    result = gp_Trsf(); // Identite forcee au depart
+    result = gp_Trsf(); // Identity forced at start
-  // On prend le contenu de <loc>. Attention a l adressage
+  // We take the content of <loc>. Be careful with addressing
   gp_XYZ v1(loc.Value(1, 1), loc.Value(1, 2), loc.Value(1, 3));
   gp_XYZ v2(loc.Value(2, 1), loc.Value(2, 2), loc.Value(2, 3));
   gp_XYZ v3(loc.Value(3, 1), loc.Value(3, 2), loc.Value(3, 3));
-  // A-t-on affaire a une similitude ?
+  // Are we dealing with a similarity ?
   Standard_Real m1 = v1.Modulus();
   Standard_Real m2 = v2.Modulus();
   Standard_Real m3 = v3.Modulus();
-  // D abord est-elle singuliere cette matrice ?
+  // First is this matrix singular ?
   if (m1 < prec || m2 < prec || m3 < prec)
     return Standard_False;
-  Standard_Real mm = (m1 + m2 + m3) / 3.; // voici la Norme moyenne, cf Scale
+  Standard_Real mm = (m1 + m2 + m3) / 3.; // here is the average Norm, see Scale
   if (Abs(m1 - mm) > prec * mm || Abs(m2 - mm) > prec * mm || Abs(m3 - mm) > prec * mm)
     return Standard_False;
   v1.Divide(m1);
@@ -260,8 +260,8 @@ Standard_Boolean IGESData_ToolLocation::ConvertLocation(const Standard_Real prec
   v3.Divide(m3);
   if (Abs(v1.Dot(v2)) > prec || Abs(v2.Dot(v3)) > prec || Abs(v3.Dot(v1)) > prec)
     return Standard_False;
-  // Ici, Orthogonale et memes normes. En plus on l a Normee
+  // Here, Orthogonal and same norms. Plus we normalized it
-  // Restent les autres caracteristiques :
+  // Remain the other characteristics :
   if (Abs(mm - 1.) > prec)
     result.SetScale(gp_Pnt(0, 0, 0), mm);
   gp_XYZ tp = loc.TranslationPart();
@@ -269,11 +269,11 @@ Standard_Boolean IGESData_ToolLocation::ConvertLocation(const Standard_Real prec
     tp.Multiply(unit);
   if (tp.X() != 0. || tp.Y() != 0. || tp.Z() != 0.)
     result.SetTranslationPart(tp);
-  // On isole le cas de l Identite (tellement facile et avantageux)
+  // We isolate the case of Identity (so easy and advantageous)
   if (v1.X() != 1. || v1.Y() != 0. || v1.Z() != 0. || v2.X() != 0. || v2.Y() != 1. || v2.Z() != 0.
       || v3.X() != 0. || v3.Y() != 0. || v3.Z() != 1.)
   {
-    // Pas Identite : vraie construction depuis un Ax3
+    // Not Identity : real construction from an Ax3
     gp_Dir d1(v1);
     gp_Dir d2(v2);
     gp_Dir d3(v3);

src/DataExchange/TKDEIGES/IGESData/IGESData_TransfEntity.cxx

@@ -17,5 +17,5 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(IGESData_TransfEntity, IGESData_IGESEntity)
 
-// TransfEntity ne sert que pour controle de Type, et fourniture par Value
+// TransfEntity is only used for Type control, and providing by Value
-// de la GTrsf correspondante
+// the corresponding GTrsf

src/DataExchange/TKDEIGES/IGESData/IGESData_UndefinedEntity.cxx

@@ -145,8 +145,8 @@ Standard_Boolean IGESData_UndefinedEntity::HasSubScriptNumber() const
     return Standard_False;
 }
 
-//   ReadDir verifie les donnees, s il y a des erreurs les note (status),
+//   ReadDir verifies the data, if there are errors notes them (status),
-//   genere un nouveau DirPart sans ces erreurs, et appelle ReadDir de base
+//   generates a new DirPart without these errors, and calls base ReadDir
 
 //=================================================================================================
 
@@ -167,7 +167,7 @@ Standard_Boolean IGESData_UndefinedEntity::ReadDir(const Handle(IGESData_IGESRea
 
   Standard_Integer   v[17];
   Standard_Character res1[9], res2[9], lab[9], subs[9];
-  Standard_Integer   max = 2 * IR->NbRecords(); // valeur maxi pour DSectNum
+  Standard_Integer   max = 2 * IR->NbRecords(); // max value for DSectNum
   thedstat               = 0;
 
   Handle(IGESData_IGESEntity) anent;
@@ -315,7 +315,7 @@ Standard_Boolean IGESData_UndefinedEntity::ReadDir(const Handle(IGESData_IGESRea
   for (i = 0; i < 8; i++)
   {
     if (subs[i] == '\0')
-      break; // fin de ligne
+      break; // end of line
     if (subs[i] != ' ' && (subs[i] < 48 || subs[i] > 57))
       iapb = Standard_True;
   }
@@ -330,7 +330,7 @@ Standard_Boolean IGESData_UndefinedEntity::ReadDir(const Handle(IGESData_IGESRea
       subs[i] = ' ';
   }
 
-  //  ...  Fin de cette analyse : si necessaire on reconstruit DP  ...
+  //  ...  End of this analysis : if necessary we rebuild DP  ...
   if (thedstat == 0)
     return Standard_True;
   else
@@ -360,7 +360,7 @@ Standard_Boolean IGESData_UndefinedEntity::ReadDir(const Handle(IGESData_IGESRea
   }
 }
 
-//   Parametres indifferencies : assocs et props ignores
+//   Undifferentiated parameters : assocs and props ignored
 
 //=================================================================================================
 
@@ -378,7 +378,7 @@ void IGESData_UndefinedEntity::ReadOwnParams(const Handle(IGESData_IGESReaderDat
         }
         else thecont->AddLiteral (ptyp,new TCollection_HAsciiString(PR.ParamValue(i)));
     */
-    //  On est TOUJOURS en mode litteral, c est bien plus clair !
+    //  We are ALWAYS in literal mode, it's much clearer !
     thecont->AddLiteral(ptyp, new TCollection_HAsciiString(PR.ParamValue(i)));
   }
   PR.SetCurrentNumber(nb + 1);

src/DataExchange/TKDEIGES/IGESData/IGESData_ViewKindEntity.cxx

@@ -17,6 +17,6 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(IGESData_ViewKindEntity, IGESData_IGESEntity)
 
-// ViewKindEntity ne sert qu'au controle de type (entite View du directory part
+// ViewKindEntity is only used for type control (View entity in directory part
-// qui peut etre une Vue Simple ou une Liste de Vue
+// which can be a Simple View or a View List
-// Vue Simple doit implementer IsSingle a Standard_True, Liste de Vue a Standard_False
+// Simple View must implement IsSingle as Standard_True, View List as Standard_False

src/DataExchange/TKDEIGES/IGESDefs/IGESDefs_AttributeTable.cxx

@@ -31,9 +31,9 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(IGESDefs_AttributeTable, IGESData_IGESEntity)
 
-//  ATTENTION  ATTENTION : L Appellation "ROW" n est pas reconduite en l etat
+//  WARNING  WARNING : The "ROW" designation is not continued as is
-//  Le Numero d Attribut est donne en 1er (donc, en colonne du HArray2 et non
+//  The Attribute Number is given first (therefore, in column of HArray2 and not
-//  en ligne), le numero de Colonne en 2e (donc, comme un numero de Ligne)
+//  in row), the Column number second (therefore, as a Row number)
 IGESDefs_AttributeTable::IGESDefs_AttributeTable() {}
 
 void IGESDefs_AttributeTable::Init(const Handle(TColStd_HArray2OfTransient)& attributes)
@@ -124,5 +124,5 @@ Standard_Boolean IGESDefs_AttributeTable::AttributeAsLogical(const Standard_Inte
                                                              const Standard_Integer Rownum,
                                                              const Standard_Integer Valuenum) const
 {
-  return (AttributeAsInteger(Atnum, Rownum, Valuenum) != 0); // raccourci
+  return (AttributeAsInteger(Atnum, Rownum, Valuenum) != 0); // shortcut
 }

src/DataExchange/TKDEIGES/IGESDefs/IGESDefs_TabularData.cxx

@@ -59,7 +59,7 @@ Standard_Integer IGESDefs_TabularData::NbPropertyValues() const
 
 Standard_Integer IGESDefs_TabularData::ComputedNbPropertyValues() const
 {
-  return theNbPropertyValues; // pas malin ... a ameliorer
+  return theNbPropertyValues; // not smart ... to improve
 }
 
 Standard_Boolean IGESDefs_TabularData::OwnCorrect()

src/DataExchange/TKDEIGES/IGESDefs/IGESDefs_ToolAttributeDef.cxx

@@ -146,8 +146,8 @@ void IGESDefs_ToolAttributeDef::ReadOwnParams(const Handle(IGESDefs_AttributeDef
             switch (attrValueDataType)
             {
               case 0: {
-                PR.SetCurrentNumber(PR.CurrentNumber() + 1); // passer
+                PR.SetCurrentNumber(PR.CurrentNumber() + 1); // skip
-                ////			attrValue->SetValue(j, NULL);    par defaut
+                ////			attrValue->SetValue(j, NULL);    by default
                 break;
               }
               case 1: {

src/DataExchange/TKDEIGES/IGESDefs/IGESDefs_ToolAttributeTable.cxx

@@ -231,7 +231,7 @@ void IGESDefs_ToolAttributeTable::OwnCopy(const Handle(IGESDefs_AttributeTable)&
       Standard_Integer atype = ab->AttributeValueDataType(i);
       switch (atype)
       {
-        case 0: ////    list2->SetValue(i,k,NULL);    par defaut
+        case 0: ////    list2->SetValue(i,k,NULL);    by default
           break;
         case 1: {
           DeclareAndCast(TColStd_HArray1OfInteger, otherInt, another->AttributeList(i, k));
@@ -267,7 +267,7 @@ void IGESDefs_ToolAttributeTable::OwnCopy(const Handle(IGESDefs_AttributeTable)&
                               GetCasted(IGESData_IGESEntity, TC.Transferred(otherEnt->Value(j))));
         }
         break;
-        case 5: /////	      list2->SetValue(i,k,NULL);    par defaut
+        case 5: /////	      list2->SetValue(i,k,NULL);    by default
           break;
         case 6: { // Here item takes value 0 or 1
           DeclareAndCast(TColStd_HArray1OfInteger, otherInt, another->AttributeList(i, k));

src/DataExchange/TKDEIGES/IGESDefs/IGESDefs_ToolTabularData.cxx

@@ -99,9 +99,9 @@ void IGESDefs_ToolTabularData::ReadOwnParams(const Handle(IGESDefs_TabularData)&
     valuesInd->SetValue(i, tarr);
   }
   // ??  for (i=1; i<=nbDeps; i++) {  }
-  //  Dependents : definition pas limpide, on accumule tout sur un seul
+  //  Dependents : definition not clear, we accumulate everything on a single
-  //  HArray1OfReal, mis en 1re position du HArray1OfHArray1OfReal
+  //  HArray1OfReal, put in 1st position of the HArray1OfHArray1OfReal
-  //  On y met tous les flottants qui restent
+  //  We put all the remaining floats there
   Standard_Integer curnum = PR.CurrentNumber();
   Standard_Integer nbpars = PR.NbParams();
   Standard_Integer nbd    = 0;
@@ -135,7 +135,7 @@ void IGESDefs_ToolTabularData::ReadOwnParams(const Handle(IGESDefs_TabularData)&
       PR.SetCurrentNumber (curnum+1);
     }  */
   PR.AddWarning("Don't know exactly how to read dependent values ...");
-  //  ??  a eclaircir
+  //  ??  to clarify
   DirChecker(ent).CheckTypeAndForm(PR.CCheck(), ent);
   ent->Init(nbProps, propType, typesInd, nbValuesInd, valuesInd, valuesDep);
 }

src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_GeneralSymbol.cxx

@@ -40,7 +40,7 @@ void IGESDimen_GeneralSymbol::Init(const Handle(IGESDimen_GeneralNote)&
   theGeoms   = allGeoms;
   theLeaders = allLeaders;
   InitTypeAndForm(228, FormNumber());
-  //  FormNumber precises the Nature of the Symbol, cf G.14 (0-3 or > 5000)
+  //  FormNumber specifies the Nature of the Symbol, see G.14 (0-3 or > 5000)
 }
 
 void IGESDimen_GeneralSymbol::SetFormNumber(const Standard_Integer form)

src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_RadiusDimension.cxx

@@ -39,7 +39,7 @@ void IGESDimen_RadiusDimension::Init(const Handle(IGESDimen_GeneralNote)& aNote,
   theCenter      = arcCenter;
   theLeader2     = anotherArrow;
   if (!anotherArrow.IsNull())
-    InitTypeAndForm(222, 1); // 1 admet aussi Null
+    InitTypeAndForm(222, 1); // 1 also admits Null
   else
     InitTypeAndForm(222, FormNumber());
 }

src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_ToolCenterLine.cxx

@@ -121,10 +121,10 @@ Standard_Boolean IGESDimen_ToolCenterLine::OwnCorrect(const Handle(IGESDimen_Cen
   }
   if (ent->Datatype() == 1)
     return res;
-  //  Forcer DataType = 1 -> reconstruire
+  //  Force DataType = 1 -> reconstruct
   Standard_Integer nb = ent->NbPoints();
   if (nb == 0)
-    return res; // rien pu faire (est-ce possible ?)
+    return res; // nothing could be done (is this possible?)
   Handle(TColgp_HArray1OfXY) pts = new TColgp_HArray1OfXY(1, nb);
   for (Standard_Integer i = 1; i <= nb; i++)
     pts->SetValue(i, gp_XY(ent->Point(i).X(), ent->Point(i).Y()));

src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_ToolDimensionedGeometry.cxx

@@ -112,7 +112,7 @@ Standard_Boolean IGESDimen_ToolDimensionedGeometry::OwnCorrect(
 {
   if (ent->NbDimensions() == 1)
     return Standard_False;
-  //  forcer NbDimensions a 1 -> reconstruire
+  //  force NbDimensions to 1 -> reconstruct
   Standard_Integer                     nb       = ent->NbGeometryEntities();
   Handle(IGESData_HArray1OfIGESEntity) EntArray = new IGESData_HArray1OfIGESEntity(1, nb);
   for (Standard_Integer i = 1; i <= nb; i++)

src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_ToolNewDimensionedGeometry.cxx

@@ -177,7 +177,7 @@ Standard_Boolean IGESDimen_ToolNewDimensionedGeometry::OwnCorrect(
   }
   if (ent->NbDimensions() == 1)
     return res;
-  //   Forcer NbDimensions = 1 -> reconstruire
+  //   Force NbDimensions = 1 -> reconstruct
   Standard_Integer                     nb              = ent->NbGeometries();
   Handle(IGESData_HArray1OfIGESEntity) tempGeomEnts    = new IGESData_HArray1OfIGESEntity(1, nb);
   Handle(TColStd_HArray1OfInteger)     tempDimLocFlags = new TColStd_HArray1OfInteger(1, nb);

src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_ToolSection.cxx

@@ -121,10 +121,10 @@ Standard_Boolean IGESDimen_ToolSection::OwnCorrect(const Handle(IGESDimen_Sectio
   }
   if (ent->Datatype() == 1)
     return res;
-  //  Forcer DataType = 1 -> reconstruire
+  //  Force DataType = 1 -> reconstruct
   Standard_Integer nb = ent->NbPoints();
   if (nb == 0)
-    return Standard_False; // rien pu faire (est-ce possible ?)
+    return Standard_False; // nothing could be done (is this possible?)
   Handle(TColgp_HArray1OfXY) pts = new TColgp_HArray1OfXY(1, nb);
   for (Standard_Integer i = 1; i <= nb; i++)
     pts->SetValue(i, gp_XY(ent->Point(i).X(), ent->Point(i).Y()));

src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_ToolWitnessLine.cxx

@@ -121,10 +121,10 @@ Standard_Boolean IGESDimen_ToolWitnessLine::OwnCorrect(
   }
   if (ent->Datatype() == 1)
     return res;
-  //  Forcer DataType = 1 -> reconstruire
+  //  Force DataType = 1 -> reconstruct
   Standard_Integer nb = ent->NbPoints();
   if (nb == 0)
-    return Standard_False; // rien pu faire (est-ce possible ?)
+    return Standard_False; // nothing could be done (is this possible?)
   Handle(TColgp_HArray1OfXY) pts = new TColgp_HArray1OfXY(1, nb);
   for (Standard_Integer i = 1; i <= nb; i++)
     pts->SetValue(i, gp_XY(ent->Point(i).X(), ent->Point(i).Y()));

src/DataExchange/TKDEIGES/IGESDraw/IGESDraw_ToolDrawing.cxx

@@ -186,7 +186,7 @@ void IGESDraw_ToolDrawing::OwnCopy(const Handle(IGESDraw_Drawing)& another,
 
 Standard_Boolean IGESDraw_ToolDrawing::OwnCorrect(const Handle(IGESDraw_Drawing)& ent) const
 {
-  //  Vues vides : les supprimer
+  //  Empty views: remove them
   Standard_Integer i, nb = ent->NbViews();
   Standard_Integer nbtrue = nb;
   for (i = 1; i <= nb; i++)
@@ -219,7 +219,7 @@ Standard_Boolean IGESDraw_ToolDrawing::OwnCorrect(const Handle(IGESDraw_Drawing)
     viewOrigins->SetValue(nbtrue, ent->ViewOrigin(i).XY());
   }
 
-  //  Ne pas oublier les annotations ...
+  //  Don't forget the annotations ...
   Standard_Integer                     nbanot      = ent->NbAnnotations();
   Handle(IGESData_HArray1OfIGESEntity) annotations = new IGESData_HArray1OfIGESEntity(1, nbanot);
   for (i = 1; i <= nbanot; i++)

src/DataExchange/TKDEIGES/IGESDraw/IGESDraw_ToolSegmentedViewsVisible.cxx

@@ -244,7 +244,7 @@ void IGESDraw_ToolSegmentedViewsVisible::OwnCopy(
     else
     {
       colorValues->SetValue(i, another->ColorValue(i));
-      ////          colorDefinitions->SetValue( i, NULL );    par defaut
+      ////          colorDefinitions->SetValue( i, NULL );    by default
     }
 
     if (another->IsFontDefinition(i))
@@ -256,7 +256,7 @@ void IGESDraw_ToolSegmentedViewsVisible::OwnCopy(
     else
     {
       lineFontValues->SetValue(i, another->LineFontValue(i));
-      ////          lineFontDefinitions->SetValue( i, NULL );  par defaut
+      ////          lineFontDefinitions->SetValue( i, NULL );  by default
     }
 
     lineWeights->SetValue(i, another->LineWeightItem(i));

src/DataExchange/TKDEIGES/IGESDraw/IGESDraw_ToolViewsVisible.cxx

@@ -159,7 +159,7 @@ void IGESDraw_ToolViewsVisible::OwnCopy(const Handle(IGESDraw_ViewsVisible)& ano
     DeclareAndCast(IGESData_ViewKindEntity, tempView, TC.Transferred(another->ViewItem(I)));
     tempViewEntities->SetValue(I, tempView);
   }
-  //  Displayed -> Implied : mettre une liste vide par defaut
+  //  Displayed -> Implied : set an empty list by default
   Handle(IGESData_HArray1OfIGESEntity) tempDisplayEntities;
   ent->Init(tempViewEntities, tempDisplayEntities);
 }
@@ -253,7 +253,7 @@ void IGESDraw_ToolViewsVisible::OwnDump(const Handle(IGESDraw_ViewsVisible)& ent
 Standard_Boolean IGESDraw_ToolViewsVisible::OwnCorrect(
   const Handle(IGESDraw_ViewsVisible)& ent) const
 {
-  //  Les entites affichees doivent referencer <ent>. Elles ont priorite.
+  //  The displayed entities must reference <ent>. They have priority.
   Standard_Boolean                       res     = Standard_False;
   Standard_Integer                       nb      = ent->NbDisplayedEntities();
   const Handle(IGESData_ViewKindEntity)& entcomp = ent;

src/DataExchange/TKDEIGES/IGESDraw/IGESDraw_ToolViewsVisibleWithAttr.cxx

@@ -279,7 +279,7 @@ void IGESDraw_ToolViewsVisibleWithAttr::OwnCopy(
     Standard_Integer tempLineWeight = another->LineWeightItem(I);
     tempLineWeights->SetValue(I, tempLineWeight);
   }
-  //  Displayed -> Implied : mettre une liste vide par defaut
+  //  Displayed -> Implied : set an empty list by default
   Handle(IGESData_HArray1OfIGESEntity) tempDisplayEntities;
   ent->Init(tempViewEntities,
             tempLineFonts,
@@ -425,7 +425,7 @@ void IGESDraw_ToolViewsVisibleWithAttr::OwnDump(const Handle(IGESDraw_ViewsVisib
 Standard_Boolean IGESDraw_ToolViewsVisibleWithAttr::OwnCorrect(
   const Handle(IGESDraw_ViewsVisibleWithAttr)& ent) const
 {
-  //  Les entites affichees doivent referencer <ent>. Elles ont priorite.
+  //  The displayed entities must reference <ent>. They have priority.
   Standard_Boolean                       res     = Standard_False;
   Standard_Integer                       nb      = ent->NbDisplayedEntities();
   const Handle(IGESData_ViewKindEntity)& entcomp = ent;

src/DataExchange/TKDEIGES/IGESFile/IGESFile_Read.cxx

@@ -14,17 +14,17 @@
 // dce 21.01.99 : move of general message to IGESToBRep_Reader
 
 #include <stdio.h>
-// declarations des programmes C de base :
+// declarations of basic C programs:
 #include <IGESData_IGESReaderData.hxx>
 #include <IGESData_IGESReaderTool.hxx>
 #include <IGESData_GeneralModule.hxx>
 #include <Interface_Check.hxx>
 
-//  Pour traiter les exceptions :
+//  To handle exceptions:
 #include <Standard_ErrorHandler.hxx>
 #include <Standard_Failure.hxx>
 
-// definition de base, a inclure pour utiliser
+// basic definition, to include for use
 #include <IGESFile_Read.hxx>
 
 #include "igesread.h"
@@ -35,8 +35,8 @@
 // To use Msg class
 #include <Message_Msg.hxx>
 
-// decoupage interne pour faciliter les recuperations d erreurs
+// internal breakdown to facilitate error recovery
-static Standard_Integer recupne, recupnp; // pour affichage en cas de pepin
+static Standard_Integer recupne, recupnp; // for display in case of problem
 
 static Handle(Interface_Check)& checkread()
 {
@@ -50,10 +50,10 @@ void        IGESFile_Check(int mode, Message_Msg& amsg);
 // void IGESFile_Check2 (int mode,char * code, int num, char * str);
 // void IGESFile_Check3 (int mode,char * code);
 
-//  Correspondance entre types igesread et types Interface_ParamFile ...
+//  Correspondence between igesread types and Interface_ParamFile types ...
 static Interface_ParamType LesTypes[10];
 
-//  Nouvelle maniere : Protocol suffit
+//  New way: Protocol is sufficient
 
 Standard_Integer IGESFile_Read(char*                             nomfic,
                                const Handle(IGESData_IGESModel)& amodel,
@@ -71,7 +71,7 @@ Standard_Integer IGESFile_ReadFNES(char*                             nomfic,
   return IGESFile_Read(nomfic, amodel, protocol, nulreco, Standard_True);
 }
 
-//  Ancienne maniere : avec Recognizer
+//  Old way: with Recognizer
 
 Standard_Integer IGESFile_Read(char*                                  nomfic,
                                const Handle(IGESData_IGESModel)&      amodel,
@@ -96,7 +96,7 @@ Standard_Integer IGESFile_Read(char*                                  nomfic,
   if (result != 0)
     return result;
 
-  //  Chargement des resultats dans un IGESReader
+  //  Loading results into an IGESReader
 
   LesTypes[ArgVide] = Interface_ParamVoid;
   LesTypes[ArgQuid] = Interface_ParamMisc;
@@ -104,12 +104,12 @@ Standard_Integer IGESFile_Read(char*                                  nomfic,
   LesTypes[ArgInt]  = Interface_ParamInteger;
   LesTypes[ArgSign] = Interface_ParamInteger;
   LesTypes[ArgReal] = Interface_ParamReal;
-  LesTypes[ArgExp]  = Interface_ParamMisc; // exposant pas termine
+  LesTypes[ArgExp]  = Interface_ParamMisc; // exponent not finished
-  LesTypes[ArgRexp] = Interface_ParamReal; // exposant complet
+  LesTypes[ArgRexp] = Interface_ParamReal; // complete exponent
-  LesTypes[ArgMexp] = Interface_ParamEnum; // exposant mais pas de point
+  LesTypes[ArgMexp] = Interface_ParamEnum; // exponent but no decimal point
 
   int nbparts, nbparams;
-  iges_stats(&nbparts, &nbparams); // et fait les Initialisations necessaires
+  iges_stats(&nbparts, &nbparams); // and performs necessary initializations
   Handle(IGESData_IGESReaderData) IR =
     //    new IGESData_IGESReaderData (nbparts, nbparams);
     new IGESData_IGESReaderData((lesect[3] + 1) / 2, nbparams);
@@ -119,7 +119,7 @@ Standard_Integer IGESFile_Read(char*                                  nomfic,
       {
         OCC_CATCH_SIGNALS
         IGESFile_ReadHeader(IR);
-      } // fin essai 1 (global)
+      } // end attempt 1 (global)
       catch (Standard_Failure const&)
       {
         // Sending of message : Internal error during the header reading
@@ -136,7 +136,7 @@ Standard_Integer IGESFile_Read(char*                                  nomfic,
           IGESFile_ReadContent(IR);
 
         // Sending of message : Loaded data
-      } // fin essai 2 (entites)
+      } // end attempt 2 (entities)
       catch (Standard_Failure const&)
       {
         // Sending of message : Internal error during the content reading
@@ -172,7 +172,7 @@ Standard_Integer IGESFile_Read(char*                                  nomfic,
     amodel->SetProtocol(protocol);
   iges_finfile(2);
 
-  //  A present, le check
+  //  Now, the check
   // Nb warning in global section.
   Standard_Integer nbWarn = checkread()->NbWarnings(), nbFail = checkread()->NbFails();
   const Handle(Interface_Check)& oldglob = amodel->GlobalCheck();
@@ -187,14 +187,14 @@ Standard_Integer IGESFile_Read(char*                                  nomfic,
   return 0;
 }
 
-// Decoupage interne
+// Internal breakdown
 
 void IGESFile_ReadHeader(const Handle(IGESData_IGESReaderData)& IR)
 {
   Standard_Integer l = 0; // szv#4:S4163:12Mar99 i,j,k not needed
   char*            parval;
   int              typarg;
-  //  d abord les start lines (commentaires)
+  //  first the start lines (comments)
   // szv#4:S4163:12Mar99 optimized
   /*
     while ( (j = iges_lirparam(&typarg,&parval)) != 0) {
@@ -206,7 +206,7 @@ void IGESFile_ReadHeader(const Handle(IGESData_IGESReaderData)& IR)
       if (k >= 0 || l > 0) IR->AddStartLine (parval);
       l ++;
     }
-    //  puis la Global Section
+    //  then the Global Section
     iges_setglobal();
     while ( (i = iges_lirparam(&typarg,&parval)) != 0) {
       IR->AddGlobal(LesTypes[typarg],parval);
@@ -223,7 +223,7 @@ void IGESFile_ReadHeader(const Handle(IGESData_IGESReaderData)& IR)
       IR->AddStartLine(parval);
     l++;
   }
-  //  puis la Global Section
+  //  then the Global Section
   iges_setglobal();
   while (iges_lirparam(&typarg, &parval) != 0)
     IR->AddGlobal(LesTypes[typarg], parval);

src/DataExchange/TKDEIGES/IGESFile/IGESFile_Read.hxx

@@ -11,7 +11,7 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-//  Include a utiliser pour appeler IGESFile_Read
+//  Include to use for calling IGESFile_Read
 
 #ifndef IGESFile_Read_HeaderFile
 #define IGESFile_Read_HeaderFile

src/DataExchange/TKDEIGES/IGESFile/analiges.c

@@ -24,38 +24,38 @@ void iges_addparam(int longval, char* parval);
 #define ArgVide 0
 #define ArgQuid 1
 #define ArgChar 2
-#define ArgInt  3   /* Entier non signe : peut evoluer vers Real ou Char */
+#define ArgInt  3   /* Unsigned integer: can evolve to Real or Char */
-#define ArgSign 4   /* Entier signe : peut evoluer vers Real */
+#define ArgSign 4   /* Signed integer: can evolve to Real */
 #define ArgReal 5
-#define ArgExp  6   /* Real + lettre E : attendre confirmation */
+#define ArgExp  6   /* Real + letter E: wait for confirmation */
-#define ArgRexp 7   /* Real + Exposant : se ramene a Real */
+#define ArgRexp 7   /* Real + Exponent: reduces to Real */
-#define ArgMexp 8   /* Real + Exposant INCOMPLET (pas de point decimal) */
+#define ArgMexp 8   /* Real + INCOMPLETE Exponent (no decimal point) */
 
-/*  les structures de travail de  structiges  sont connues :
+/*  the working structures of structiges are known:
-    a savoir declarations + curp  */
+    namely declarations + curp  */
 /*  #define VERIFPRINT  */
 
-/*    Lecture section D
+/*    Reading section D
-      Chaque entite tient sur deux lignes
+      Each entity spans two lines
 
-      Dstat demarre a zero "on lit une nouvelle entite"
+      Dstat starts at zero "we read a new entity"
-      et bascule avec un   "deuxieme ligne de l'entite"
+      and switches with a   "second line of the entity"
 */
 
 
 static int bases[] =
   { 1,10,100,1000,10000,100000,1000000, 10000000,100000000,1000000000 };
 
-/*      DECODAGE : parce que scanf ne fait pas vraiment ce qu'il faut     */
+/*      DECODING: because scanf doesn't really do what's needed     */
-/*      Utilitaire decodant un nombre en format fixe dans une ligne
+/*      Utility decoding a number in fixed format in a line
-	Il part de "depuis" inclus (debut ligne = 0) et prend "tant" caracteres
+	It starts from "depuis" included (line start = 0) and takes "tant" characters
-	Valeur lue en retour de fonction   */
+	Value read as function return   */
-static int IGES_decode (char* ligne, int depuis, int tant)
+static int IGES_decode (char* line, int depuis, int tant)
 {
   int val = 0; int i;
   int depart = depuis+tant-1;
   for (i = 0; i < tant; i ++) {
-    char uncar = ligne[depart-i];
+    char uncar = line[depart-i];
     if (uncar == ' ') break;
     else if (uncar == '+') continue;
     else if (uncar == '-') val = -val;
@@ -64,90 +64,90 @@ static int IGES_decode (char* ligne, int depuis, int tant)
   return val;
 }
 
-/*   Recopie d'une chaine de caracteres de longueur fixe (close par \0)  */
+/*   Copy of a fixed-length character string (closed by \0)  */
-void IGES_copstr(char *ligne, int depuis, int tant, char* dans)
+void IGES_copstr(char *line, int depuis, int tant, char* dans)
 {
   int i;
-  for (i = 0; i < tant; i ++) { dans[i] = ligne[depuis+i]; }
+  for (i = 0; i < tant; i ++) { dans[i] = line[depuis+i]; }
   dans[tant] = '\0';
 }
 
-/*                   Analyse section D                */
+/*                   Analysis section D                */
-void iges_Dsect (int *Dstat, int numsec, char* ligne)
+void iges_Dsect (int *Dstat, int numsec, char* line)
 {
   struct dirpart *curp;
   if (*Dstat == 0) {
     iges_newpart(numsec);
     curp = iges_get_curp();
-    curp->typ  = IGES_decode(ligne, 0,8);
+    curp->typ  = IGES_decode(line, 0,8);
-    curp->poi  = IGES_decode(ligne, 8,8);
+    curp->poi  = IGES_decode(line, 8,8);
-    curp->pdef = IGES_decode(ligne,16,8);
+    curp->pdef = IGES_decode(line,16,8);
-    curp->tra  = IGES_decode(ligne,24,8);
+    curp->tra  = IGES_decode(line,24,8);
-    curp->niv  = IGES_decode(ligne,32,8);
+    curp->niv  = IGES_decode(line,32,8);
-    curp->vue  = IGES_decode(ligne,40,8);
+    curp->vue  = IGES_decode(line,40,8);
-    curp->trf  = IGES_decode(ligne,48,8);
+    curp->trf  = IGES_decode(line,48,8);
-    curp->aff  = IGES_decode(ligne,56,8);
+    curp->aff  = IGES_decode(line,56,8);
-    curp->blk  = IGES_decode(ligne,64,2);
+    curp->blk  = IGES_decode(line,64,2);
-    curp->sub  = IGES_decode(ligne,66,2);
+    curp->sub  = IGES_decode(line,66,2);
-    curp->use  = IGES_decode(ligne,68,2);
+    curp->use  = IGES_decode(line,68,2);
-    curp->her  = IGES_decode(ligne,70,2);
+    curp->her  = IGES_decode(line,70,2);
 #ifdef VERIFPRINT
-    printf("Entite %d : type %d  ->P %d\n",numsec,typ,poi);
+    printf("Entity %d : type %d  ->P %d\n",numsec,typ,poi);
 #endif
     *Dstat = 1;
   } else if (*Dstat == 1) {
     curp = iges_get_curp();
-    curp->typ2 = IGES_decode(ligne, 0,8);
+    curp->typ2 = IGES_decode(line, 0,8);
-    curp->epa  = IGES_decode(ligne, 8,8);
+    curp->epa  = IGES_decode(line, 8,8);
-    curp->col  = IGES_decode(ligne,16,8);
+    curp->col  = IGES_decode(line,16,8);
-    curp->nbl  = IGES_decode(ligne,24,8);
+    curp->nbl  = IGES_decode(line,24,8);
-    curp->form = IGES_decode(ligne,32,8);
+    curp->form = IGES_decode(line,32,8);
-    IGES_copstr (ligne,40,8,curp->res1);
+    IGES_copstr (line,40,8,curp->res1);
-    IGES_copstr (ligne,48,8,curp->res2);
+    IGES_copstr (line,48,8,curp->res2);
-    IGES_copstr (ligne,56,8,curp->nom);
+    IGES_copstr (line,56,8,curp->nom);
-    IGES_copstr (ligne,64,8,curp->num);
+    IGES_copstr (line,64,8,curp->num);
 #ifdef VERIFPRINT
-    printf("Entite %d : type %d (redite) form %d\n",numsec,typ2,form);
+    printf("Entity %d : type %d (redite) form %d\n",numsec,typ2,form);
 #endif
     *Dstat = 0;
   }
 }
 
 
-/*     Lecture section P : preanalyse
+/*     Reading section P: pre-analysis
-       Extraction du numero D et troncature a 64 caracteres  */
+       Extraction of D number and truncation to 64 characters  */
 
-void iges_Psect (int numsec, char ligne[80])
+void iges_Psect (int numsec, char line[80])
 {
   int dnum;
-  dnum = atoi(&ligne[65]);
+  dnum = atoi(&line[65]);
-  ligne[64] = '\0';
+  line[64] = '\0';
   iges_curpart(dnum);
 #ifdef VERIFPRINT
-  printf("Entite P:%d ->D:%d,soit %s\n",numsec,dnum,ligne);
+  printf("Entity P:%d ->D:%d,soit %s\n",numsec,dnum,line);
 #else
   (void)numsec; // just to avoid warning
 #endif
 }
 
 
-/*     Depiautage ligne section P (ou G)
+/*     Parsing line section P (or G)
-       Fractionnement en parametres
+       Parameter breakdown
-       Separes par Separateur courant (c_separ), de fin (c_fin), plus
+       Separated by current Separator (c_separ), end (c_fin), plus
-       traitement des caracteres sous forme Hollerith ... (nnnH...)
+       character processing in Hollerith form ... (nnnH...)
 
-       Pstat entree : 0 debut entite, 1 debut ligne, 2 courant, 3 pas fini(H)
+       Pstat input : 0 entity start, 1 line start, 2 current, 3 not finished(H)
-       Pstat retour : 0 fin entite, 1 fin ligne, 2 courant (en voila un), 3
+       Pstat return : 0 entity end, 1 line end, 2 current (here's one), 3
-          pas fini (un nnnH... pas termine)
+          not finished (a nnnH... not finished)
 */
 
 static int nbcarH = 0; static int numcar = 0; static int reste = 0;
-/*  reste : 0 cas normal; 1 completer parametre; -1 le sauter  */
+/*  reste: 0 normal case; 1 complete parameter; -1 skip it  */
 static int typarg;
-/*  +  definitions des types de parametres en tete  */
+/*  +  parameter type definitions at head  */
 
 
-void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
+void iges_param (int *Pstat, char *line, char c_separ, char c_fin, int lonlin)
 {
   int i,i0,j; char param[80]; char unpar;
   if (*Pstat == 0) reste  = 0;
@@ -156,17 +156,17 @@ void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
   else {
     numcar = nbcarH;
     if (numcar > lonlin) {
-      iges_addparam(lonlin,ligne);
+      iges_addparam(lonlin,line);
       nbcarH -= lonlin;   /*  ??? enregistrer ...  ???  */
       return;
     } else {
-      iges_addparam(nbcarH,ligne);
+      iges_addparam(nbcarH,line);
       nbcarH = 0;
     }
   }
-  i0 = 0;     /*  debut param utile (apres blancs eventuels), par defaut a 0 */
+  i0 = 0;     /*  useful param start (after possible blanks), default to 0 */
   typarg = ArgVide;
-  for (i = 0; (unpar = ligne[numcar+i]) != '\0'; i ++) {
+  for (i = 0; (unpar = line[numcar+i]) != '\0'; i ++) {
     if (unpar == c_separ) {
       *Pstat = 2;  param[i] = '\0';
 #ifdef VERIFPRINT
@@ -175,7 +175,7 @@ void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
       if (reste == 0) iges_newparam(typarg,i-i0+1,&param[i0]);
       else if (reste > 0) iges_addparam(i-i0+1,&param[i0]);
       reste = 0;
-      for (j = i+1; (unpar = ligne[numcar+j]) != '\0'; j++) {
+      for (j = i+1; (unpar = line[numcar+j]) != '\0'; j++) {
 	if (unpar != ' ') { numcar += i+1; return; }
       }
       *Pstat = 1; return;
@@ -192,7 +192,7 @@ void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
     }
     param[i] = unpar;
 
-/*    Type du parametre ? */
+/*    Parameter type ? */
 
     if (unpar > 47 && unpar < 58) {
       if (typarg == ArgInt) continue;
@@ -225,8 +225,8 @@ void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
 	if (param[j] > 47 && param[j] < 58) nbcarH = nbcarH*10 + (param[j]-48);
 	else { nbcarH = 0; break; }
       }
-      if (numcar+i+nbcarH >= lonlin) {   /* texte a cheval sur +ieurs lignes */
+      if (numcar+i+nbcarH >= lonlin) {   /* text spanning multiple lines */
-	for (j = 1; j < lonlin-numcar-i; j++) param[i+j] = ligne[numcar+i+j];
+	for (j = 1; j < lonlin-numcar-i; j++) param[i+j] = line[numcar+i+j];
 	param[lonlin-numcar] = '\0';
 	nbcarH = (numcar+i +nbcarH+1 -lonlin);
 	*Pstat =3;
@@ -237,28 +237,28 @@ void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
 	reste = 1;
 	return;
       } else {
-	for (j = 1; j <= nbcarH; j++) param[i+j] = ligne[numcar+i+j];
+	for (j = 1; j <= nbcarH; j++) param[i+j] = line[numcar+i+j];
         i += nbcarH;
       }
     }
 
-/*   blanc : leading (facile) ou trailing (chercher la suite), sinon mauvais */
+/*   blank : leading (easy) or trailing (look for continuation), otherwise bad */
     else if (unpar == ' ') {
       if (typarg == ArgVide) i0 = i+1;
       else {
-	for (j = i+1; (unpar = ligne[numcar+j]) != '\0' ; j ++) {
+	for (j = i+1; (unpar = line[numcar+j]) != '\0' ; j ++) {
 	  if (unpar == c_separ || unpar == c_fin) break;
 	  if (unpar != ' ')  {  typarg = ArgQuid;  break;  }
 	}
       }
     }
 
-    else typarg = ArgQuid;   /* caractere non reconnu */
+    else typarg = ArgQuid;   /* unrecognized character */
   }
-/*  Ici, fin de ligne sans separateur : noter parametre en cours !  */
+/*  Here, end of line without separator : note current parameter !  */
   *Pstat = 1;  param[i] = '\0'; reste = -1;
 #ifdef VERIFPRINT
-  printf ("Fin de ligne sans separateur, numcar,i : %d %d\n",numcar,i);
+  printf ("End of line without separator, numcar,i : %d %d\n",numcar,i);
   if (i > i0) printf("numcar = %d type %d param: %s ",numcar,typarg,&param[i0]);
 #endif
   if (i > i0) iges_newparam(typarg,i-i0+1,&param[i0]);

src/DataExchange/TKDEIGES/IGESFile/igesread.c

@@ -13,7 +13,7 @@
  commercial license or contractual agreement.
 */
 
-/*  Regroupement des sources "C" pour compilation   */ 
+/*  Grouping of "C" sources for compilation   */ 
 #include <stdio.h>
 #include "igesread.h"
 #include <OSD_OpenFile.hxx>
@@ -24,7 +24,7 @@ void IGESFile_Check21 (int mode,char * code, int num, char * str);
 void IGESFile_Check3 (int mode,char * code);
 void IGESFile_Check2 (int mode,char * code, int num, char * str);
 
-/*  #include "structiges.c"    ...  fait par analiges qui en a l'usage  ...  */
+/*  #include "structiges.c"    ...  done by analiges which uses it  ...  */
 void iges_initfile();
 int  iges_lire (FILE* lefic, int *numsec, char ligne[100], int modefnes);
 void iges_newparam(int typarg,int longval, char *parval);
@@ -34,12 +34,12 @@ void iges_Psect(int numsec,char ligne[80]);
 
 
 
-/*  Routine de lecture generale d'un fichier IGES
+/*  General reading routine for an IGES file
-    Assure l'enchainement des appels necessaires
+    Ensures the chaining of necessary calls
-    Il en resulte un ensemble de donnees (struct C) interrogeables par
+    Results in a set of data (struct C) queryable by
-    routines ad hoc  (cf igesread.h qui les recapitule pour appel par C++)
+    ad hoc routines (see igesread.h which summarizes them for C++ call)
 
-    Retourne : 0 si OK, 1 si fichier pas pu etre ouvert
+    Returns: 0 if OK, 1 if file could not be opened
   */
 
 
@@ -64,7 +64,7 @@ int igesread (char* nomfic, int lesect[6], int modefnes)
   lefic = stdin; i0 = numsec = 0;  numl = 0;
   if (nomfic[0] != '\0') 
     lefic = OSD_OpenFile(nomfic,"r");
-  if (lefic == NULL) return -1;    /*  fichier pas pu etre ouvert  */
+  if (lefic == NULL) return -1;    /*  file could not be opened  */
   for (i = 1; i < 6; i++) lesect[i] = 0;
   for (j = 0; j < 100; j++) ligne[j] = 0;
   for(;;) {
@@ -102,7 +102,7 @@ int igesread (char* nomfic, int lesect[6], int modefnes)
     if (i == 2) {                                   /* Header (Global sect) */
       iges_setglobal();
       for (;;) {
-        if (lesect[i] == 1) {    /* Separation specifique */
+        if (lesect[i] == 1) {    /* Specific separation */
           int n0 = 0;
           if (ligne[0] != ',') {  c_separ = ligne[2]; n0 = 3;  }
           if (ligne[n0+1] != c_separ) { c_fin = ligne[n0+3]; }
@@ -112,7 +112,7 @@ int igesread (char* nomfic, int lesect[6], int modefnes)
       }
     }
     if (i == 3) iges_Dsect(&Dstat,numsec,ligne);    /* Directory  (Dsect) */
-    if (i == 4) {                                   /* Parametres (Psect) */
+    if (i == 4) {                                   /* Parameters (Psect) */
       iges_Psect(numsec,ligne);
       for (;;) {
         iges_param(&Pstat,ligne,c_separ,c_fin,64);

src/DataExchange/TKDEIGES/IGESFile/igesread.h

@@ -13,7 +13,7 @@
  commercial license or contractual agreement.
 */
 
-/* Appel externe aux routines de lecture (en C) */
+/* External call to reading routines (in C) */
 #include <stdio.h>
 
 /*  structiges : */
@@ -25,10 +25,10 @@ struct parlist
 
 struct dirpart
 {
-  int            typ, poi, pdef, tra, niv, vue, trf, aff, blk, sub, use, her; /* ligne 1 */
+  int            typ, poi, pdef, tra, niv, vue, trf, aff, blk, sub, use, her; /* line 1 */
-  int            typ2, epa, col, nbl, form;                                   /* ligne 2 */
+  int            typ2, epa, col, nbl, form;                                   /* line 2 */
   char           res1[10], res2[10], nom[10], num[10];
-  struct parlist list;    /* liste Psect */
+  struct parlist list;    /* Psect list */
   int            numpart; /* n0 en Dsect */
 };
 
@@ -49,11 +49,11 @@ extern "C"
   struct dirpart* iges_get_curp(void);
 
   void iges_initfile();
-  int  iges_lire(FILE* lefic, int* numsec, char ligne[100], int modefnes);
+  int  iges_lire(FILE* lefic, int* numsec, char line[100], int modefnes);
   void iges_newparam(int typarg, int longval, char* parval);
-  void iges_param(int* Pstat, char* ligne, char c_separ, char c_fin, int lonlin);
+  void iges_param(int* Pstat, char* line, char c_separ, char c_fin, int lonlin);
-  void iges_Dsect(int* Dstat, int numsec, char* ligne);
+  void iges_Dsect(int* Dstat, int numsec, char* line);
-  void iges_Psect(int numsec, char ligne[80]);
+  void iges_Psect(int numsec, char line[80]);
 
   /* MGE 20/07/98 */
   void IGESFile_Check2(int mode, char* code, int num, char* str);
@@ -63,13 +63,13 @@ extern "C"
 }
 #endif
 
-/*  Definition des types de parametres de l'analyseur de base IGES */
+/*  Definition of parameter types for the basic IGES analyzer */
 #define ArgVide 0
 #define ArgQuid 1
 #define ArgChar 2
-#define ArgInt 3  /* Entier non signe : peut evoluer vers Real ou Char */
+#define ArgInt 3  /* Unsigned integer: can evolve to Real or Char */
-#define ArgSign 4 /* Entier signe : peut evoluer vers Real */
+#define ArgSign 4 /* Signed integer: can evolve to Real */
 #define ArgReal 5
-#define ArgExp 6  /* Real + lettre E : attendre confirmation */
+#define ArgExp 6  /* Real + letter E: wait for confirmation */
-#define ArgRexp 7 /* Real + Exposant : se ramene a Real */
+#define ArgRexp 7 /* Real + Exponent: reduces to Real */
-#define ArgMexp 8 /* Real + Exposant INCOMPLET (pas de point decimal) */
+#define ArgMexp 8 /* Real + INCOMPLETE Exponent (no decimal point) */

src/DataExchange/TKDEIGES/IGESFile/liriges.c

@@ -15,74 +15,74 @@
 
 #include "igesread.h"
 #include <string.h>
-/*    Routine de base de lecture d'un fichier IGES
+/*    Basic routine for reading an IGES file
 
-      Cette routine lit une ligne, sauf si le statut "relire sur place" est mis
+      This routine reads a line, except if the "re-read in place" status is set
-      (utilise pour changement de section) : il est reannule ensuite
+      (used for section change): it is reset afterwards
 
-  Cette routine retourne :
+  This routine returns:
-  - statut (retour fonction) : no de section : S,G,D,P,T (car 73) ou
+  - status (function return): section no: S,G,D,P,T (char 73) or
-    0 (EOF) ou -1 (tacher de sauter) ou -2 (car. 73 faux)
+    0 (EOF) or -1 (try to skip) or -2 (char 73 false)
-  - un numero de ligne dans la section (car. 74 a 80)
+  - a line number in the section (char 74 to 80)
-  - la ligne tronquee a 72 caracteres (0 binaire dans le 73ieme)
+  - the line truncated to 72 characters (binary 0 in the 73rd)
-  Il faut lui fournir (buffer) une ligne reservee a 81 caracteres
+  Must provide it (buffer) a line reserved for 81 characters
 
-  Cas d erreur : ligne fausse des le debut -> abandon. Sinon tacher d enjamber
+  Error case: false line from the start -> abort. Otherwise try to step over
 */
 
 static int iges_fautrelire = 0;
-int  iges_lire (FILE* lefic, int *numsec, char ligne[100], int modefnes)
+int  iges_lire (FILE* lefic, int *numsec, char line[100], int modefnes)
-/*int iges_lire (lefic,numsec,ligne,modefnes)*/
+/*int iges_lire (lefic,numsec,line,modefnes)*/
-/*FILE* lefic; int *numsec; char ligne[100]; int modefnes;*/
+/*FILE* lefic; int *numsec; char line[100]; int modefnes;*/
 {
   int i,result; char typesec;
 /*  int length;*/
   if (iges_fautrelire == 0)
   {
     if (*numsec == 0)
-      ligne[72] = ligne[79] = ' ';
+      line[72] = line[79] = ' ';
 
-    ligne[0] = '\0'; 
+    line[0] = '\0'; 
     if(modefnes)
     {
-      if (fgets(ligne,99,lefic) == NULL) /*for kept compatibility with fnes*/
+      if (fgets(line,99,lefic) == NULL) /*for kept compatibility with fnes*/
         return 0;
     }
     else
     {
       /* PTV: 21.03.2002 it is necessary for files that have only `\r` but no `\n`
               example file is 919-001-T02-04-CP-VL.iges */
-      while ( fgets ( ligne, 2, lefic ) && ( ligne[0] == '\r' || ligne[0] == '\n' ) )
+      while ( fgets ( line, 2, lefic ) && ( line[0] == '\r' || line[0] == '\n' ) )
       {
       }
       
-      if (fgets(&ligne[1],80,lefic) == NULL)
+      if (fgets(&line[1],80,lefic) == NULL)
         return 0;
     }
     
-    if (*numsec == 0 && ligne[72] != 'S' && ligne[79] == ' ')
+    if (*numsec == 0 && line[72] != 'S' && line[79] == ' ')
-    {/*        ON A DU FNES : Sauter la 1re ligne          */
+    {/*        WE HAVE FNES: Skip the 1st line          */
-      ligne[0] = '\0';
+      line[0] = '\0';
       
       if(modefnes)
       {
-        if (fgets(ligne,99,lefic) == NULL) /*for kept compatibility with fnes*/
+        if (fgets(line,99,lefic) == NULL) /*for kept compatibility with fnes*/
           return 0;
       }
       else
       {
-        while ( fgets ( ligne, 2, lefic ) && ( ligne[0] == '\r' || ligne[0] == '\n' ) )
+        while ( fgets ( line, 2, lefic ) && ( line[0] == '\r' || line[0] == '\n' ) )
         {
         }
-        if (fgets(&ligne[1],80,lefic) == NULL)
+        if (fgets(&line[1],80,lefic) == NULL)
           return 0;
       }
     }
 
-    if ((ligne[0] & 128) && modefnes)
+    if ((line[0] & 128) && modefnes)
     {
       for (i = 0; i < 80; i ++)
-        ligne[i] = (char)(ligne[i] ^ (150 + (i & 3)));
+        line[i] = (char)(line[i] ^ (150 + (i & 3)));
     }
   }
 
@@ -90,7 +90,7 @@ int  iges_lire (FILE* lefic, int *numsec, char ligne[100], int modefnes)
     return 0;
 
   {//0x1A is END_OF_FILE for OS DOS and WINDOWS. For other OS we set this rule forcefully.
-    char *fc = strchr(ligne, 0x1A);
+    char *fc = strchr(line, 0x1A);
     if(fc != 0)
     {
       fc[0] = '\0';
@@ -99,38 +99,38 @@ int  iges_lire (FILE* lefic, int *numsec, char ligne[100], int modefnes)
   }
 
   iges_fautrelire = 0;
-  if (ligne[0] == '\0' || ligne[0] == '\n' || ligne[0] == '\r')
+  if (line[0] == '\0' || line[0] == '\n' || line[0] == '\r')
-    return iges_lire(lefic,numsec,ligne,modefnes); /* 0 */
+    return iges_lire(lefic,numsec,line,modefnes); /* 0 */
 
-  if (sscanf(&ligne[73],"%d",&result) != 0) {
+  if (sscanf(&line[73],"%d",&result) != 0) {
     *numsec = result;
-    typesec = ligne[72];
+    typesec = line[72];
     switch (typesec) {
-     case 'S' :  ligne[72] = '\0'; return (1);
+     case 'S' :  line[72] = '\0'; return (1);
-     case 'G' :  ligne[72] = '\0'; return (2);
+     case 'G' :  line[72] = '\0'; return (2);
-     case 'D' :  ligne[72] = '\0'; return (3);
+     case 'D' :  line[72] = '\0'; return (3);
-     case 'P' :  ligne[72] = '\0'; return (4);
+     case 'P' :  line[72] = '\0'; return (4);
-     case 'T' :  ligne[72] = '\0'; return (5);
+     case 'T' :  line[72] = '\0'; return (5);
      default  :;
     }
     /* the column 72 is empty, try to check the neighbour*/
-    if(strlen(ligne)==80 
+    if(strlen(line)==80 
-        && (ligne[79]=='\n' || ligne[79]=='\r') && (ligne[0]<='9' && ligne[0]>='0')) {
+        && (line[79]=='\n' || line[79]=='\r') && (line[0]<='9' && line[0]>='0')) {
        /*check in case of loss.*/
        int index;
-       for(index = 1; ligne[index]<='9' && ligne[index]>='0'; index++);
+       for(index = 1; line[index]<='9' && line[index]>='0'; index++);
-       if (ligne[index]=='D' || ligne[index]=='d') {
+       if (line[index]=='D' || line[index]=='d') {
          for(index = 79; index > 0; index--)
-           ligne[index] = ligne[index-1];
+           line[index] = line[index-1];
-         ligne[0]='.';
+         line[0]='.';
        }
-       typesec = ligne[72];
+       typesec = line[72];
        switch (typesec) {
-       case 'S' :  ligne[72] = '\0'; return (1);
+       case 'S' :  line[72] = '\0'; return (1);
-       case 'G' :  ligne[72] = '\0'; return (2);
+       case 'G' :  line[72] = '\0'; return (2);
-       case 'D' :  ligne[72] = '\0'; return (3);
+       case 'D' :  line[72] = '\0'; return (3);
-       case 'P' :  ligne[72] = '\0'; return (4);
+       case 'P' :  line[72] = '\0'; return (4);
-       case 'T' :  ligne[72] = '\0'; return (5);
+       case 'T' :  line[72] = '\0'; return (5);
        default  :;
       }
     }
@@ -138,33 +138,33 @@ int  iges_lire (FILE* lefic, int *numsec, char ligne[100], int modefnes)
 
   // the line is not conform to standard, try to read it (if there are some missing spaces)
   // find the number end
-  i = (int)strlen(ligne);
+  i = (int)strlen(line);
-  while ((ligne[i] == '\0' || ligne[i] == '\n' || ligne[i] == '\r' || ligne[i] == ' ') && i > 0)
+  while ((line[i] == '\0' || line[i] == '\n' || line[i] == '\r' || line[i] == ' ') && i > 0)
     i--;
-  if (i != (int)strlen(ligne))
+  if (i != (int)strlen(line))
-    ligne[i + 1] = '\0';
+    line[i + 1] = '\0';
   // find the number start
-  while (ligne[i] >= '0' && ligne[i] <= '9' && i > 0)
+  while (line[i] >= '0' && line[i] <= '9' && i > 0)
     i--;
-  if (sscanf(&ligne[i + 1],"%d",&result) == 0)
+  if (sscanf(&line[i + 1],"%d",&result) == 0)
     return -1;
   *numsec = result;
   // find type of line
-  while (ligne[i] == ' ' && i > 0)
+  while (line[i] == ' ' && i > 0)
     i--;
-  typesec = ligne[i];
+  typesec = line[i];
   switch (typesec) {
-    case 'S' :  ligne[i] = '\0'; return (1);
+    case 'S' :  line[i] = '\0'; return (1);
-    case 'G' :  ligne[i] = '\0'; return (2);
+    case 'G' :  line[i] = '\0'; return (2);
-    case 'D' :  ligne[i] = '\0'; return (3);
+    case 'D' :  line[i] = '\0'; return (3);
-    case 'P' :  ligne[i] = '\0'; return (4);
+    case 'P' :  line[i] = '\0'; return (4);
-    case 'T' :  ligne[i] = '\0'; return (5);
+    case 'T' :  line[i] = '\0'; return (5);
-    default  :; /* printf("Ligne incorrecte, ignoree n0.%d :\n%s\n",*numl,ligne); */
+    default  :; /* printf("Incorrect line, ignored n0.%d :\n%s\n",*numl,line); */
   }
   return -1;
 }
 
-/*          Pour commander la relecture sur place            */
+/*          To control re-reading in place            */
 
 void iges_arelire()
 {  iges_fautrelire = 1;  }

src/DataExchange/TKDEIGES/IGESFile/structiges.c

@@ -18,19 +18,19 @@
 
 #include "igesread.h"
 
-/*   Structures temporaires IGES (enregistrement des entites et parametres)
+/*   Temporary IGES structures (recording entities and parameters)
-     Comprennent : les declarations, et la gestion de l'entite en cours  */
+     Include: declarations, and management of the current entity  */
 
 static int nbparts;
 static int nbparams;
 
-/*                Liste de parametres IGES (header ou current part)        */
+/*                IGES parameter list (header or current part)        */
 static struct parlist *curlist;
-static struct parlist *starts;   /*  Start Section du fichier IGES  */
+static struct parlist *starts;   /*  Start Section of IGES file  */
-static struct parlist *header;   /*  Entete du fichier IGES  */
+static struct parlist *header;   /*  Header of IGES file  */
 
 
-/*                Declaration d'une portion de Directory IGES              */
+/*                Declaration of a portion of IGES Directory              */
 static struct dirpart *curp;
 
 struct dirpart *iges_get_curp (void)
@@ -38,7 +38,7 @@ struct dirpart *iges_get_curp (void)
   return curp;
 }
 
-/*                   Declaration d'un parametre IGES (Psect)              */
+/*                   Declaration of an IGES parameter (Psect)              */
 static struct oneparam {
   struct oneparam *next;
   int typarg;
@@ -53,7 +53,7 @@ static struct dirpage {
 } *firstpage = NULL;
 
 #define Maxpar 20000
-static struct parpage {    /* une page de parametres ; cf AddParam */
+static struct parpage {    /* a page of parameters; see AddParam */
   struct parpage* next;
   int             used;
   struct oneparam params[Maxpar+1];
@@ -64,28 +64,28 @@ static int curnumpart = 0;
 static struct dirpage *curpage;
 
 
-/*           ROUTINES UTILITAIRES de traitement des textes (char*)          */
+/*           UTILITY ROUTINES for text processing (char*)          */
 
-/*     Gestion du texte courant : c'est un texte alloue dynamiquement
+/*     Current text management: it's a dynamically allocated text
-       iges_newchar en alloue un (jete le precedent alloue si pas lu)
+       iges_newchar allocates one (discards the previous allocated if not read)
-       rec_gettext lit le texte en cours, qui ne sera pas desalloue ensuite
+       rec_gettext reads the current text, which will not be deallocated afterwards
-       rec_settext en force un autre en jetant le precedent (idem rec_newtext)
+       rec_settext forces another by discarding the previous (same as rec_newtext)
-       tandis que rec_newtext alloue un texte, sans lien avec le courant
+       while rec_newtext allocates a text, without link to the current one
 */
 
 #define Maxcar 10000
 
   static struct carpage {
-    struct carpage* next;        /*  chainage des pages de caracteres  */
+    struct carpage* next;        /*  chaining of character pages  */
-    int             used;        /*  place deja prise  */
+    int             used;        /*  space already taken  */
-    char  cars[Maxcar+1];        /*  page de caracteres  */
+    char  cars[Maxcar+1];        /*  character page  */
   } *onecarpage;
 
-  static char* restext = NULL ;  /* texte courant  (allocation dynamique) */
+  static char* restext = NULL ;  /* current text  (dynamic allocation) */
-/*  static int   resalloc = 0 ; */    /*   alloue (memoire a liberer) ou non   */
+/*  static int   resalloc = 0 ; */    /*   allocated (memory to free) or not   */
 
-/*    Utilitaire : Reservation de caracteres
+/*    Utility: Character reservation
-      Remplace suite de mini-malloc par gestion de page   */
+      Replaces series of mini-malloc with page management   */
 
 static char* iges_newchar (int lentext)
 {
@@ -107,9 +107,9 @@ static char* iges_newchar (int lentext)
 }
 
 
-/*             FICHIER  IGES  Proprement Dit             */
+/*             IGES FILE  Properly Speaking             */
 
-/*             Initialisation de l'enregistrement d'un fichier            */
+/*             Initialization of file recording            */
 void iges_initfile()
 {
   onecarpage = (struct carpage*) malloc ( sizeof(struct carpage) );
@@ -122,19 +122,19 @@ void iges_initfile()
   header = (struct parlist*) malloc ( sizeof(struct parlist) );
   header->first = header->last = NULL; header->nbparam = 0;
 
-  curlist = starts;    /* On commence a enregistrer la start section */
+  curlist = starts;    /* We start recording the start section */
   nbparts = nbparams = 0;
   firstpage = (struct dirpage*) malloc ( sizeof(struct dirpage) );
   firstpage->next = NULL; firstpage->used = 0;
   curpage = firstpage;
 }  
 
-/*   Passage au Header (Global Section), lecture comme ecriture    */
+/*   Switch to Header (Global Section), reading as writing    */
 void iges_setglobal()
 {  if (curlist == header) return;  curlist = header;    curparam = curlist->first;  }
 
 
-/*   Definition et Selection d'un nouveau dirpart   */
+/*   Definition and Selection of a new dirpart   */
 
 void iges_newpart(int numsec)
 {
@@ -153,7 +153,7 @@ void iges_newpart(int numsec)
 }
 
 
-/*   Selection du dirpart dnum, correspond a numsec en Psect   */
+/*   Selection of dirpart dnum, corresponds to numsec in Psect   */
 
 void iges_curpart (int dnum)
 {
@@ -181,20 +181,20 @@ void iges_curpart (int dnum)
     }
     curpage = curpage->next;
   }
-  curp = NULL;    /*  pas trouve  */
+  curp = NULL;    /*  not found  */
 }
 
 
-/*     Definition d'un nouveau parametre    */
+/*     Definition of a new parameter    */
-/*   (manque la gestion d'un Hollerith sur plusieurs lignes)   */
+/*   (missing management of Hollerith over multiple lines)   */
 
-/*   longval : longueur de parval, incluant le zero final   */
+/*   longval: length of parval, including the final zero   */
 void iges_newparam (int typarg, int longval, char *parval)
 {
   char *newval;
   int i;
 
-  if (curlist == NULL) return;      /*  non defini : abandon  */
+  if (curlist == NULL) return;      /*  not defined: abort  */
 
   newval = iges_newchar(longval);
   for (i = 0; i < longval; i++) newval[i] = parval[i];
@@ -218,7 +218,7 @@ void iges_newparam (int typarg, int longval, char *parval)
   nbparams ++;
 }
 
-/*     Complement du parametre courant (cf Hollerith sur +ieurs lignes)    */
+/*     Complement of current parameter (see Hollerith over multiple lines)    */
 void iges_addparam (int longval, char* parval)
 {
   char *newval, *oldval;
@@ -235,9 +235,9 @@ void iges_addparam (int longval, char* parval)
 }
 
 
-/*               Relecture : Initialiation              */
+/*               Re-reading: Initialization              */
-/*  entites relues par suite de lirpart + {lirparam}
+/*  entities re-read following lirpart + {lirparam}
-    lirparam initiaux : pour relire le demarrage (start section)   */
+    initial lirparam: to re-read the startup (start section)   */
 void iges_stats (int* nbpart, int* nbparam)
 {
   curpage  = firstpage; curnumpart = 0;
@@ -247,9 +247,9 @@ void iges_stats (int* nbpart, int* nbparam)
   *nbparam = nbparams;
 }
 
-/*      Lecture d'une part : retour = n0 section, 0 si fin         */
+/*      Reading a part: return = section n0, 0 if end         */
-/* \par tabval tableau recepteur des entiers (reserver 17 valeurs) */
+/* \par tabval integer receiver array (reserve 17 values) */
-/* \par res1 res2 nom num char : transmis a part */
+/* \par res1 res2 nom num char: transmitted to part */
 int iges_lirpart (int* *tabval, char* *res1, char* *res2, char* *nom, char* *num, int *nbparam)
 {
   if (curpage == NULL) return 0;
@@ -257,24 +257,24 @@ int iges_lirpart (int* *tabval, char* *res1, char* *res2, char* *nom, char* *num
   curlist = &(curp->list);
   *nbparam = curlist->nbparam;
   curparam = curlist->first;
-  *tabval = &(curp->typ);    /* adresse de curp = adresse du tableau */
+  *tabval = &(curp->typ);    /* address of curp = address of array */
   *res1 = curp->res1; *res2 = curp->res2;
   *nom  = curp->nom;  *num  = curp->num;
   return curp->numpart;
 }
 
-/*               Passage au suivant (une fois lus les parametres)          */
+/*               Move to next (once parameters are read)          */
 void iges_nextpart()
 {
   curnumpart ++;
-  if (curnumpart >= curpage->used) {  /* attention, adressage de 0 a used-1 */
+  if (curnumpart >= curpage->used) {  /* caution, addressing from 0 to used-1 */
     curpage = curpage->next;
     curnumpart = 0;
   }
 }
 
-/*               Lecture parametre + passage au suivant                   */
+/*               Read parameter + move to next                   */
-int iges_lirparam (int *typarg, char* *parval)    /* renvoie 0 si fin de liste, 1 sinon */
+int iges_lirparam (int *typarg, char* *parval)    /* returns 0 if end of list, 1 otherwise */
 {
   if (curparam == NULL) return 0;
   *typarg = curparam->typarg;
@@ -283,8 +283,8 @@ int iges_lirparam (int *typarg, char* *parval)    /* renvoie 0 si fin de liste,
   return 1;
 }
 
-/*               Fin pour ce fichier : liberer la place                  */
+/*               End for this file: free the space                  */
-/*    mode = 0 : tout; 1 : parametres; 2 : caracteres  */
+/*    mode = 0: all; 1: parameters; 2: characters  */
 void iges_finfile (int mode)
 {
   struct dirpage* oldpage;

src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ConicArc.cxx

@@ -238,7 +238,7 @@ void IGESGeom_ConicArc::ComputedDefinition(Standard_Real& Xcen,
 
   if (IsFromParabola())
   {
-    Rmin = Rmax = -1.; // rayons : yena pas
+    Rmin = Rmax = -1.; // radii : there are none
     if ((Abs(a) <= eps) && (Abs(b) <= eps))
     {
       Xcen                = (f * c - e * e) / c / d / 2.;
@@ -274,11 +274,11 @@ void IGESGeom_ConicArc::ComputedDefinition(Standard_Real& Xcen,
 
   else
   {
-    //   -> Conique a centre, cas general
+    //   -> Centered conic, general case
-    //  On utilise les Determinants des matrices :
+    //  We use the matrix Determinants :
     //               | a b d |
-    //  gdet (3x3) = | b c e |  et pdet (2X2) = | a b |
+    //  gdet (3x3) = | b c e |  and pdet (2X2) = | a b |
-    //               | d e f |                  | b c |
+    //               | d e f |                   | b c |
 
     Standard_Real gdet = a * c * f + 2 * b * d * e - c * d * d - a * e * e - b * b * f;
     Standard_Real pdet = a * c - b * b;

src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_CopiousData.cxx

@@ -59,7 +59,7 @@ void IGESGeom_CopiousData::SetPolyline(const Standard_Boolean F)
 
 void IGESGeom_CopiousData::SetClosedPath2D()
 {
-  InitTypeAndForm(106, 63); // et verifier DataType !
+  InitTypeAndForm(106, 63); // and verify DataType !
 }
 
 Standard_Boolean IGESGeom_CopiousData::IsPointSet() const

src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolBSplineCurve.cxx

@@ -348,7 +348,7 @@ void IGESGeom_ToolBSplineCurve::OwnCheck(const Handle(IGESGeom_BSplineCurve)& en
   // Message_Msg Msg109("XSTEP_109");
   //========================================
 
-  Standard_Real eps = 1.E-04; // Tolerance des tests ??
+  Standard_Real eps = 1.E-04; // Test tolerance ??
                               //  Standard_Real norm = ent->Normal().SquareModulus();
 
   // modified by rln 17/12/97 check of flag PROP2 according to IGES Standard

src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolBSplineSurface.cxx

@@ -204,7 +204,7 @@ void IGESGeom_ToolBSplineSurface::ReadOwnParams(const Handle(IGESGeom_BSplineSur
     st = PR.ReadReal(PR.Current(), "Starting Value For V Direction", aVmin);
     st = PR.ReadReal(PR.Current(), "Ending Value For U Direction", aVmax);
   */
-  //  PROTECTION contre ANSYS 5.3 qui ecrit 3 flottants en plus ...
+  //  PROTECTION against ANSYS 5.3 which writes 3 additional floats ...
   Standard_Integer icur = PR.CurrentNumber(), imax = PR.NbParams();
   Standard_Real    bid;
   Standard_Integer pbfin = 0;

src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolBoundary.cxx

@@ -320,12 +320,12 @@ Standard_Boolean IGESGeom_ToolBoundary::OwnCorrect(const Handle(IGESGeom_Boundar
   if (ent->BoundaryType() != 0)
     return res; // OK
 
-  //  Reste Boundary Type : s ilya des ParameterCurves, il doit valoir 1
+  //  Remaining Boundary Type : if there are ParameterCurves, it must be valued 1
-  //  On reconstruit donc la Boundary a l identique, mais avec BoundaryType = 1
+  //  We therefore reconstruct the Boundary identically, but with BoundaryType = 1
 
-  // si type = 0, annuller tous les ParameterCurves
+  // if type = 0, nullify all ParameterCurves
-  //  -> On reconstruit, avec ParameterCurves Nulles
+  //  -> We reconstruct, with Null ParameterCurves
-  // En plus, les ParameterCurves doivent avoir leur UseFlag a 5
+  // In addition, the ParameterCurves must have their UseFlag at 5
 
   Handle(IGESBasic_HArray1OfHArray1OfIGESEntity) cv2d =
     new IGESBasic_HArray1OfHArray1OfIGESEntity(1, nb);
@@ -383,8 +383,8 @@ void IGESGeom_ToolBoundary::OwnCheck(const Handle(IGESGeom_Boundary)& ent,
     ach->SendFail(Msg123);
   }
 
-  // il faudrait aussi tester que, pour BoundaryType = 1, la Surface est bien
+  // we should also test that, for BoundaryType = 1, the Surface is indeed
-  //  Parametrique ... (au moins un cas ne passe pas : c est Plane 108)
+  //  Parametric ... (at least one case fails : it is Plane 108)
   if (ent->BoundaryType() == 1)
   {
     if (ent->Surface()->TypeNumber() == 108)

src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolCircularArc.cxx

@@ -120,7 +120,7 @@ void IGESGeom_ToolCircularArc::OwnCheck(const Handle(IGESGeom_CircularArc)& /*en
                                         Handle(Interface_Check)& /*ach*/) const
 {
   /*
-    //Standard_Real eps  = 1.E-04;    // Tolerance des tests ?? //szv#4:S4163:12Mar99 not needed
+    //Standard_Real eps  = 1.E-04;    // Test tolerance ?? //szv#4:S4163:12Mar99 not needed
 
     Standard_Real Rad1 = Sqrt(Square(ent->StartPoint().X() - ent->Center().X()) +
                   Square(ent->StartPoint().Y() - ent->Center().Y()));

src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolCurveOnSurface.cxx

@@ -225,7 +225,7 @@ void IGESGeom_ToolCurveOnSurface::OwnCheck(const Handle(IGESGeom_CurveOnSurface)
   //  Standard_Integer pref = ent->PreferenceMode();
   //  if (pref < 0 || pref > 3)
   //    ach.SendFail("Incorrect value for the Preference Mode");
-  //  tolerance a la norme
+  //  tolerance to the standard
   //  if (pref == 1 && ent->CurveUV().IsNull())
   //    ach.AddWarning("Preference Mode asks UV and Curve UV not defined");
   //  if (pref == 2 && ent->Curve3D().IsNull())

src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolOffsetCurve.cxx

@@ -287,7 +287,7 @@ Standard_Boolean IGESGeom_ToolOffsetCurve::OwnCorrect(const Handle(IGESGeom_Offs
   Handle(IGESData_IGESEntity) func = ent->Function();
   if (func.IsNull())
     return Standard_False;
-  //  OffsetType != 3 : reconstruire avec Offset Function Nulle
+  //  OffsetType != 3 : reconstruct with Null Offset Function
   func.Nullify();
   ent->Init(ent->BaseCurve(),
             ent->OffsetType(),

src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolPlane.cxx

@@ -99,7 +99,7 @@ void IGESGeom_ToolPlane::ReadOwnParams(const Handle(IGESGeom_Plane)&          en
     }
   } // szv#4:S4163:12Mar99 `st=` not needed
     // st = PR.ReadEntity(IR, PR.Current(), "Bounding Curve", aCurve,Standard_True);
-  //  en principe exige si FormNumber != 0 ... cf OwnCheck (Load accepte)
+  //  in principle required if FormNumber != 0 ... see OwnCheck (Load accepts)
 
   if (PR.IsParamDefined(PR.CurrentNumber()))
   {
@@ -219,11 +219,11 @@ void IGESGeom_ToolPlane::OwnCheck(const Handle(IGESGeom_Plane)& ent,
     ach->SendFail(Msg137);
   }
   // These messages are transferred in the translation procedure
-  //  if ( (A*A + B*B + C*C) < eps)    //  pas nul !
+  //  if ( (A*A + B*B + C*C) < eps)    //  not null !
   //    ach.SendFail("Incorrect Coefficients for the Plane");
   if (!ent->HasBoundingCurve())
     return;
-  //  Symbol : verifie si Size defini > 0 (sinon, n a pas de signification)
+  //  Symbol : check if Size defined > 0 (otherwise, has no meaning)
   /*  Standard_Real ec = 0.;
     if (ent->SymbolSize() > 0.) ec = A*ent->SymbolAttach().X() + B*ent->SymbolAttach().Y() +
         C * ent->SymbolAttach().Z() - D;

src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolSplineSurface.cxx

@@ -164,8 +164,8 @@ void IGESGeom_ToolSplineSurface::ReadOwnParams(const Handle(IGESGeom_SplineSurfa
         }
         else
         {
-          //  Si fin manquante ... On refait temp !
+          //  If end missing ... We redo temp !
-          //  Les valeurs n ont pas ete lues ... il faut d abord les relire !
+          //  The values were not read ... we must first re-read them !
           Temp = new TColStd_HArray1OfReal(1, 16);
           Temp->Init(0.);
           for (k = 1; k <= 16; k++)

src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolTransformationMatrix.cxx

@@ -164,7 +164,7 @@ void IGESGeom_ToolTransformationMatrix::OwnCheck(const Handle(IGESGeom_Transform
   }
   // These messages are transferred in the translation procedure
   /*
-    if (form > 1) return;    // ce qui suit : matrice orthogonale
+    if (form > 1) return;    // what follows : orthogonal matrix
     if (form == 0 && ent->Value().IsNegative())
       ach.AddFail("For Form 0, Determinant is not Positive");
     else if (form == 1 && !ent->Value().IsNegative())

src/DataExchange/TKDEIGES/IGESGraph/IGESGraph_ToolColor.cxx

@@ -62,7 +62,7 @@ void IGESGraph_ToolColor::WriteOwnParams(const Handle(IGESGraph_Color)& ent,
   IW.Send(Red);
   IW.Send(Green);
   IW.Send(Blue);
-  //  ATTENTION  place a reserver (Null) silya des pointeurs additionnels
+  //  WARNING  place to reserve (Null) if there are additional pointers
   if (ent->HasColorName())
     IW.Send(ent->ColorName());
   else

src/DataExchange/TKDEIGES/IGESGraph/IGESGraph_ToolDrawingUnits.cxx

@@ -113,7 +113,7 @@ Standard_Boolean IGESGraph_ToolDrawingUnits::OwnCorrect(
       }
       break;
     case 3:
-      break; // nom libre
+      break; // free name
     case 4:
       if (strcmp(unm, "FT") == 0)
       {
@@ -163,7 +163,7 @@ Standard_Boolean IGESGraph_ToolDrawingUnits::OwnCorrect(
       }
       break;
     default:
-      break; // on ne peut rien faire ... ?
+      break; // we can't do anything ... ?
   }
 
   res |= (!name.IsNull());
@@ -215,7 +215,7 @@ void IGESGraph_ToolDrawingUnits::OwnCheck(const Handle(IGESGraph_DrawingUnits)&
         break;
       case 3:
         unok = Standard_True;
-        break; // nom libre
+        break; // free name
       case 4:
         unok = !strcmp(unm, "FT");
         break;

src/DataExchange/TKDEIGES/IGESSelect/IGESSelect.cxx

@@ -49,7 +49,7 @@ Standard_Integer IGESSelect::WhatIges(const Handle(IGESData_IGESEntity)& ent,
   if (igesent.IsNull() || model.IsNull())
     return 0;
 
-  //  Plane : de View ? de SingleParent ?  sinon cf TrimmedSurface & cie
+  //  Plane : from View? from SingleParent? otherwise see TrimmedSurface & co
 
   return 0;
 }

src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_Activator.cxx

@@ -114,7 +114,7 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
   switch (number)
   {
 
-    case 5:   //        ****    ListViews (sans tri complementaire)
+    case 5:   //        ****    ListViews (without additional sorting)
     case 6:   //        ****    ListDrawings
     case 7: { //        ****    ListS(ingle)Views
       Standard_Integer listmode = 0;
@@ -122,12 +122,11 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
         argc = -1;
       if (argc < 2)
       {
-        std::cout << "Ajouter un argument pour avoir :\n"
+        std::cout << "Add an argument to have :\n"
-                  << " l : liste resumee"
+                  << " l : summary list"
-                  << " c : liste complete par item (mais pas pour remaining)\n"
+                  << " c : complete list per item (but not for remaining)\n"
-                  << " r : idem + liste complete remaining\n"
+                  << " r : same + complete remaining list\n"
-                  << "  sur tout le modele. Ajouter nom selection pour lister sur une partie"
+                  << "  on entire model. Add selection name to list on a part" << std::endl;
-                  << std::endl;
         return (argc >= 0 ? IFSelect_RetError : IFSelect_RetVoid);
       }
       if (arg1[0] == 'l')
@@ -138,12 +137,12 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
       else if (arg1[0] == 'c')
       {
         listmode = 1;
-        std::cout << "Liste complete par item (pas pour Remaining)" << std::endl;
+        std::cout << "Complete list per item (not for Remaining)" << std::endl;
       }
       else if (arg1[0] == 'r')
       {
         listmode = 2;
-        std::cout << "Liste complete par item et pour Remaining" << std::endl;
+        std::cout << "Complete list per item and for Remaining" << std::endl;
       }
       else
       {
@@ -207,8 +206,8 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
     case 10: { //        ****    IGESType (form Type/Form)
       if (argc < 2)
       {
-        std::cout << "Donner le n0 de type desire, + en option la forme\n"
+        std::cout << "Give the desired type number, + optionally the form\n"
-                  << "  Si pas de forme, prend toutes les formes du type demande" << std::endl;
+                  << "  If no form, takes all forms of the requested type" << std::endl;
         return IFSelect_RetError;
       }
       char signature[20];
@@ -228,7 +227,7 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
     case 12: { //        ****    IGES Name
       if (argc < 2)
       {
-        std::cout << "Donner un Nom de TextParam pour IGESName" << std::endl;
+        std::cout << "Give a TextParam Name for IGESName" << std::endl;
         return IFSelect_RetError;
       }
       Handle(IGESSelect_SelectName) sel = new IGESSelect_SelectName;
@@ -243,13 +242,13 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
     case 14: { //        ****    IGES LevelNumber
       if (argc < 2)
       {
-        std::cout << "Donner nom IntParam pour Level" << std::endl;
+        std::cout << "Give IntParam name for Level" << std::endl;
         return IFSelect_RetError;
       }
       DeclareAndCast(IFSelect_IntParam, lev, WS->NamedItem(arg1));
       if (lev.IsNull())
       {
-        std::cout << arg1 << " : pas un IntParam (pour Level)" << std::endl;
+        std::cout << arg1 << " : not an IntParam (for Level)" << std::endl;
         return IFSelect_RetError;
       }
       Handle(IGESSelect_SelectLevelNumber) sel = new IGESSelect_SelectLevelNumber;
@@ -283,7 +282,7 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
         prem = '?';
       else if (argc == 5)
       {
-        std::cout << "floatformat tout court donne les formes admises" << std::endl;
+        std::cout << "floatformat alone gives the accepted forms" << std::endl;
         return IFSelect_RetError;
       }
       else
@@ -298,13 +297,13 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
         digits = atoi(arg1);
       else
       {
-        std::cout << "floatformat digits, digits=nb de chiffres signifiants, ou\n"
+        std::cout << "floatformat digits, digits=nb of significant digits, or\n"
                   << "floatformat NZ %mainformat [%rangeformat [Rmin Rmax]]\n"
-                  << "  NZ : N ou n pour Non-zero-suppress, Z ou z pour zero-suppress\n"
+                  << "  NZ : N or n for Non-zero-suppress, Z or z for zero-suppress\n"
-                  << " %mainformat  : format principal type printf, ex,: %E\n"
+                  << " %mainformat  : main format printf type, ex,: %E\n"
-                  << " + optionnel  : format secondaire (flottants autour de 1.) :\n"
+                  << " + optional  : secondary format (floats around 1.) :\n"
-                  << " %rangeformat Rmin Rmax : format type printf entre Rmin et Rmax\n"
+                  << " %rangeformat Rmin Rmax : printf type format between Rmin and Rmax\n"
-                  << " %rangeformat tout seul : format type printf entre 0.1 et 1000.\n"
+                  << " %rangeformat alone : printf type format between 0.1 and 1000.\n"
                   << std::flush;
         return (prem == '?' ? IFSelect_RetVoid : IFSelect_RetError);
       }
@@ -339,7 +338,7 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
     case 41: { //        ****    SetGlobalParameter
       if (argc < 3)
       {
-        std::cout << "Donner entier=n0 param a changer + nom TextParam pour la valeur" << std::endl;
+        std::cout << "Give integer=n0 param to change + TextParam name for the value" << std::endl;
         return IFSelect_RetError;
       }
       Standard_Integer numpar = atoi(arg1);
@@ -391,8 +390,8 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
     case 60: { //        ****    Spline To BSpline
       if (argc < 2)
       {
-        std::cout << "Pour SplineToBSpline, donner mode :\n"
+        std::cout << "For SplineToBSpline, give mode :\n"
-                  << " n pour normal, t pour tryC2" << std::endl;
+                  << " n for normal, t for tryC2" << std::endl;
         return IFSelect_RetError;
       }
       Standard_Boolean tryC2;
@@ -452,11 +451,11 @@ Standard_CString IGESSelect_Activator::Help(const Standard_Integer number) const
   switch (number)
   {
     case 5:
-      return "Liste Vues (tous types). Nom selection sinon tout modele";
+      return "List Views (all types). Selection name otherwise entire model";
     case 6:
-      return "Liste Drawings. Nom selection sinon tout modele";
+      return "List Drawings. Selection name otherwise entire model";
     case 7:
-      return "Liste Vues SIMPLES. Nom selection sinon tout modele";
+      return "List SIMPLE Views. Selection name otherwise entire model";
 
     case 10:
       return "type:integer [form:integer]  : cree Select IGESType";
@@ -472,21 +471,21 @@ Standard_CString IGESSelect_Activator::Help(const Standard_Integer number) const
     case 21:
       return "cree Select From Drawing";
     case 22:
-      return "cree Select From Single View";
+      return "create Select From Single View";
     case 23:
-      return "cree Select Drawing From, drawing(s) pour une liste d entites";
+      return "create Select Drawing From, drawing(s) for an entity list";
     case 24:
-      return "cree Select View From, views pour une liste d entites";
+      return "create Select View From, views for an entity list";
 
     case 31:
-      return "cree Dispatch Per Drawing";
+      return "create Dispatch Per Drawing";
     case 32:
-      return "cree Dispatch Per SingleView";
+      return "create Dispatch Per SingleView";
 
     case 40:
-      return "options... : cree FloatFormat ... floatformat tout court->help";
+      return "options... : create FloatFormat ... floatformat alone->help";
     case 41:
-      return "numpar:integer  value:TextParam  : cree Set Global Param";
+      return "numpar:integer  value:TextParam  : create Set Global Param";
     case 42:
       return "cree Set Version -> 5.1";
     case 43:

src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_RebuildGroups.cxx

@@ -37,14 +37,14 @@ void IGESSelect_RebuildGroups::Performing(IFSelect_ContextModif&            ctx,
                                           const Handle(IGESData_IGESModel)& target,
                                           Interface_CopyTool&               TC) const
 {
-  //  On reconstruit les groupes qui peuvent l etre
+  //  We rebuild the groups that can be
-  //  Pour chaque groupe de l original, on regarde les composants transferes
+  //  For each group of the original, we look at the transferred components
-  //   (evt filtres par <ctx>)
+  //   (possibly filtered by <ctx>)
-  //  Ensuite, silyena plus d une, on refait un nouveau groupe
+  //  Then, if there are more than one, we create a new group
   DeclareAndCast(IGESData_IGESModel, original, ctx.OriginalModel());
   Standard_Integer nbo = original->NbEntities();
 
-  //  Entites a prendre en compte pour la reconstruction
+  //  Entities to consider for reconstruction
   //  NB : Les groupes deja transferes ne sont bien sur pas reconstruits !
   TColStd_Array1OfInteger pris(0, nbo);
   pris.Init(0);

src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_SelectBypassGroup.cxx

@@ -34,7 +34,7 @@ Standard_Boolean IGESSelect_SelectBypassGroup::Explore(const Standard_Integer /*
                                                        const Interface_Graph& /*G*/,
                                                        Interface_EntityIterator& explored) const
 {
-  DeclareAndCast(IGESBasic_Group, gr, ent); // Group les regroupe tous
+  DeclareAndCast(IGESBasic_Group, gr, ent); // Group groups them all
   if (gr.IsNull())
     return Standard_True;
 

src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_SelectBypassSubfigure.cxx

@@ -89,7 +89,7 @@ Standard_Boolean IGESSelect_SelectBypassSubfigure::Explore(const Standard_Intege
     explored.AddItem(subf->BaseEntity());
   }
 
-  //  Si c est pas tout ca, c est un objet de base et on le prend tel quel
+  //  If it's not all that, it's a base object and we take it as is
   return Standard_True;
 }
 

src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_SignStatus.cxx

@@ -116,5 +116,5 @@ Standard_Boolean IGESSelect_SignStatus::Matches(const Handle(Standard_Transient)
         return Standard_False;
     }
   }
-  return exact; // un brin de reflexion pour arriver
+  return exact; // a bit of reflection to arrive
 }

src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_ViewSorter.cxx

@@ -76,7 +76,7 @@ Standard_Boolean IGESSelect_ViewSorter::AddEntity(const Handle(IGESData_IGESEnti
   if (themap.FindIndex(igesent))
     return Standard_False;
   themap.Add(igesent);
-  //  Recuperation de la vue (attention au cas du Drawing)
+  //  View recovery (watch out for Drawing case)
   Handle(IGESData_IGESEntity) view;
   if (igesent->TypeNumber() == PourDrawing)
     view = igesent; // DRAWING
@@ -131,10 +131,10 @@ Standard_Integer IGESSelect_ViewSorter::NbEntities() const
 
 void IGESSelect_ViewSorter::SortSingleViews(const Standard_Boolean alsoframes)
 {
-  // Du tas initial, on ecarte : les vues nulles, et selon alsoframe les drawings
+  // From the initial pile, we exclude : null views, and according to alsoframe the drawings
-  // Vues nulles : cf theremain (remain initial reconduit)
+  // Null views : see theremain (initial remain carried forward)
 
-  //  Remarque : le filtre IsSingle a ete applique par Add
+  //  Note : the IsSingle filter has been applied by Add
   thefinals.Clear();
   Standard_Integer nb = theinditem.Length();
   // Standard_Integer numit = 0; //szv#4:S4163:12Mar99 not needed

src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_WorkLibrary.cxx

@@ -185,7 +185,7 @@ void IGESSelect_WorkLibrary::DumpEntity(const Handle(Interface_InterfaceModel)&
     return;
   }
 
-  //  On attaque le dump : d abord cas de l Erreur
+  //  We start the dump : first the Error case
   if (iserr)
   {
     S << " ERRONEOUS, Content, Type cdl : ";

src/DataExchange/TKDEIGES/IGESSolid/IGESSolid_Loop.cxx

@@ -102,13 +102,13 @@ Standard_Boolean IGESSolid_Loop::IsIsoparametric(const Standard_Integer EdgeInde
   if (!theIsoparametricFlags->Value(EdgeIndex).IsNull())
     return (theIsoparametricFlags->Value(EdgeIndex)->Value(CurveIndex) != 0);
   else
-    return Standard_False; // faut bien dire qq chose
+    return Standard_False; // must say something
 }
 
 Handle(IGESData_IGESEntity) IGESSolid_Loop::ParametricCurve(const Standard_Integer EdgeIndex,
                                                             const Standard_Integer CurveIndex) const
 {
-  Handle(IGESData_IGESEntity) acurve; // par defaut sera nulle
+  Handle(IGESData_IGESEntity) acurve; // by default will be null
   if (!theCurves->Value(EdgeIndex).IsNull())
     acurve = theCurves->Value(EdgeIndex)->Value(CurveIndex);
   return acurve;

src/DataExchange/TKDEIGES/IGESSolid/IGESSolid_ToolConicalSurface.cxx

@@ -78,7 +78,7 @@ void IGESSolid_ToolConicalSurface::WriteOwnParams(const Handle(IGESSolid_Conical
   IW.Send(ent->Radius());
   IW.Send(ent->SemiAngle());
   if (ent->IsParametrised())
-    IW.Send(ent->ReferenceDir()); // cf FormNumber
+    IW.Send(ent->ReferenceDir()); // see FormNumber
 }
 
 void IGESSolid_ToolConicalSurface::OwnShared(const Handle(IGESSolid_ConicalSurface)& ent,

src/DataExchange/TKDEIGES/IGESSolid/IGESSolid_TopoBuilder.cxx

@@ -186,7 +186,7 @@ void IGESSolid_TopoBuilder::AddCurveUV(const Handle(IGESData_IGESEntity)& curve,
 
 void IGESSolid_TopoBuilder::EndEdge()
 {
-  //  transformer  thecuruv,theiso en array et le mettre dans theeuv
+  //  transform thecuruv,theiso to array and put it in theeuv
   Handle(IGESData_HArray1OfIGESEntity) curuv;
   Handle(TColStd_HArray1OfInteger)     iso;
   if (!thecuruv->IsEmpty())