OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0024574: ICC compiler warnings on Windows

Browse Source 
NCollection_UtfString and NCollection_UtfIterator classes are refactored to use methods overloading instead of switches to dispatch implementation depending on character (Unicode code unit) size.

ICC-specific preprocessor directives are added to avoid warnings.
Unused local functions and variables, class methods, unreachable statements, and extra throw() declarations reported by ICC are removed.
Usage of "expl" for name of local variable is avoided as it conflicts with standard C function "expl" defined in math.h as preprocessor macro.

Non-standard (MS-specific) argument envp is removed in definition of main() function on Windows.
Functions _main_ and _WinMain_ are renamed to Draw_Main and Draw_WinMain, respectively, to avoid using names reserved in C++.

Doxygen warning is fixed in XDE User's Guide.
This commit is contained in:
abv 2017-10-19 17:12:05 +03:00 committed by bugmaster
parent f6c2b39aac
commit cf0786daf1
22 changed files with 259 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
dox/user_guides/xde/xde.md
View File

@ -91,18 +91,18 @@ XDE can read and write colors and layers assigned to shapes or their subparts (d
@figure{/user_guides/xde/images/xde_image006.png,"Colors and Layers",240}
@subsection occt_xde_1_7 Geometric Dimensions & Tolerances (GD&T)
@subsection occt_xde_1_7 Geometric Dimensions & Tolerances (GD\&T)
GD&T are a type of Product and Manufacturing Information (PMI) that can be either computed automatically by a CAD system,
GD\&T are a type of Product and Manufacturing Information (PMI) that can be either computed automatically by a CAD system,
or entered manually by the user. For detailed information use <a href="https://www.cax-if.org/documents/rec_pracs_pmi_v40.pdf">CAx-IF Recommended Practices
for the Representation and Presentation of Product Manufacturing Information (PMI) (AP242)</a>
XDE can read and write GD&T data of the following types:
XDE can read and write GD\&T data of the following types:
* dimensions, such as distance, length, radius and so on;
* geometric tolerances;
* datums, i.e a theoretically exact geometric references, such as point, line or plane, to which toleranced features are related.
XDE supports two presentations of GD&T data:
XDE supports two presentations of GD\&T data:
* semantic presentation, i.e. data is stored in a machine-consumable way and includes all information required to understand the
specification without the aid of any presentation elements;
* tessellated presentation, i.e. data is displayed in a human-readable way.
@ -660,42 +660,42 @@ To remove a Color and all the references to it (so that the related shapes will
myColors->RemoveColor(ColLabel);
~~~~~
@subsection occt_xde_2_7 Geometric Dimensions & Tolerances (GD&T)
@subsection occt_xde_2_7 Geometric Dimensions & Tolerances (GD\&T)
XDE can read and write GD&T assigned to shapes or their subparts (down to the level of faces and edges) to and from STEP formats.
XDE can read and write GD\&T assigned to shapes or their subparts (down to the level of faces and edges) to and from STEP formats.
In an XDE document, GD&T are managed by the class *XCAFDoc_DimTolTool*. It works basing on the same principles as ShapeTool works with Shapes. This tool can be provided on the Main Label or on any sub-label. The GD&T entities themselves are defined as the following sub-classes of *TDF_Attribute*:
In an XDE document, GD\&T are managed by the class *XCAFDoc_DimTolTool*. It works basing on the same principles as ShapeTool works with Shapes. This tool can be provided on the Main Label or on any sub-label. The GD\&T entities themselves are defined as the following sub-classes of *TDF_Attribute*:
* *XCAFDoc_Dimension* - for dimensions;
* *XCAFDoc_GeomTolerance* - for geometric tolerances;
* *XCAFDoc_Datum* - for geometric tolerance Datums.
A GD&T type is identified by the attributes listed above, i.e. *XCAFDoc_DimTolTool* methods working with particular entity types check
A GD\&T type is identified by the attributes listed above, i.e. *XCAFDoc_DimTolTool* methods working with particular entity types check
for presence of the corresponding attributes in passed labels. One can use methods of *XCAFDoc_DimTolTool* beginning with 'Is' for this purpose.
GD&T entities are stored in a child of the starting document label 0.1.4.
Each GD&T entity then corresponds to the dedicated label, the property itself is one of access classes:
GD\&T entities are stored in a child of the starting document label 0.1.4.
Each GD\&T entity then corresponds to the dedicated label, the property itself is one of access classes:
* *XCAFDimTolObject_DimensionObject* - for dimensions;
* *XCAFDimTolObject_GeomToleranceObject* - for geometric tolerances;
* *XCAFDimTolObject_DatumObject* - for geometric tolerance Datums.
GD&Ts and Shapes are related to by Graph Nodes.
GD\&Ts and Shapes are related to by Graph Nodes.
These definitions are common to various exchange formats, at least for STEP.
@subsubsection occt_xde_2_7_1 Initialization
To query, edit, or initialize a Document to handle GD&Ts of XCAF, use:
To query, edit, or initialize a Document to handle GD\&Ts of XCAF, use:
~~~~~
Handle(XCAFDoc_DimTolTool) myDimTolTool =
XCAFDoc_DocumentTool::DimTolTool(Doc->Main());
~~~~~
This call can be used at any time. When it is used for the first time, a relevant structure is added to the document. This definition is used for all later GD&T calls and is not repeated for them.
This call can be used at any time. When it is used for the first time, a relevant structure is added to the document. This definition is used for all later GD\&T calls and is not repeated for them.
@subsubsection occt_xde_2_7_2 Adding a GD&T
*XCAFDoc_DimTolTool* provides methods to create GD&T 'empty' entities:
@subsubsection occt_xde_2_7_2 Adding a GD\&T
*XCAFDoc_DimTolTool* provides methods to create GD\&T 'empty' entities:
* *AddDimension* - for a new dimension;
* *AddGeomTolerance* - for a new geometric tolerance;
* *AddDatum* - for a new geometric tolerance datum.
All methods create a sub-label for the corresponding GD&T entity of the tool master label and attach an attribute specific for the
All methods create a sub-label for the corresponding GD\&T entity of the tool master label and attach an attribute specific for the
created entity.
Here is an example of adding a new dimension:
@ -706,10 +706,10 @@ if (!aDimLabel.IsNull())
// error processing
}
~~~~~
A similar approach can be used for other GD&T types.
A similar approach can be used for other GD\&T types.
@subsubsection occt_xde_2_7_3 Editing a GD&T
A newly added GD&T entity is empty. To set its data a corresponding access object should be used as it is demonstrated
@subsubsection occt_xde_2_7_3 Editing a GD\&T
A newly added GD\&T entity is empty. To set its data a corresponding access object should be used as it is demonstrated
below, where the dimension becomes the linear distance between two points.
~~~~~
Handle(XCAFDoc_Dimension) aDimAttr;
@ -726,10 +726,10 @@ if (!aDimAttr.IsNull())
aDimAttr->SetObject(aDimObject);
}
~~~~~
A similar approach can be used for other GD&T types.
A similar approach can be used for other GD\&T types.
@subsubsection occt_xde_2_7_4 Linking GD&Ts
To link a GD&T entity with other OCAF labels (e.g. representing shapes) one should use the following methods:
@subsubsection occt_xde_2_7_4 Linking GD\&Ts
To link a GD\&T entity with other OCAF labels (e.g. representing shapes) one should use the following methods:
* *SetDimension* - for dimensions;
* *SetGeomTolerance* - for geometric tolerances;
* SetDatum - for geometric tolerance datums.
@ -748,20 +748,20 @@ aDGTTool->SetDimension(aShapes1, aShapes2, aDimLabel);
In addition, a special method *SetDatumToGeomTol* should be used to link a datum with a geometric tolerance.
@subsubsection occt_xde_2_7_5 Finding GD&Ts and reference shapes
@subsubsection occt_xde_2_7_5 Finding GD\&Ts and reference shapes
*XCAFDimTolObjects_Tool* class provides basic capabilities for searching GD&Ts linked to shapes.
*XCAFDimTolObjects_Tool* class provides basic capabilities for searching GD\&Ts linked to shapes.
Using the tool one can get sequences of dimensions, geometric tolerances and datums linked with a shape. A series of related datums is also returned for geometric tolerances.
To get reference shapes for a GD&T entity one can use *GetRefShapeLabel* from *XCAFDoc_DimTolTool*.
To get reference shapes for a GD\&T entity one can use *GetRefShapeLabel* from *XCAFDoc_DimTolTool*.
*XCAFDoc_DimTolTool* provides methods to get lists of all dimensions, geometric tolerances and datums.
@subsubsection occt_xde_2_7_6 Storing custom data
Every GD&T entity in XDE is represented as a label with attached attribute identifying entity type. All specific data is
Every GD\&T entity in XDE is represented as a label with attached attribute identifying entity type. All specific data is
stored in sub-labels in standard OCAF attributes, such as *TDataStd_Integer*, *TDataStd_IntegerArray*, *TDataStd_RealArray* and so on.
Sub-label tags are reserved for internal use and cannot be used for storing custom data. The following tag ranges are reserved for
GD&T entities:
GD\&T entities:
* 1 - 17 - for dimensions;
* 1 - 17 - for geometric tolerances;
* 1 - 19 - for datums.
@ -834,7 +834,7 @@ for (TDF_LabelSequence::Iterator anIt(aClipPlaneLbls); anIt.More(); anIt.Next())
@subsection occt_xde_2_9 Saved views
In an XDE document, Views are managed by the class *XCAFDoc_ViewTool*. It works basing on the same principles as ShapeTool works with Shapes. This tool can be provided on the Main Label or on any sub-label. Views are stored in a child of the starting document label 0.1.7, where a view itself is defined as *XCAFDoc_View* sub-class of *TDF_Attribute*. Views and selected shapes, clipping planes, GD&Ts and notes are related to by Graph Nodes.
In an XDE document, Views are managed by the class *XCAFDoc_ViewTool*. It works basing on the same principles as ShapeTool works with Shapes. This tool can be provided on the Main Label or on any sub-label. Views are stored in a child of the starting document label 0.1.7, where a view itself is defined as *XCAFDoc_View* sub-class of *TDF_Attribute*. Views and selected shapes, clipping planes, GD\&Ts and notes are related to by Graph Nodes.
To query, edit, or initialize a Document to handle views of XCAF, use:
~~~~~
@ -864,7 +864,7 @@ if (!aViewAttr.IsNull())
}
~~~~~
To set shapes, clipping planes, GD&Ts and notes selected for the view use one of overloaded *SetView* methods of *XCAFDoc_ViewTool*.
To set shapes, clipping planes, GD\&Ts and notes selected for the view use one of overloaded *SetView* methods of *XCAFDoc_ViewTool*.
To set only clipping planes one should use *SetClippingPlanes* method.
~~~~~
TDF_LabelSequence aShapes; ...
@ -891,23 +891,26 @@ for (TDF_LabelSequence::Iterator anIt(aViewLbls); anIt.More(); anIt.Next())
}
~~~~~
To get shapes, clipping planes, GD&Ts or notes associated with a particular view use the following methods:
To get shapes, clipping planes, GD\&Ts or notes associated with a particular view use the following methods:
* *GetRefShapeLabel* - returns a sequence of associated shape labels;
* *GetRefGDTLabel* - returns a sequence of associated GDT labels;
* *GetRefClippingPlaneLabel* - returns a sequence of associated clipping plane labels;
* *GetRefNoteLabel* - returns a sequence of associated note labels;
* *GetRefAnnotationLabel* - returns a sequence of associated annotated labels.
And vice versa, to get views that display a particular clipping plane, GD&T or note use the following methods:
And vice versa, to get views that display a particular clipping plane, GD\&T or note use the following methods:
* *GetViewLabelsForShape* - returns a sequence of associated view labels for a shape;
* *GetViewLabelsForGDT* - returns a sequence of associated view labels for a GD&T;
* *GetViewLabelsForGDT* - returns a sequence of associated view labels for a GD\&T;
* *GetViewLabelsForClippingPlane* - returns a sequence of associated view labels for a clipping plane;
* *GetViewLabelsForNote* - returns a sequence of associated view labels for a note;
* *GetViewLabelsForAnnotation* - returns a sequence of associated view labels for an annotated label.
@subsection occt_xde_2_10 Custom notes
In an XDE document, custom notes are managed by the class *XCAFDoc_NotesTool*. It works basing on the same principles as ShapeTool works with Shapes. This tool can be provided on the Main Label or on any sub-label. The Property itself is defined as sub-class of *XCAFDoc_Note* abstract class, which is a sub-class of *TDF_Attribute* one.
In an XDE document, custom notes are managed by the class *XCAFDoc_NotesTool*.
It works basing on the same principles as ShapeTool works with Shapes.
This tool can be provided on the Main Label or on any sub-label.
The Property itself is defined as sub-class of *XCAFDoc_Note* abstract class, which is a sub-class of *TDF_Attribute* one.
Custom notes are stored in a child of the *XCAFDoc_NotesTool* label, at label 0.1.9.1. Each note then corresponds to a dedicated label. A note may be attached to a document item identified by a label, a sub-shape identified by integer index or an attribute identified by GUID. Annotations are stored in a child of the *XCAFDoc_NotesTool* label, at label 0.1.9.2.
Notes binding is done through *XCAFDoc_GraphNode* attribute.
@ -1042,7 +1045,7 @@ The same can be said for Viewing: presentations can be defined from Shapes and C
There are several important points to consider:
* Previously defined Readers and Writers for dealing with Shapes only, whether Standard or Advanced, remain unchanged in their form and in their dependencies. In addition, functions other than mapping are also unchanged.
* XDE provides mapping with data other than Shapes. Names, Colors, Layers, GD&T, Clipping planes, Views, Validation Properties (Centroid, Volume, Area), and Assembly Structure are hierarchic with rigid motion. Currently, Clipping planes and Views writing supported for XBF format only.
* XDE provides mapping with data other than Shapes. Names, Colors, Layers, GD\&T, Clipping planes, Views, Validation Properties (Centroid, Volume, Area), and Assembly Structure are hierarchic with rigid motion. Currently, Clipping planes and Views writing supported for XBF format only.
* XDE mapping is relevant for use within the Advanced level of Data Exchanges, rather than Standard ones, because a higher level of information is better suited to a higher quality of shapes. In addition, this allows to avoid the multiplicity of combinations between various options. Note that this choice is not one of architecture but of practical usage and packaging.
* Reader and Writer classes for XDE are generally used like those for Shapes. However, their use is adapted to manage a Document rather than a Shape.

2
src/BRepBuilderAPI/BRepBuilderAPI_Copy.cxx
View File

@ -185,8 +185,6 @@ private:
Standard_Boolean myCopyMesh;
};
DEFINE_STANDARD_HANDLE(BRepBuilderAPI_Copy_Modification, BRepTools_Modification)
} // anonymous namespace
//=======================================================================

8
src/BRepTest/BRepTest_Fillet2DCommands.cxx
View File

@ -240,12 +240,12 @@ static gp_Pnt findCommonPoint(const TopoDS_Shape& W)
// The common point for two edges inside a wire
// is a sharing vertex of two edges.
TopTools_MapOfShape vertices;
TopExp_Explorer expl(W, TopAbs_VERTEX);
for (; expl.More(); expl.Next())
TopExp_Explorer aExp(W, TopAbs_VERTEX);
for (; aExp.More(); aExp.Next())
{
if (!vertices.Add(expl.Current()))
if (!vertices.Add(aExp.Current()))
{
return BRep_Tool::Pnt(TopoDS::Vertex(expl.Current()));
return BRep_Tool::Pnt(TopoDS::Vertex(aExp.Current()));
}
}
return gp::Origin(); // not found

30
src/DNaming/DNaming.cxx
View File

@ -364,20 +364,20 @@ static void LoadNextLevels(const TopoDS_Shape& S,
{
if (S.ShapeType() == TopAbs_SOLID) {
TopExp_Explorer expl(S, TopAbs_FACE);
for (; expl.More(); expl.Next()) {
TopExp_Explorer aExp(S, TopAbs_FACE);
for (; aExp.More(); aExp.Next()) {
TNaming_Builder bFace(Tagger->NewChild());
bFace.Generated(expl.Current());
bFace.Generated(aExp.Current());
}
} else if (S.ShapeType() == TopAbs_SHELL || S.ShapeType() == TopAbs_FACE) {
// load faces and all the free edges
TopTools_IndexedMapOfShape Faces;
TopExp::MapShapes(S, TopAbs_FACE, Faces);
if (Faces.Extent() > 1 || (S.ShapeType() == TopAbs_SHELL && Faces.Extent() == 1)) {
TopExp_Explorer expl(S, TopAbs_FACE);
for (; expl.More(); expl.Next()) {
TopExp_Explorer aExp(S, TopAbs_FACE);
for (; aExp.More(); aExp.Next()) {
TNaming_Builder bFace(Tagger->NewChild());
bFace.Generated(expl.Current());
bFace.Generated(aExp.Current());
}
}
TopTools_IndexedDataMapOfShapeListOfShape anEdgeAndNeighbourFaces;
@ -403,16 +403,16 @@ static void LoadNextLevels(const TopoDS_Shape& S,
if (Edges.Extent() == 1) {
TNaming_Builder bEdge(Tagger->NewChild());
bEdge.Generated(Edges.FindKey(1));
TopExp_Explorer expl(S, TopAbs_VERTEX);
for (; expl.More(); expl.Next()) {
TopExp_Explorer aExp(S, TopAbs_VERTEX);
for (; aExp.More(); aExp.Next()) {
TNaming_Builder bVertex(Tagger->NewChild());
bVertex.Generated(expl.Current());
bVertex.Generated(aExp.Current());
}
} else {
TopExp_Explorer expl(S, TopAbs_EDGE);
for (; expl.More(); expl.Next()) {
TopExp_Explorer aExp(S, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
TNaming_Builder bEdge(Tagger->NewChild());
bEdge.Generated(expl.Current());
bEdge.Generated(aExp.Current());
}
// and load generated vertices.
TopTools_DataMapOfShapeShape generated;
@ -422,10 +422,10 @@ static void LoadNextLevels(const TopoDS_Shape& S,
}
}
} else if (S.ShapeType() == TopAbs_EDGE) {
TopExp_Explorer expl(S, TopAbs_VERTEX);
for (; expl.More(); expl.Next()) {
TopExp_Explorer aExp(S, TopAbs_VERTEX);
for (; aExp.More(); aExp.Next()) {
TNaming_Builder bVertex(Tagger->NewChild());
bVertex.Generated(expl.Current());
bVertex.Generated(aExp.Current());
}
}
}

8
src/Draft/Draft_Modification_1.cxx
View File

@ -277,10 +277,10 @@ Standard_Boolean Draft_Modification::InternalAdd(const TopoDS_Face& F,
}
}
TopExp_Explorer expl(F,TopAbs_EDGE);
TopExp_Explorer aExp(F,TopAbs_EDGE);
TopTools_MapOfShape MapOfE;
while (expl.More() && badShape.IsNull()) {
const TopoDS_Edge& edg = TopoDS::Edge(expl.Current());
while (aExp.More() && badShape.IsNull()) {
const TopoDS_Edge& edg = TopoDS::Edge(aExp.Current());
if (!myEMap.Contains(edg)) {
Standard_Boolean addedg = Standard_False;
Standard_Boolean addface = Standard_False;
@ -393,7 +393,7 @@ Standard_Boolean Draft_Modification::InternalAdd(const TopoDS_Face& F,
}
}
}
expl.Next();
aExp.Next();
}
return (badShape.IsNull());
}

21
src/Draw/Draw_Main.cxx
View File

@ -46,26 +46,26 @@ static FDraw_InitAppli theDraw_InitAppli; //pointer to the Draw_InitAppli
#endif
#ifdef _WIN32
//=======================================================================
//NOTE: OCC11
// On Windows NT, both console (UNIX-like) and windowed (classical on
// WNT, with three separated windows - input, output and graphic)
// modes are supported.
// Depending on compilation mode of executable (CONSOLE or WINDOWS),
// either _main_ or _WinMain_ becomes entry point;
// either Draw_Main or Draw_WinMain becomes entry point;
// the further different behaviour of DRAW is determined by variable
// Draw_IsConsoleSubsystem which is set by _main_ only
// Draw_IsConsoleSubsystem which is set by Draw_Main only
//=======================================================================
extern Standard_Boolean Draw_IsConsoleSubsystem;
//=======================================================================
//function : _main_
//function : Draw_Main
//purpose :
//=======================================================================
Standard_Integer _main_ (int /*argc*/, char* argv[], char* /*envp*/[], const FDraw_InitAppli fDraw_InitAppli)
Standard_Integer Draw_Main (int /*argc*/, char* argv[], const FDraw_InitAppli fDraw_InitAppli)
{
Draw_IsConsoleSubsystem = Standard_True;
theDraw_InitAppli = fDraw_InitAppli;
@ -83,11 +83,11 @@ Standard_Integer _main_ (int /*argc*/, char* argv[], char* /*envp*/[], const FDr
}
//=======================================================================
//function : _WinMain_
//function : Draw_WinMain
//purpose :
//=======================================================================
Standard_Integer _WinMain_ (HINSTANCE hInstance, HINSTANCE hPrevinstance, LPSTR /*lpCmdLine*/, int nCmdShow, const FDraw_InitAppli fDraw_InitAppli)
Standard_Integer Draw_WinMain (HINSTANCE hInstance, HINSTANCE hPrevinstance, LPSTR /*lpCmdLine*/, int nCmdShow, const FDraw_InitAppli fDraw_InitAppli)
{
theDraw_InitAppli = fDraw_InitAppli;
int aNbArgs = 0;
@ -96,13 +96,15 @@ Standard_Integer _WinMain_ (HINSTANCE hInstance, HINSTANCE hPrevinstance, LPSTR
LocalFree (anArgVec);
return 0;
}
#else
//=======================================================================
//function : _main_
//function : Draw_Main
//purpose :
//=======================================================================
Standard_Integer _main_ (Standard_Integer argc, char* argv[], const FDraw_InitAppli fDraw_InitAppli)
Standard_Integer Draw_Main (Standard_Integer argc, char* argv[], const FDraw_InitAppli fDraw_InitAppli)
{
// MKV 01.02.05
#if ((TCL_MAJOR_VERSION > 8) || ((TCL_MAJOR_VERSION == 8) && (TCL_MINOR_VERSION >= 4)))
@ -111,4 +113,5 @@ Standard_Integer _main_ (Standard_Integer argc, char* argv[], const FDraw_InitAp
Draw_Appli(argc, argv, fDraw_InitAppli);
return 0;
}
#endif

49
src/Draw/Draw_Main.hxx
View File

@ -30,37 +30,32 @@
typedef void (*FDraw_InitAppli)(Draw_Interpretor&);
#ifndef _WIN32
Standard_EXPORT Standard_Integer _main_ (Standard_Integer argc,
Standard_PCharacter argv[],
const FDraw_InitAppli Draw_InitAppli);
#else
#include <windows.h>
Standard_EXPORT Standard_Integer _WinMain_ (HINSTANCE hInstance,
HINSTANCE hPrevinstance,
LPSTR lpCmdLine,
Standard_Integer nCmdShow,
const FDraw_InitAppli Draw_InitAppli);
Standard_EXPORT Standard_Integer _main_ (int argc,
char* argv[],
char* envp[],
const FDraw_InitAppli Draw_InitAppli);
#endif
Standard_EXPORT Standard_Integer Draw_Main (Standard_Integer argc, Standard_PCharacter argv[], const FDraw_InitAppli Draw_InitAppli);
// Declarations of macros DRAW_MAIN to be used in executables instead of explicit main/WinMain
#ifndef _WIN32
// main()
#define DRAW_MAIN int main (Standard_Integer argc, char* argv[])\
{return _main_ (argc, argv, Draw_InitAppli);}
#else
#ifdef _WIN32
#include <windows.h>
Standard_EXPORT Standard_Integer Draw_WinMain (HINSTANCE hInstance,
HINSTANCE hPrevinstance,
LPSTR lpCmdLine,
Standard_Integer nCmdShow,
const FDraw_InitAppli Draw_InitAppli);
// WinMain() and main()
#define DRAW_MAIN Standard_Integer PASCAL WinMain (HINSTANCE hInstance, HINSTANCE hPrevinstance, LPSTR lpCmdLine, Standard_Integer nCmdShow)\
{return _WinMain_ (hInstance, hPrevinstance, lpCmdLine, nCmdShow, Draw_InitAppli);}\
#define DRAW_MAIN Standard_Integer PASCAL WinMain (HINSTANCE hInstance, HINSTANCE hPrevinstance, LPSTR lpCmdLine, Standard_Integer nCmdShow) \
{ return Draw_WinMain (hInstance, hPrevinstance, lpCmdLine, nCmdShow, Draw_InitAppli); } \
\
int main (int argc, char* argv[], char* envp[])\
{return _main_ (argc, argv, envp, Draw_InitAppli);}
#endif
int main (int argc, char* argv[]) \
{ return Draw_Main (argc, argv, Draw_InitAppli); }
#else
// main()
#define DRAW_MAIN int main (Standard_Integer argc, char* argv[]) \
{ return Draw_Main (argc, argv, Draw_InitAppli); }
#endif
#endif

2
src/Draw/MainWindow.cxx
View File

@ -86,7 +86,7 @@ BOOL CreateProc(HWND hWndFrame)
| COMMAND PROCEDURE
| Handler for message WM_COMMAND
| It is used when Draw_IsConsoleSubsystem = Standard_False
| i.e. in non-console mode (see _main_() in Draw_Main.cxx).
| i.e. in non-console mode (see Draw_main() in Draw_Main.cxx).
\*--------------------------------------------------------------------------*/
LRESULT APIENTRY CmdProc(HWND hWndFrame, UINT wMsg, WPARAM /*wParam*/, LPARAM /*lParam*/)
{

5
src/GeomAdaptor/GeomAdaptor_Curve.cxx
View File

@ -763,9 +763,8 @@ gp_Vec GeomAdaptor_Curve::DN(const Standard_Real U,
return myBSplineCurve->LocalDN(U, aStart, aFinish, N);
}
else
return myCurve->DN( U, N);
break;
}
return myCurve->DN (U, N);
}
case GeomAbs_OffsetCurve:
return myNestedEvaluator->DN(U, N);

1
src/Image/Image_Diff.cxx
View File

@ -32,7 +32,6 @@ namespace
{
Standard_Byte v[3];
typedef Standard_Byte ComponentType_t; //!< Component type
static Standard_Integer Length() { return 3; } //!< Returns the number of components
};
static Image_ColorXXX24 operator- (const Image_ColorXXX24& theA,

18
src/NCollection/NCollection_StdAllocator.hxx
View File

@ -50,21 +50,21 @@ public:
/*! Creates an object using default Open CASCADE allocation mechanism, i.e. which uses
Standard::Allocate() and Standard::Free() underneath.
*/
NCollection_StdAllocator() throw()
NCollection_StdAllocator()
{ myAlloc = NCollection_BaseAllocator::CommonBaseAllocator(); }
//! Constructor.
/*! Saves \a theAlloc as an underlying allocator instance.*/
NCollection_StdAllocator( const Handle(NCollection_BaseAllocator)& theAlloc) throw()
NCollection_StdAllocator( const Handle(NCollection_BaseAllocator)& theAlloc)
{ myAlloc = theAlloc; }
//! Copy constructor.
/*! Copies Allocator() from \a Y.*/
template<typename U> NCollection_StdAllocator( const NCollection_StdAllocator<U>& Y) throw()
template<typename U> NCollection_StdAllocator( const NCollection_StdAllocator<U>& Y)
{ myAlloc = Y.Allocator(); }
//! Assignment operator
template<typename U> NCollection_StdAllocator& operator= (const NCollection_StdAllocator<U>& Y) throw()
template<typename U> NCollection_StdAllocator& operator= (const NCollection_StdAllocator<U>& Y)
{ myAlloc = Y.Allocator(); return *this; }
//! Returns an object address.
@ -85,7 +85,7 @@ public:
void deallocate( pointer p, size_type ) { myAlloc->Free( p ); }
//! Returns the largest value for which method allocate might succeed.
size_type max_size() const throw()
size_type max_size() const
{
size_type aMax = static_cast<size_type>( -1 ) / sizeof( value_type );
return aMax;
@ -138,24 +138,24 @@ public:
/*! Creates an object using default Open CASCADE allocation mechanism, i.e. which uses
Standard::Allocate() and Standard::Free() underneath.
*/
NCollection_StdAllocator() throw()
NCollection_StdAllocator()
{ myAlloc = NCollection_BaseAllocator::CommonBaseAllocator(); }
//! Constructor.
/*! Saves \a theAlloc as an underlying allocator instance.*/
NCollection_StdAllocator( const Handle(NCollection_BaseAllocator)& theAlloc) throw()
NCollection_StdAllocator( const Handle(NCollection_BaseAllocator)& theAlloc)
{ myAlloc = theAlloc; }
//! Constructor.
/*! Copies Allocator() from \a X.*/
NCollection_StdAllocator( const NCollection_StdAllocator& X) throw() { myAlloc = X.myAlloc; }
NCollection_StdAllocator( const NCollection_StdAllocator& X) { myAlloc = X.myAlloc; }
//! Returns an underlying NCollection_BaseAllocator instance.
/*! Returns an object specified in the constructor.*/
const Handle(NCollection_BaseAllocator)& Allocator() const { return myAlloc; }
//! Assignment operator
NCollection_StdAllocator& operator=(const NCollection_StdAllocator& X) throw()
NCollection_StdAllocator& operator=(const NCollection_StdAllocator& X)
{
myAlloc = X.myAlloc;
return *this;

72
src/NCollection/NCollection_UtfIterator.hxx
View File

@ -16,12 +16,16 @@
#ifndef _NCollection_UtfIterator_H__
#define _NCollection_UtfIterator_H__
#include <Standard_TypeDef.hxx>
#include <Standard_Handle.hxx>
//! Template class for Unicode strings support.
//!
//! It defines an iterator and provide correct way to read multi-byte text (UTF-8 and UTF-16)
//! and convert it from one to another.
//! The current value of iterator returned as UTF-32 Unicode code.
//! The current value of iterator is returned as UTF-32 Unicode symbol.
//!
//! Here and below term "Unicode symbol" is used as
//! synonym of "Unicode code point".
template<typename Type>
class NCollection_UtfIterator
{
@ -56,20 +60,13 @@ public:
myCharIndex = 0;
}
//! Pre-increment operator. Reads the next unicode character.
//! Pre-increment operator. Reads the next unicode symbol.
//! Notice - no protection against overrun!
NCollection_UtfIterator& operator++()
{
myPosition = myPosNext;
++myCharIndex;
switch (sizeof(Type))
{
case 1: readUTF8(); break;
case 2: readUTF16(); break;
case 4: // UTF-32
default:
myCharUtf32 = *myPosNext++;
}
readNext (static_cast<const typename CharTypeChooser<Type>::type*>(0));
return *this;
}
@ -95,7 +92,7 @@ public:
}
//! Dereference operator.
//! @return the UTF-32 codepoint of the character currently pointed by iterator.
//! @return the UTF-32 codepoint of the symbol currently pointed by iterator.
Standard_Utf32Char operator*() const
{
return myCharUtf32;
@ -111,6 +108,7 @@ public:
const Type* BufferNext() const { return myPosNext; }
//! @return the index displacement from iterator intialization
//! (first symbol has index 0)
Standard_Integer Index() const
{
return myCharIndex;
@ -161,25 +159,61 @@ public:
//! @return the advance in TypeWrite chars needed to store current symbol
template<typename TypeWrite>
Standard_Integer AdvanceBytesUtf() const;
inline Standard_Integer AdvanceBytesUtf() const
{
return advanceBytes(static_cast<const typename CharTypeChooser<TypeWrite>::type*>(0));
}
//! Fill the UTF-** buffer within current Unicode symbol.
//! Use method AdvanceUtf**() to allocate buffer with enough size.
//! @param theBuffer buffer to fill
//! @return new buffer position (for next char)
template<typename TypeWrite>
TypeWrite* GetUtf (TypeWrite* theBuffer) const;
inline TypeWrite* GetUtf (TypeWrite* theBuffer) const
{
return (TypeWrite*)(getUtf (reinterpret_cast<typename CharTypeChooser<TypeWrite>::type*>(theBuffer)));
}
private:
//! Helper function for reading a single UTF8 character from the string.
//! Helper template class dispatching its argument class
//! to the equivalent (by size) character (Unicode code unit) type.
//! The code unit type is defined as nested typedef "type".
//!
//! In practice this is relevant for wchar_t type:
//! typename CharTypeChooser<wchar_t>::type resolves to
//! Standard_Utf16Char on Windows and to Standard_Utf32Char on Linux.
template <typename TypeChar>
class CharTypeChooser :
public opencascade::std::conditional< sizeof(TypeChar) == 1, Standard_Utf8Char,
typename opencascade::std::conditional< sizeof(TypeChar) == 2, Standard_Utf16Char,
typename opencascade::std::conditional< sizeof(TypeChar) == 4, Standard_Utf32Char, void >::type >::type >
{
};
//! Helper function for reading a single Unicode symbol from the UTF-8 string.
//! Updates internal state appropriately.
void readUTF8();
//! Helper function for reading a single UTF16 character from the string.
//! Helper function for reading a single Unicode symbol from the UTF-16 string.
//! Updates internal state appropriately.
void readUTF16();
//! Helper overload methods to dispatch reading function depending on code unit size
void readNext (const Standard_Utf8Char*) { readUTF8(); }
void readNext (const Standard_Utf16Char*) { readUTF16(); }
void readNext (const Standard_Utf32Char*) { myCharUtf32 = *myPosNext++; }
//! Helper overload methods to dispatch advance function depending on code unit size
Standard_Integer advanceBytes (const Standard_Utf8Char*) const { return AdvanceBytesUtf8(); }
Standard_Integer advanceBytes (const Standard_Utf16Char*) const { return AdvanceBytesUtf16(); }
Standard_Integer advanceBytes (const Standard_Utf32Char*) const { return AdvanceBytesUtf32(); }
//! Helper overload methods to dispatch getter function depending on code unit size
Standard_Utf8Char* getUtf (Standard_Utf8Char* theBuffer) const { return GetUtf8 (theBuffer); }
Standard_Utf16Char* getUtf (Standard_Utf16Char* theBuffer) const { return GetUtf16(theBuffer); }
Standard_Utf32Char* getUtf (Standard_Utf32Char* theBuffer) const { return GetUtf32(theBuffer); }
private: //! @name unicode magic numbers
static const unsigned char UTF8_BYTES_MINUS_ONE[256];
@ -199,10 +233,10 @@ private: //! @name unicode magic numbers
private: //! @name private fields
const Type* myPosition; //!< buffer position of the first element in the current character
const Type* myPosNext; //!< buffer position of the first element in the next character
const Type* myPosition; //!< buffer position of the first element in the current symbol
const Type* myPosNext; //!< buffer position of the first element in the next symbol
Standard_Integer myCharIndex; //!< index displacement from iterator intialization
Standard_Utf32Char myCharUtf32; //!< character stored at the current buffer position
Standard_Utf32Char myCharUtf32; //!< Unicode symbol stored at the current buffer position
};

32
src/NCollection/NCollection_UtfIterator.lxx
View File

@ -317,35 +317,3 @@ Standard_Utf32Char* NCollection_UtfIterator<Type>::GetUtf32 (Standard_Utf32Char*
*theBuffer++ = myCharUtf32;
return theBuffer;
}
// =======================================================================
// function : AdvanceBytesUtf
// purpose :
// =======================================================================
template<typename Type> template<typename TypeWrite> inline
Standard_Integer NCollection_UtfIterator<Type>::AdvanceBytesUtf() const
{
switch (sizeof(TypeWrite))
{
case sizeof(Standard_Utf8Char): return AdvanceBytesUtf8();
case sizeof(Standard_Utf16Char): return AdvanceBytesUtf16();
case sizeof(Standard_Utf32Char): return AdvanceBytesUtf32();
default: return 0; // invalid case
}
}
// =======================================================================
// function : GetUtf
// purpose :
// =======================================================================
template<typename Type> template<typename TypeWrite> inline
TypeWrite* NCollection_UtfIterator<Type>::GetUtf (TypeWrite* theBuffer) const
{
switch (sizeof(TypeWrite))
{
case sizeof(Standard_Utf8Char): return (TypeWrite* )GetUtf8 ((Standard_Utf8UChar* )theBuffer);
case sizeof(Standard_Utf16Char): return (TypeWrite* )GetUtf16((Standard_Utf16Char* )theBuffer);
case sizeof(Standard_Utf32Char): return (TypeWrite* )GetUtf32((Standard_Utf32Char* )theBuffer);
default: return NULL; // invalid case
}
}

121
src/NCollection/NCollection_UtfString.hxx
View File

@ -16,9 +16,7 @@
#ifndef _NCollection_UtfString_H__
#define _NCollection_UtfString_H__
#include "NCollection_UtfIterator.hxx"
#include <Standard.hxx>
#include <NCollection_UtfIterator.hxx>
#include <cstring>
#include <cstdlib>
@ -29,6 +27,9 @@
//!
//! Notice that changing the string is not allowed
//! and any modifications should produce new string.
//!
//! In comments to this class, terms "Unicode symbol" is used as
//! synonym of "Unicode code point".
template<typename Type>
class NCollection_UtfString
{
@ -40,7 +41,7 @@ public:
return NCollection_UtfIterator<Type> (myString);
}
//! @return the size of the buffer, excluding NULL-termination symbol
//! @return the size of the buffer in bytes, excluding NULL-termination symbol
Standard_Integer Size() const
{
return mySize;
@ -60,7 +61,8 @@ public:
//! Retrieve string buffer at specified position.
//! Warning! This is a slow access. Iterator should be used for consecutive parsing.
//! @param theCharIndex the index of the symbol, should be lesser than Length()
//! @param theCharIndex the index of the symbol, should be less than Length()
//! (first symbol of the string has index 0)
//! @return the pointer to the symbol
const Type* GetCharBuffer (const Standard_Integer theCharIndex) const;
@ -78,45 +80,67 @@ public:
//! @param theCopy string to copy.
NCollection_UtfString (const NCollection_UtfString& theCopy);
//! Copy constructor from NULL-terminated UTF-8 string.
//! @param theCopyUtf8 NULL-terminated UTF-8 string to copy
//! @param theLength the length limit in Unicode symbols (NOT bytes!)
//! Copy constructor from UTF-8 string.
//! @param theCopyUtf8 UTF-8 string to copy
//! @param theLength optional length limit in Unicode symbols (NOT bytes!)
//! The string is copied till NULL symbol or, if theLength >0,
//! till either NULL or theLength-th symbol (which comes first).
NCollection_UtfString (const char* theCopyUtf8,
const Standard_Integer theLength = -1);
//! Copy constructor from NULL-terminated UTF-16 string.
//! @param theCopyUtf16 NULL-terminated UTF-16 string to copy
//! Copy constructor from UTF-16 string.
//! @param theCopyUtf16 UTF-16 string to copy
//! @param theLength the length limit in Unicode symbols (NOT bytes!)
//! The string is copied till NULL symbol or, if theLength >0,
//! till either NULL or theLength-th symbol (which comes first).
NCollection_UtfString (const Standard_Utf16Char* theCopyUtf16,
const Standard_Integer theLength = -1);
//! Copy constructor from NULL-terminated UTF-32 string.
//! @param theCopyUtf32 NULL-terminated UTF-32 string to copy
//! Copy constructor from UTF-32 string.
//! @param theCopyUtf32 UTF-32 string to copy
//! @param theLength the length limit in Unicode symbols (NOT bytes!)
//! The string is copied till NULL symbol or, if theLength >0,
//! till either NULL or theLength-th symbol (which comes first).
NCollection_UtfString (const Standard_Utf32Char* theCopyUtf32,
const Standard_Integer theLength = -1);
#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) || (defined(_MSC_VER) && _MSC_VER >= 1900)
//! Copy constructor from NULL-terminated wide UTF string.
//! @param theCopyUtfWide NULL-terminated wide UTF string to copy
//! Copy constructor from wide UTF string.
//! @param theCopyUtfWide wide UTF string to copy
//! @param theLength the length limit in Unicode symbols (NOT bytes!)
//! The string is copied till NULL symbol or, if theLength >0,
//! till either NULL or theLength-th symbol (which comes first).
//!
//! This constructor is undefined if Standard_WideChar is the same type as Standard_Utf16Char.
NCollection_UtfString (const Standard_WideChar* theCopyUtfWide,
const Standard_Integer theLength = -1);
#endif
//! Copy from NULL-terminated Unicode string.
//! @param theStringUtf NULL-terminated Unicode string
//! Copy from Unicode string in UTF-8, UTF-16, or UTF-32 encoding,
//! determined by size of TypeFrom character type.
//! @param theStringUtf Unicode string
//! @param theLength the length limit in Unicode symbols
//! The string is copied till NULL symbol or, if theLength >0,
//! till either NULL or theLength-th symbol (which comes first).
template <typename TypeFrom>
void FromUnicode (const TypeFrom* theStringUtf,
const Standard_Integer theLength = -1);
inline void FromUnicode (const TypeFrom* theStringUtf,
const Standard_Integer theLength = -1)
{
NCollection_UtfIterator<TypeFrom> anIterRead (theStringUtf);
if (*anIterRead == 0)
{
// special case
Clear();
return;
}
fromUnicodeImpl (theStringUtf, theLength, anIterRead);
}
//! Copy from NULL-terminated multibyte string in system locale.
//! You should avoid this function unless extreme necessity.
//! @param theString NULL-terminated multibyte string
//! Copy from multibyte string in current system locale.
//! @param theString multibyte string
//! @param theLength the length limit in Unicode symbols
//! The string is copied till NULL symbol or, if theLength >0,
//! till either NULL or theLength-th symbol (which comes first).
void FromLocale (const char* theString,
const Standard_Integer theLength = -1);
@ -153,8 +177,7 @@ public:
//! @return copy in wide format (UTF-16 on Windows and UTF-32 on Linux)
const NCollection_UtfString<Standard_WideChar> ToUtfWide() const;
//! Converts the string into multibyte string.
//! You should avoid this function unless extreme necessity.
//! Converts the string into string in the current system locale.
//! @param theBuffer output buffer
//! @param theSizeBytes buffer size in bytes
//! @return true on success
@ -210,16 +233,50 @@ public: //! @name compare operators
private: //! @name low-level methods
//! Compute advance for specified string.
//! @param theStringUtf pointer to the NULL-terminated Unicode string
//! @param theLengthMax length limit (to cut the string), set to -1 to compute up to NULL-termination symbol
//! @param theSizeBytes advance in bytes (out)
//! @param theLength string length (out)
//! Implementation of copy routine for string of the same type
void fromUnicodeImpl (const Type* theStringUtf, const Standard_Integer theLength, NCollection_UtfIterator<Type>& theIterator)
{
Type* anOldBuffer = myString; // necessary in case of self-copying
// advance to the end
const Standard_Integer aLengthMax = (theLength > 0) ? theLength : IntegerLast();
for(; *theIterator != 0 && theIterator.Index() < aLengthMax; ++theIterator) {}
mySize = Standard_Integer((Standard_Byte* )theIterator.BufferHere() - (Standard_Byte* )theStringUtf);
myLength = theIterator.Index();
myString = strAlloc (mySize);
strCopy ((Standard_Byte* )myString, (const Standard_Byte* )theStringUtf, mySize);
strFree (anOldBuffer);
}
//! Implementation of copy routine for string of other types
template<typename TypeFrom>
static void strGetAdvance (const TypeFrom* theStringUtf,
const Standard_Integer theLengthMax,
Standard_Integer& theSizeBytes,
Standard_Integer& theLength);
void fromUnicodeImpl (typename opencascade::std::enable_if<! opencascade::std::is_same<Type, TypeFrom>::value, const TypeFrom*>::type theStringUtf,
const Standard_Integer theLength, NCollection_UtfIterator<TypeFrom>& theIterator)
{
Type* anOldBuffer = myString; // necessary in case of self-copying
mySize = 0;
const Standard_Integer aLengthMax = (theLength > 0) ? theLength : IntegerLast();
for (; *theIterator != 0 && theIterator.Index() < aLengthMax; ++theIterator)
{
mySize += theIterator.template AdvanceBytesUtf<Type>();
}
myLength = theIterator.Index();
myString = strAlloc (mySize);
// copy string
theIterator.Init (theStringUtf);
Type* anIterWrite = myString;
for (; *theIterator != 0 && theIterator.Index() < myLength; ++theIterator)
{
anIterWrite = theIterator.GetUtf (anIterWrite);
}
strFree (anOldBuffer);
}
//! Allocate NULL-terminated string buffer.
static Type* strAlloc (const Standard_Size theSizeBytes)

96
src/NCollection/NCollection_UtfString.lxx
View File

@ -13,53 +13,6 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// =======================================================================
// function : strGetAdvance
// purpose : Compute advance for specified string.
// =======================================================================
template<typename TypeTo> template<typename TypeFrom> inline
void NCollection_UtfString<TypeTo>::strGetAdvance (const TypeFrom* theStringUtf,
const Standard_Integer theLengthMax,
Standard_Integer& theSizeBytes,
Standard_Integer& theLength)
{
theSizeBytes = 0;
theLength = 0;
NCollection_UtfIterator<TypeFrom> anIter (theStringUtf);
const Standard_Integer aLengthMax = (theLengthMax > 0) ? theLengthMax : IntegerLast();
switch (sizeof(TypeTo))
{
case sizeof(Standard_Utf8Char):
{
for (; *anIter != 0 && anIter.Index() < aLengthMax; ++anIter)
{
theSizeBytes += anIter.AdvanceBytesUtf8();
}
theLength = anIter.Index();
return;
}
case sizeof(Standard_Utf16Char):
{
for (; *anIter != 0 && anIter.Index() < aLengthMax; ++anIter)
{
theSizeBytes += anIter.AdvanceBytesUtf16();
}
theLength = anIter.Index();
return;
}
case sizeof(Standard_Utf32Char):
{
for (; *anIter != 0 && anIter.Index() < aLengthMax; ++anIter)
{
theSizeBytes += anIter.AdvanceBytesUtf32();
}
theLength = anIter.Index();
return;
}
default: return;
}
}
// =======================================================================
// function : GetChar
// purpose :
@ -225,55 +178,6 @@ const NCollection_UtfString<Type>& NCollection_UtfString<Type>::operator= (const
return (*this);
}
// =======================================================================
// function : FromUnicode
// purpose :
// =======================================================================
template<typename Type> template<typename TypeFrom>
void NCollection_UtfString<Type>::FromUnicode (const TypeFrom* theStringUtf,
const Standard_Integer theLength)
{
Type* anOldBuffer = myString; // necessary in case of self-copying
NCollection_UtfIterator<TypeFrom> anIterRead (theStringUtf);
if (*anIterRead == 0)
{
// special case
Clear();
return;
}
switch (sizeof(TypeFrom)) // use switch() rather than if() to shut up msvc compiler
{
case sizeof(Type):
{
if (theLength > 0)
{
// optimized copy
for(; *anIterRead != 0 && anIterRead.Index() < theLength; ++anIterRead) {}
mySize = Standard_Integer((Standard_Byte* )anIterRead.BufferHere() - (Standard_Byte* )theStringUtf);
myLength = anIterRead.Index();
myString = strAlloc (mySize);
strCopy ((Standard_Byte* )myString, (const Standard_Byte* )theStringUtf, mySize);
strFree (anOldBuffer);
return;
}
}
default: break;
}
strGetAdvance (theStringUtf, theLength, mySize, myLength);
myString = strAlloc (mySize);
// reset iterator
anIterRead.Init (theStringUtf);
Type* anIterWrite = myString;
for (; *anIterRead != 0 && anIterRead.Index() < myLength; ++anIterRead)
{
anIterWrite = anIterRead.GetUtf (anIterWrite);
}
strFree (anOldBuffer);
}
#if !defined(__ANDROID__)
//! Auxiliary convertion tool.
class NCollection_UtfStringTool

4
src/OSD/OSD_Host.cxx
View File

@ -217,8 +217,10 @@ OSD_Host :: OSD_Host () {
ZeroMemory (&ms, sizeof(ms));
ZeroMemory (szHostName, sizeof(char) * (MAX_COMPUTERNAME_LENGTH + 1));
#ifdef _MSC_VER
// suppress GetVersionEx() deprecation warning
#if defined(__INTEL_COMPILER)
#pragma warning(disable : 1478)
#elif defined(_MSC_VER)
#pragma warning(disable : 4996)
#endif
if (!GetVersionExW (&osVerInfo))

2
src/QABugs/QABugs_11.cxx
View File

@ -2399,7 +2399,7 @@ static Standard_Integer OCC6143 (Draw_Interpretor& di, Standard_Integer argc, co
di << "(Real) Underflow";
//cout.flush();
di << "\n";
Standard_Real res, r=1.0e-308;
Standard_Real res, r = RealSmall();
res = r * r;
//res = res + 1.;
//++++ cout<<"-- "<<res<<"="<<r<<"*"<<r<<" Does not Caught... KO"<<endl;

2
src/QANCollection/QANCollection_Handle.cxx
View File

@ -317,8 +317,6 @@ namespace
{
class qaclass50_50ANON : public qaclass49_50
{
public:
qaclass50_50ANON() {}
};
}

4
src/ShapeExtend/ShapeExtend_Explorer.cxx
View File

@ -215,8 +215,8 @@ TopoDS_Shape ShapeExtend_Explorer::SortedCompound (const TopoDS_Shape& shape,
BRep_Builder BB;
BB.MakeCompound(CC);
//Standard_Integer iena = Standard_False; //szv#4:S4163:12Mar99 unused
for (TopExp_Explorer expl (shape,type); expl.More(); expl.Next()) {
nb ++; sh = expl.Current();
for (TopExp_Explorer aExp (shape,type); aExp.More(); aExp.Next()) {
nb ++; sh = aExp.Current();
BB.Add (CC,sh);
}
if (nb == 0) CC.Nullify();

2
src/Standard/Standard_Atomic.hxx
View File

@ -61,7 +61,7 @@ extern "C" {
long _InterlockedDecrement (volatile long* lpAddend);
}
#if defined(_MSC_VER)
#if defined(_MSC_VER) && ! defined(__INTEL_COMPILER)
// force intrinsic instead of WinAPI calls
#pragma intrinsic (_InterlockedIncrement)
#pragma intrinsic (_InterlockedDecrement)

2
src/TopOpeBRepBuild/TopOpeBRepBuild_VertexInfo.cxx
View File

@ -140,7 +140,7 @@ TopOpeBRepBuild_VertexInfo::TopOpeBRepBuild_VertexInfo()
void TopOpeBRepBuild_VertexInfo::Dump() const
{
printf(" *** Dump the Vertex Info ***\n");
printf(" mySmart : %ud\n", mySmart);
printf(" mySmart : %d\n", (mySmart ? 0 : 1));
printf(" Edges : %d In, %d Out\n", myEdgesIn.Extent(), myEdgesOut.Extent());

5
src/XSControl/XSControl_Utils.cxx
View File

@ -444,8 +444,9 @@ static const Standard_ExtString voidext = { 0 };
TopoDS_Compound CC;
BRep_Builder BB;
BB.MakeCompound(CC);
for (TopExp_Explorer expl (shape,type); expl.More(); expl.Next()) {
nb ++; sh = expl.Current();
for (TopExp_Explorer aExp (shape,type); aExp.More(); aExp.Next()) {
nb ++;
sh = aExp.Current();
BB.Add (CC,sh);
}
if (nb == 0) CC.Nullify();