0028824: Possibility to build OCCT 7.1.0 and above using Visual Studio 2008
authoroan <oan@opencascade.com>
Thu, 14 Sep 2017 08:39:36 +0000 (11:39 +0300)
committerbugmaster <bugmaster@opencascade.com>
Fri, 22 Sep 2017 08:52:00 +0000 (11:52 +0300)
Possibility to build OCCT using Visual Studio 2008 (VC9) is restored.
For that:

- template functions and classes from namespace std or tr1 (for VC9) are imported to namespace opencascade which is then used instead of std in relevant places
- templates not provided by compiler (VC9) but required for OCCT are defined in this namespace (in Standard_Handle.hxx)
- methods implementing move semantics are excluded for VC9 compiler (which does not support && syntax)
- support of vc9 compiler is restored in build procedures and environment scripts
- check of type of the current class in macros DEFINE_STANDARD_RTTI* is refactored

VS 2008 is restored in the list of supported platforms on Overview / System Requirements.

23 files changed:
adm/templates/env.bat
adm/templates/env.bat.in
adm/templates/template.vc9
dox/overview/overview.md
src/BVH/BVH_BinaryTree.hxx
src/BVH/BVH_Types.hxx
src/BinLDrivers/BinLDrivers_DocumentRetrievalDriver.cxx
src/BinLDrivers/BinLDrivers_DocumentSection.cxx
src/DrawTrSurf/DrawTrSurf.hxx
src/IGESData/IGESData_IGESWriter.hxx
src/NCollection/NCollection_Array1.hxx
src/NCollection/NCollection_DefineHSequence.hxx
src/NCollection/NCollection_Shared.hxx
src/NCollection/NCollection_StlIterator.hxx
src/NCollection/NCollection_UBTreeFiller.hxx
src/OpenGl/OpenGl_Context.cxx
src/Poly/Poly_Connect.cxx
src/QANCollection/QANCollection_Handle.cxx
src/RWStl/RWStl_Reader.cxx
src/Standard/Standard_ArrayStreamBuffer.hxx
src/Standard/Standard_Handle.hxx
src/Standard/Standard_Type.hxx
src/Standard/Standard_TypeDef.hxx

index 0748e48..65c399d 100644 (file)
@@ -82,6 +82,8 @@ set "VisualStudioExpressName=VCExpress"
 
 if not "%DevEnvDir%" == "" (
   rem If DevEnvDir is already defined (e.g. in custom.bat), use that value
+) else if /I "%VCFMT%" == "vc9" (
+  set "DevEnvDir=%VS90COMNTOOLS%..\IDE"
 ) else if /I "%VCFMT%" == "vc10" (
   set "DevEnvDir=%VS100COMNTOOLS%..\IDE"
 ) else if /I "%VCFMT%" == "vc11" (
@@ -101,12 +103,22 @@ if not "%DevEnvDir%" == "" (
 ) else if /I "%VCFMT%" == "gcc" (
   rem MinGW
 ) else (
-  echo Error: wrong VS identifier
+  echo Error: first argument ^(%VCVER%^) should specify supported version of Visual C++, 
+  echo one of: 
+  echo vc9   = VS 2008 ^(SP1^)
+  echo vc10  = VS 2010 ^(SP3^)
+  echo vc11  = VS 2012 ^(SP3^)
+  echo vc12  = VS 2013 ^(SP3^)
+  echo vc14  = VS 2015
+  echo vc141 = VS 2017
   exit /B
 )
 
 rem ----- Parsing vcvarsall for qt samples and define PlatformToolset -----
-if /I "%VCFMT%" == "vc10" (
+if /I "%VCFMT%" == "vc9" (
+  set "VCVARS=%VS90COMNTOOLS%..\..\VC\vcvarsall.bat"
+  set "VCPlatformToolSet=v90"
+) else if /I "%VCFMT%" == "vc10" (
   set "VCVARS=%VS100COMNTOOLS%..\..\VC\vcvarsall.bat"
   set "VCPlatformToolSet=v100"
 ) else if /I "%VCFMT%" == "vc11" (
@@ -126,9 +138,8 @@ if /I "%VCFMT%" == "vc10" (
 ) else if /I "%VCFMT%" == "gcc" (
   rem MinGW
 ) else (
-  echo Error: first argument ^(%VCVER%^) should specify supported version of Visual C++,
-  echo one of: vc10 ^(VS 2010 SP3^), vc11 ^(VS 2012 SP3^), vc12 ^(VS 2013^) or vc14 ^(VS 2015^)
-  exit
+  echo Error: wrong VS identifier
+  exit /B
 )
 
 set "CSF_OPT_LIB32D=%CSF_OPT_LIB32%"
index c84a963..74f130a 100644 (file)
@@ -52,6 +52,8 @@ set "VisualStudioExpressName=VCExpress"
 
 if not "%DevEnvDir%" == "" (
   rem If DevEnvDir is already defined (e.g. in custom.bat), use that value
+) else if /I "%VCFMT%" == "vc9" (
+  set "DevEnvDir=%VS90COMNTOOLS%..\IDE"
 ) else if /I "%VCFMT%" == "vc10" (
   set "DevEnvDir=%VS100COMNTOOLS%..\IDE"
 ) else if /I "%VCFMT%" == "vc11" (
@@ -76,7 +78,10 @@ if not "%DevEnvDir%" == "" (
 )
 
 rem ----- Parsing vcvarsall for qt samples and define PlatformToolset -----
-if /I "%VCFMT%" == "vc10" (
+if /I "%VCFMT%" == "vc9" (
+  set "VCVARS=%VS90COMNTOOLS%..\..\VC\vcvarsall.bat"
+  set "VCPlatformToolSet=v90"
+) else if /I "%VCFMT%" == "vc10" (
   set "VCVARS=%VS100COMNTOOLS%..\..\VC\vcvarsall.bat"
   set "VCPlatformToolSet=v100"
 ) else if /I "%VCFMT%" == "vc11" (
index 8dc5ba5..a6de42e 100644 (file)
@@ -24,6 +24,7 @@
                        ConfigurationType="2"
                        UseOfMFC="0"
                        ATLMinimizesCRunTimeLibraryUsage="false"
+                       CharacterSet="1"
                        >
                        <Tool
                                Name="VCPreBuildEventTool"
                        ConfigurationType="2"
                        UseOfMFC="0"
                        ATLMinimizesCRunTimeLibraryUsage="false"
-                       ManagedExtensions="0"
+                       CharacterSet="1"
                        >
                        <Tool
                                Name="VCPreBuildEventTool"
                        ConfigurationType="2"
                        UseOfMFC="0"
                        ATLMinimizesCRunTimeLibraryUsage="false"
+                       CharacterSet="1"
                        >
                        <Tool
                                Name="VCPreBuildEventTool"
                        ConfigurationType="2"
                        UseOfMFC="0"
                        ATLMinimizesCRunTimeLibraryUsage="false"
-                       ManagedExtensions="0"
+                       CharacterSet="1"
                        >
                        <Tool
                                Name="VCPreBuildEventTool"
index 6d2c8fe..5a79b3c 100644 (file)
@@ -205,9 +205,9 @@ for which OCCT is certified to work.
 
 | OS        | Compiler |
 | --------- | ----------- |
-| Windows   | Microsoft Visual Studio: 2010 SP1<sup>1</sup>, 2012 Update 4, 2013 Update 5, 2015, 2017 <br> Intel C++ Composer XE 2013 SP1 <br> GCC 4.3+ (Mingw-w64)|
+| Windows   | Microsoft Visual Studio: 2008 SP1, 2010 SP1<sup>1</sup>, 2012 Update 4, 2013 Update 5, 2015, 2017 <br> GCC 4.3+ (Mingw-w64)|
 | Linux     | GNU gcc 4.3+ <br> LLVM CLang 3.6+ |
-| OS X      | XCode 6 or newer |
+| OS X / macOS | XCode 6 or newer |
 | Android   | NDK r10, GNU gcc 4.8 or newer |
 
 1) VC++ 10 64-bit is used for regular testing and for building 
index 80d36ac..c9db4ca 100644 (file)
@@ -215,21 +215,21 @@ BVH_Tree<T, N, BVH_QuadTree>* BVH_Tree<T, N, BVH_BinaryTree>::CollapseToQuadTree
   {
     const std::pair<int, int> aNode = aQueue.front();
 
-    BVH::Array<T, N>::Append (aQBVH->myMinPointBuffer, BVH::Array<T, N>::Value (this->myMinPointBuffer, std::get<0> (aNode)));
-    BVH::Array<T, N>::Append (aQBVH->myMaxPointBuffer, BVH::Array<T, N>::Value (this->myMaxPointBuffer, std::get<0> (aNode)));
+    BVH::Array<T, N>::Append (aQBVH->myMinPointBuffer, BVH::Array<T, N>::Value (this->myMinPointBuffer, opencascade::std::get<0> (aNode)));
+    BVH::Array<T, N>::Append (aQBVH->myMaxPointBuffer, BVH::Array<T, N>::Value (this->myMaxPointBuffer, opencascade::std::get<0> (aNode)));
 
     BVH_Vec4i aNodeInfo;
-    if (this->IsOuter (std::get<0> (aNode))) // is leaf node
+    if (this->IsOuter (opencascade::std::get<0> (aNode))) // is leaf node
     {
       aNodeInfo = BVH_Vec4i (1 /* leaf flag */,
-        this->BegPrimitive (std::get<0> (aNode)), this->EndPrimitive (std::get<0> (aNode)), std::get<1> (aNode) /* level */);
+        this->BegPrimitive (opencascade::std::get<0> (aNode)), this->EndPrimitive (opencascade::std::get<0> (aNode)), opencascade::std::get<1> (aNode) /* level */);
     }
     else
     {
       NCollection_Vector<int> aGrandChildNodes;
 
-      const int aLftChild = Child<0> (std::get<0> (aNode));
-      const int aRghChild = Child<1> (std::get<0> (aNode));
+      const int aLftChild = Child<0> (opencascade::std::get<0> (aNode));
+      const int aRghChild = Child<1> (opencascade::std::get<0> (aNode));
       if (this->IsOuter (aLftChild)) // is leaf node
       {
         aGrandChildNodes.Append (aLftChild);
@@ -252,13 +252,13 @@ BVH_Tree<T, N, BVH_QuadTree>* BVH_Tree<T, N, BVH_BinaryTree>::CollapseToQuadTree
 
       for (int aNodeIdx = 0; aNodeIdx < aGrandChildNodes.Size(); ++aNodeIdx)
       {
-        aQueue.push_back (std::make_pair (aGrandChildNodes (aNodeIdx), std::get<1> (aNode) + 1));
+        aQueue.push_back (std::make_pair (aGrandChildNodes (aNodeIdx), opencascade::std::get<1> (aNode) + 1));
       }
 
       aNodeInfo = BVH_Vec4i (0 /* inner flag */,
-        aNbNodes, aGrandChildNodes.Size() - 1, std::get<1> (aNode) /* level */);
+        aNbNodes, aGrandChildNodes.Size() - 1, opencascade::std::get<1> (aNode) /* level */);
 
-      aQBVH->myDepth = Max (aQBVH->myDepth, std::get<1> (aNode) + 1);
+      aQBVH->myDepth = Max (aQBVH->myDepth, opencascade::std::get<1> (aNode) + 1);
 
       aNbNodes += aGrandChildNodes.Size();
     }
index 70dc9bf..6cbf7ae 100644 (file)
@@ -247,8 +247,15 @@ namespace BVH
       if (Size (theArray) == theCount)
       {
 #ifdef _STD_VECTOR_SHRINK
+
+#if(defined(_MSC_VER) && (_MSC_VER < 1600))
+        BVH_ArrayNt aTmpArray(theArray);
+        theArray.swap(aTmpArray);
+#else
         theArray.shrink_to_fit();
 #endif
+
+#endif
       }
       else
       {
index eede80c..ccc4e1f 100644 (file)
@@ -249,7 +249,7 @@ void BinLDrivers_DocumentRetrievalDriver::Read (Standard_IStream&
     for (; anIterS.More(); anIterS.Next()) {
       BinLDrivers_DocumentSection& aCurSection = anIterS.ChangeValue();
       if (aCurSection.IsPostRead() == Standard_False) {
-        theIStream.seekg ((streampos) aCurSection.Offset());
+        theIStream.seekg ((std::streamsize)aCurSection.Offset());
         if (aCurSection.Name().IsEqual ((Standard_CString)SHAPESECTION_POS)) 
           ReadShapeSection (aCurSection, theIStream);
         else
@@ -321,7 +321,7 @@ void BinLDrivers_DocumentRetrievalDriver::Read (Standard_IStream&
     for (; aSectIter.More(); aSectIter.Next()) {
       BinLDrivers_DocumentSection& aCurSection = aSectIter.ChangeValue();
       if (aCurSection.IsPostRead()) {
-       theIStream.seekg ((streampos) aCurSection.Offset());
+       theIStream.seekg ((std::streamsize)aCurSection.Offset());
        ReadSection (aCurSection, theDoc, theIStream); 
       }
     }
index 1032888..b527ca5 100644 (file)
@@ -160,7 +160,7 @@ void BinLDrivers_DocumentSection::Write (Standard_OStream&   theStream,
                                          const uint64_t theOffset)
 {
   const uint64_t aSectionEnd = (uint64_t) theStream.tellp();
-  theStream.seekp(myValue[0]);
+  theStream.seekp((std::streamsize)myValue[0]);
   myValue[0] = theOffset;
   myValue[1] = aSectionEnd - theOffset;
   uint64_t aVal[3] = {
@@ -175,7 +175,7 @@ void BinLDrivers_DocumentSection::Write (Standard_OStream&   theStream,
 #endif
 
   theStream.write((char *)&aVal[0], 3*sizeof(uint64_t));
-  theStream.seekp(aSectionEnd);
+  theStream.seekp((std::streamsize)aSectionEnd);
 }
 
 //=======================================================================
index ad7a723..c6c892c 100644 (file)
@@ -89,14 +89,14 @@ public:
   //! isSenseMarker indicates whether to render the
   //! sense glyph (arrow) for curves or not
   Standard_EXPORT static void Set (const Standard_CString Name, const Handle(Geom_Geometry)& G, const Standard_Boolean isSenseMarker = Standard_True);
-template <class T> static void Set (const Standard_CString Name, const Handle(T)& Arg, typename std::enable_if<std::is_base_of<Geom_Geometry, T>::value>::type * = 0) { Set (Name, (const Handle(Geom_Geometry)&)Arg); }
+template <class T> static void Set (const Standard_CString Name, const Handle(T)& Arg, typename opencascade::std::enable_if<opencascade::std::is_base_of<Geom_Geometry, T>::value>::type * = 0) { Set (Name, (const Handle(Geom_Geometry)&)Arg); }
   
   //! Sets <C> in the variable <Name>.  Overwrite the
   //! variable if already set.
   //! isSenseMarker indicates whether to render the
   //! sense glyph (arrow) for curves or not
   Standard_EXPORT static void Set (const Standard_CString Name, const Handle(Geom2d_Curve)& C, const Standard_Boolean isSenseMarker = Standard_True);
-template <class T> static void Set (const Standard_CString Name, const Handle(T)& Arg, typename std::enable_if<std::is_base_of<Geom2d_Curve, T>::value>::type * = 0) { Set (Name, (const Handle(Geom2d_Curve)&)Arg); }
+template <class T> static void Set (const Standard_CString Name, const Handle(T)& Arg, typename opencascade::std::enable_if<opencascade::std::is_base_of<Geom2d_Curve, T>::value>::type * = 0) { Set (Name, (const Handle(Geom2d_Curve)&)Arg); }
   
   //! Sets <T> in the variable <Name>.  Overwrite the
   //! variable if already set.
index 5ec8715..c9b8af5 100644 (file)
@@ -152,7 +152,7 @@ public:
   //! classes derived from IGESData_IGESEntity, for VC++ 10 and 11 compillers
   template <class T> 
   void Send (const Handle(T)& val, Standard_Boolean negative = Standard_False, 
-             typename std::enable_if<std::is_base_of<IGESData_IGESEntity, T>::value>::type * = 0)
+             typename opencascade::std::enable_if<opencascade::std::is_base_of<IGESData_IGESEntity, T>::value>::type * = 0)
   { 
     Send ((const Handle(IGESData_IGESEntity)&)val, negative);
   }
index 8245603..85d2c43 100644 (file)
@@ -192,6 +192,8 @@ public:
   }
 
   //! Move constructor
+#if(defined(_MSC_VER) && (_MSC_VER < 1600))
+#else
   NCollection_Array1 (NCollection_Array1&& theOther)
   : myLowerBound (theOther.myLowerBound),
     myUpperBound (theOther.myUpperBound),
@@ -202,6 +204,7 @@ public:
     theOther.myDeletable  = false;
     theOther.myData       = NULL;
   }
+#endif
 
   //! C array-based constructor
   NCollection_Array1 (const TheItemType& theBegin,
@@ -279,7 +282,7 @@ public:
   }
 
   //! Move assignment
-  NCollection_Array1& Move (NCollection_Array1&& theOther)
+  NCollection_Array1& Move (NCollection_Array1& theOther)
   {
     if (&theOther == this)
     {
@@ -308,10 +311,13 @@ public:
   }
 
   //! Move assignment operator.
+#if(defined(_MSC_VER) && (_MSC_VER < 1600))
+#else
   NCollection_Array1& operator= (NCollection_Array1&& theOther)
   {
-    return Move (std::move (theOther));
+    return Move (theOther);
   }
+#endif
 
   //! @return first element
   const TheItemType& First() const
index 34a8901..9973d9b 100644 (file)
@@ -41,7 +41,7 @@ class HClassName : public _SequenceType_, public Standard_Transient {
    _SequenceType_& ChangeSequence ()       { return *this; }                   \
    template <class T>                                                          \
    void Append (const Handle(T)& theOther,                                     \
-                typename std::enable_if<std::is_base_of<HClassName, T>::value>::type * = 0) { \
+                typename opencascade::std::enable_if<opencascade::std::is_base_of<HClassName, T>::value>::type * = 0) { \
      _SequenceType_::Append (theOther->ChangeSequence());                      \
    }                                                                           \
    DEFINE_STANDARD_RTTI_INLINE(HClassName,Standard_Transient)                             \
index 446a0cc..f8125f2 100644 (file)
@@ -32,7 +32,7 @@
 //! The intent is similar to std::make_shared<> in STL, except that this
 //! implementation defines a separate type.
 
-template <class T, typename = typename std::enable_if<! std::is_base_of<Standard_Transient, T>::value>::type>
+template <class T, typename = typename opencascade::std::enable_if<! opencascade::std::is_base_of<Standard_Transient, T>::value>::type>
 class NCollection_Shared : public Standard_Transient, public T
 {
 public:
index 8e6c6ea..6789f4a 100644 (file)
 #include <Standard_Assert.hxx>
 #include <iterator>
 
-// This file uses C++11 utilities like std::is_base<>, which are not 
-// available in some environments (e.g. MSVC includes them since VS 2008).
-// Hence here we define our own implementation of these tools in namespace opencascade.
-// When all compilers support this, this namespace can be removed and replaced by std.
-namespace opencascade
-{
-  template<bool Condition, typename T>
-  struct enable_if
-  {
-    typedef T type;
-  };
-  
-  template<typename T>
-  struct enable_if<false, T>
-  {
-  };
-  
-  template<typename T1, typename T2>
-  struct is_same
-  {
-    enum { value = 0 };
-  };
-  
-  template<typename T>
-  struct is_same<T, T>
-  {
-    enum { value = 1 };
-  };
-  
-  template<bool Condition, typename TypeTrue, typename TypeFalse>
-  struct conditional
-  {
-    typedef TypeTrue type;
-  };
-
-  template<typename TypeTrue, typename TypeFalse>
-  struct conditional<false, TypeTrue, TypeFalse>
-  {
-    typedef TypeFalse type;
-  };
-}
-
 //! Helper class that allows to use NCollection iterators as STL iterators.
 //! NCollection iterator can be extended to STL iterator of any category by
 //! adding necessary methods: STL forward iterator requires IsEqual method,
@@ -70,8 +28,8 @@ namespace opencascade
 template<class Category, class BaseIterator, class ItemType, bool IsConstant>
 class NCollection_StlIterator :
   public std::iterator<Category, ItemType, ptrdiff_t,
-                       typename opencascade::conditional<IsConstant, const ItemType*, ItemType*>::type,
-                       typename opencascade::conditional<IsConstant, const ItemType&, ItemType&>::type>
+                       typename opencascade::std::conditional<IsConstant, const ItemType*, ItemType*>::type,
+                       typename opencascade::std::conditional<IsConstant, const ItemType&, ItemType&>::type>
 {
 public:
 
@@ -113,13 +71,13 @@ protected: //! @name methods related to forward STL iterator
   // an appropriate method based on template arguments (at instantiation time).
 
   template<bool Condition>
-  typename opencascade::enable_if<!Condition, ItemType&>::type Reference() const
+  typename opencascade::std::enable_if<!Condition, ItemType&>::type Reference() const
   {
     return myIterator.ChangeValue();
   }
 
   template<bool Condition>
-  typename opencascade::enable_if<Condition, const ItemType&>::type Reference() const
+  typename opencascade::std::enable_if<Condition, const ItemType&>::type Reference() const
   {
     return myIterator.Value();
   }
@@ -171,8 +129,8 @@ public: //! @name methods related to bidirectional STL iterator
   //! Prefix decrement
   NCollection_StlIterator& operator--()
   {
-    Standard_STATIC_ASSERT((opencascade::is_same<std::bidirectional_iterator_tag,Category>::value ||
-                            opencascade::is_same<std::random_access_iterator_tag,Category>::value));
+    Standard_STATIC_ASSERT((opencascade::std::is_same<std::bidirectional_iterator_tag,Category>::value ||
+                            opencascade::std::is_same<std::random_access_iterator_tag,Category>::value));
     myIterator.Previous();
     return *this;
   }
@@ -190,7 +148,7 @@ public: //! @name methods related to random access STL iterator
   //! Move forward
   NCollection_StlIterator& operator+= (typename NCollection_StlIterator::difference_type theOffset)
   {
-    Standard_STATIC_ASSERT((opencascade::is_same<std::random_access_iterator_tag,Category>::value));
+    Standard_STATIC_ASSERT((opencascade::std::is_same<std::random_access_iterator_tag,Category>::value));
     myIterator.Offset (theOffset);
     return *this;
   }
@@ -218,7 +176,7 @@ public: //! @name methods related to random access STL iterator
   //! Difference
   typename NCollection_StlIterator::difference_type operator- (const NCollection_StlIterator& theOther) const
   {
-    Standard_STATIC_ASSERT((opencascade::is_same<std::random_access_iterator_tag,Category>::value));
+    Standard_STATIC_ASSERT((opencascade::std::is_same<std::random_access_iterator_tag,Category>::value));
     return myIterator.Differ (theOther.myIterator);
   }
 
index 22f6c59..3171200 100644 (file)
@@ -130,7 +130,7 @@ template <class TheObjType, class TheBndType> class NCollection_UBTreeFiller
 
   UBTree&                               myTree;
   NCollection_Vector<ObjBnd>            mySeqPtr;
-  std::mt19937                          myRandGen;      //!< random number generator
+  opencascade::std::mt19937             myRandGen;      //!< random number generator
   Standard_Boolean                      myIsFullRandom;
 };
 
index 52f9a16..538331a 100644 (file)
@@ -2904,7 +2904,7 @@ void OpenGl_Context::ReleaseResource (const TCollection_AsciiString& theKey,
   {
     return;
   }
-  auto& aRes = mySharedResources->Find (theKey);
+  const Handle(OpenGl_Resource)& aRes = mySharedResources->Find (theKey);
   if (aRes->GetRefCount() > 1)
   {
     return;
@@ -2952,7 +2952,7 @@ void OpenGl_Context::ReleaseDelayed()
       continue;
     }
 
-    auto& aRes = mySharedResources->ChangeFind (aKey);
+    const Handle(OpenGl_Resource)& aRes = mySharedResources->ChangeFind (aKey);
     if (aRes->GetRefCount() > 1)
     {
       // should be only 1 instance in mySharedResources
index 2d2590e..3fc55e2 100644 (file)
@@ -82,13 +82,11 @@ void Poly_Connect::Load (const Handle(Poly_Triangulation)& theTriangulation)
     const Standard_Integer aNbAdjs = 6 * nbTriangles;
     if (myTriangles.Size() != nbNodes)
     {
-      TColStd_Array1OfInteger aTriArray (1, nbNodes);
-      myTriangles.Move (std::move (aTriArray));
+      myTriangles.Resize (1, nbNodes, Standard_False);
     }
     if (myAdjacents.Size() != aNbAdjs)
     {
-      TColStd_Array1OfInteger anAdjArray (1, aNbAdjs);
-      myAdjacents.Move (std::move (anAdjArray));
+      myAdjacents.Resize (1, aNbAdjs, Standard_False);
     }
   }
 
index f52c959..42f2d34 100644 (file)
@@ -435,7 +435,7 @@ static Standard_Integer QAHandleInc (Draw_Interpretor& theDI,
   }
 
   Handle(Standard_Transient) aHandle  = new Standard_Transient();
-  std::shared_ptr<Standard_Transient> aSharePtr (new Standard_Transient());
+  opencascade::std::shared_ptr<Standard_Transient> aSharePtr (new Standard_Transient());
   theDI << "Time of creating and destroying " << aNbIters << " smart pointers to the same object, per item, ns:";
   {
     {
@@ -451,7 +451,7 @@ static Standard_Integer QAHandleInc (Draw_Interpretor& theDI,
     {
       QATimer aTimer (theDI, "\nC++ shared_ptr: ", QATimer::ns, aNbIters);
       {
-        std::vector< std::shared_ptr<Standard_Transient> > aSharePointers (aNbIters);
+        std::vector< opencascade::std::shared_ptr<Standard_Transient> > aSharePointers (aNbIters);
         for (Standard_Integer anIter = 0; anIter < aNbIters; ++anIter)
         {
           aSharePointers[anIter] = aSharePtr;
index df2dfb9..29f669f 100644 (file)
@@ -250,7 +250,7 @@ Standard_Boolean RWStl_Reader::ReadAscii (Standard_IStream& theStream,
   const int64_t aEndPos = (theUntilPos > 0 ? 1 + GETPOS(theUntilPos) : std::numeric_limits<int64_t>::max());
 
   // skip header "solid ..."
-  theStream.ignore (aEndPos - aStartPos, '\n');
+  theStream.ignore ((std::streamsize)(aEndPos - aStartPos), '\n');
   if (!theStream)
   {
     Message::DefaultMessenger()->Send ("Error: premature end of file", Message_Fail);
@@ -264,7 +264,7 @@ Standard_Boolean RWStl_Reader::ReadAscii (Standard_IStream& theStream,
 
   // report progress every 1 MiB of read data
   const int aStepB = 1024 * 1024;
-  const Standard_Integer aNbSteps = 1 + Standard_Integer((theUntilPos - aStartPos) / aStepB);
+  const Standard_Integer aNbSteps = 1 + Standard_Integer((GETPOS(theUntilPos) - aStartPos) / aStepB);
   Message_ProgressSentry aPSentry (theProgress, "Reading text STL file", 0, aNbSteps, 1);
 
   int64_t aProgressPos = aStartPos + aStepB;
@@ -280,13 +280,13 @@ Standard_Boolean RWStl_Reader::ReadAscii (Standard_IStream& theStream,
     }
 
     char facet[LINELEN], outer[LINELEN];
-    theStream.getline (facet, std::min (LINELEN, aEndPos - GETPOS(theStream.tellg()))); // "facet normal nx ny nz"
+    theStream.getline (facet, (std::streamsize)std::min (LINELEN, aEndPos - GETPOS(theStream.tellg()))); // "facet normal nx ny nz"
     if (str_starts_with (facet, "endsolid", 8))
     {
       // end of STL code
       break;
     }
-    theStream.getline (outer, std::min (LINELEN, aEndPos - GETPOS(theStream.tellg()))); // "outer loop"
+    theStream.getline (outer, (std::streamsize)std::min (LINELEN, aEndPos - GETPOS(theStream.tellg()))); // "outer loop"
     if (!str_starts_with (facet, "facet", 5) || !str_starts_with (outer, "outer", 5))
     {
       TCollection_AsciiString aStr ("Error: unexpected format of facet at line ");
@@ -295,9 +295,9 @@ Standard_Boolean RWStl_Reader::ReadAscii (Standard_IStream& theStream,
       return false;
     }
 
-    theStream.getline (aLine1, std::min (LINELEN, aEndPos - GETPOS(theStream.tellg())));
-    theStream.getline (aLine2, std::min (LINELEN, aEndPos - GETPOS(theStream.tellg())));
-    theStream.getline (aLine3, std::min (LINELEN, aEndPos - GETPOS(theStream.tellg())));
+    theStream.getline (aLine1, (std::streamsize)std::min (LINELEN, aEndPos - GETPOS(theStream.tellg())));
+    theStream.getline (aLine2, (std::streamsize)std::min (LINELEN, aEndPos - GETPOS(theStream.tellg())));
+    theStream.getline (aLine3, (std::streamsize)std::min (LINELEN, aEndPos - GETPOS(theStream.tellg())));
 
     // stop reading if end of file is reached;
     // note that well-formatted file never ends by the vertex line
@@ -335,8 +335,8 @@ Standard_Boolean RWStl_Reader::ReadAscii (Standard_IStream& theStream,
       AddTriangle (n1, n2, n3);
     }
 
-    theStream.ignore (aEndPos - GETPOS(theStream.tellg()), '\n'); // skip "endloop"
-    theStream.ignore (aEndPos - GETPOS(theStream.tellg()), '\n'); // skip "endfacet"
+    theStream.ignore ((std::streamsize)(aEndPos - GETPOS(theStream.tellg())), '\n'); // skip "endloop"
+    theStream.ignore ((std::streamsize)(aEndPos - GETPOS(theStream.tellg())), '\n'); // skip "endfacet"
 
     aNbLine += 2;
   }
index 6e5973b..e472446 100644 (file)
 
 #include <fstream>
 
+// Suppress VC9 warning on xsputn() function
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4996)
+#endif
+
 //! Custom buffer object implementing STL interface std::streambuf for streamed reading from allocated memory block.
 //! Implements minimal sub-set of methods for passing buffer to std::istream, including seek support.
 //!
@@ -110,4 +116,8 @@ protected:
 
 };
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 #endif // _Standard_ArrayStreamBuffer_HeaderFile
index ee0abc7..9e7a3a6 100644 (file)
 
 class Standard_Transient;
 
+//! Namespace opencascade is intended for low-level template classes and functions
 namespace opencascade {
 
+  //! Namespace opencascade::std includes templates from C++11 std namespace used by
+  //! OCCT classes. These definitions are imported from std namespace, plus (on older 
+  //! compilers) from std::tr1, or implemented by custom code where neither std 
+  //! not std::tr1 provide necessary definitions.
+  namespace std
+  {
+  // import all available standard stuff from std namespace
+  using namespace ::std;
+
+// for old MSVC compiler, some standard templates are defined in std::tr1 namespace,
+// and some missing ones are implemented here
+#if(defined(_MSC_VER) && (_MSC_VER < 1600))
+  using namespace ::std::tr1;
+  
+  // C++11 template class enable_if
+  template<bool Test, class Type = void>
+  struct enable_if
+  {// type is undefined for assumed !_Test
+  };
+
+  template<class _Type>
+  struct enable_if<true, _Type>
+  {// type is _Type for _Test
+    typedef _Type type;
+  };
+
+  template<bool Condition, typename TypeTrue, typename TypeFalse>
+  struct conditional
+  {
+    typedef TypeTrue type;
+  };
+
+  template<typename TypeTrue, typename TypeFalse>
+  struct conditional<false, TypeTrue, TypeFalse>
+  {
+    typedef TypeFalse type;
+  };
+
+#endif
+
+  } // namespace opencascade::std
+
   //! Trait yielding true if class T1 is base of T2 but not the same
   template <class T1, class T2, class Dummy = void>
-  struct is_base_but_not_same : std::is_base_of <T1, T2> {};
+  struct is_base_but_not_same : opencascade::std::is_base_of <T1, T2> {};
 
   //! Explicit specialization of is_base_of trait to workaround the
   //! requirement of type to be complete when T1 and T2 are the same.
   template <class T1, class T2>
-  struct is_base_but_not_same <T1, T2, typename std::enable_if <std::is_same <T1, T2>::value>::type> : std::false_type {};
+  struct is_base_but_not_same <T1, T2, typename opencascade::std::enable_if <opencascade::std::is_same <T1, T2>::value>::type> : opencascade::std::false_type {};
 
   //! Intrusive smart pointer for use with Standard_Transient class and its descendants.
   //!
@@ -79,11 +122,14 @@ namespace opencascade {
       BeginScope();
     }
 
+#if(defined(_MSC_VER) && (_MSC_VER < 1600))
+#else
     //! Move constructor
     handle (handle&& theHandle) : entity(theHandle.entity)
     {
       theHandle.entity = 0;
     }
+#endif
 
     //! Destructor
     ~handle ()
@@ -120,12 +166,15 @@ namespace opencascade {
       return *this;
     }
 
+#if(defined(_MSC_VER) && (_MSC_VER < 1600))
+#else
     //! Move operator
     handle& operator= (handle&& theHandle)
     {
       std::swap (this->entity, theHandle.entity);
       return *this;
     }
+#endif
 
     //! STL-like cast to pointer to referred object (note non-const).
     //! @sa std::shared_ptr::get()
@@ -188,7 +237,7 @@ namespace opencascade {
 
     //! Down casting operator from handle to base type
     template <class T2>
-    static typename std::enable_if<is_base_but_not_same<T2, T>::value, handle>::type
+    static typename opencascade::std::enable_if<is_base_but_not_same<T2, T>::value, handle>::type
       DownCast (const handle<T2>& theObject)
     {
       return handle (dynamic_cast<T*>(const_cast<T2*>(theObject.get())));
@@ -196,7 +245,7 @@ namespace opencascade {
 
     //! Down casting operator from pointer to base type
     template <class T2>
-    static typename std::enable_if<is_base_but_not_same<T2, T>::value, handle>::type 
+    static typename opencascade::std::enable_if<is_base_but_not_same<T2, T>::value, handle>::type 
       DownCast (const T2* thePtr)
     {
       return handle (dynamic_cast<T*>(const_cast<T2*>(thePtr)));
@@ -205,7 +254,7 @@ namespace opencascade {
     //! For compatibility, define down casting operator from non-base type, as deprecated
     template <class T2>
     Standard_DEPRECATED("down-casting from object of the same or unrelated type is meaningless")
-    static handle DownCast (const handle<T2>& theObject, typename std::enable_if<!is_base_but_not_same<T2, T>::value, void*>::type = 0)
+    static handle DownCast (const handle<T2>& theObject, typename opencascade::std::enable_if<!is_base_but_not_same<T2, T>::value, void*>::type = 0)
     {
       return handle (dynamic_cast<T*>(const_cast<T2*>(theObject.get())));
     }
@@ -213,7 +262,7 @@ namespace opencascade {
     //! For compatibility, define down casting operator from non-base type, as deprecated
     template <class T2>
     Standard_DEPRECATED("down-casting from object of the same or unrelated type is meaningless")
-    static handle DownCast (const T2* thePtr, typename std::enable_if<!is_base_but_not_same<T2, T>::value, void*>::type = 0)
+    static handle DownCast (const T2* thePtr, typename opencascade::std::enable_if<!is_base_but_not_same<T2, T>::value, void*>::type = 0)
     {
       return handle (dynamic_cast<T*>(const_cast<T2*>(thePtr)));
     }
@@ -312,6 +361,8 @@ namespace opencascade {
       BeginScope();
     }
 
+#if(defined(_MSC_VER) && (_MSC_VER < 1600))
+#else
     //! Generalized move constructor
     template <class T2>
     handle (handle<T2>&& theHandle, typename std::enable_if <is_base_but_not_same <T, T2>::value>::type* = nullptr)
@@ -319,6 +370,7 @@ namespace opencascade {
     {
       theHandle.entity = 0;
     }
+#endif
 
     //! Generalized assignment operator.
     template <class T2>
@@ -330,6 +382,8 @@ namespace opencascade {
       return *this;
     }
 
+#if(defined(_MSC_VER) && (_MSC_VER < 1600))
+#else
     //! Generalized move operator
     template <class T2>
     handle& operator= (handle<T2>&& theHandle)
@@ -339,6 +393,7 @@ namespace opencascade {
       std::swap (this->entity, theHandle.entity);
       return *this;
     }
+#endif
 
 #else
 
@@ -351,7 +406,7 @@ namespace opencascade {
     {
       // error "type is not a member of enable_if" will be generated if T2 is not sub-type of T
       // (handle is being cast to const& to handle of non-base type)
-      return reinterpret_cast<typename std::enable_if<is_base_but_not_same<T2, T>::value, const handle<T2>&>::type>(*this);
+      return reinterpret_cast<typename opencascade::std::enable_if<is_base_but_not_same<T2, T>::value, const handle<T2>&>::type>(*this);
     }
 
     //! Upcast to non-const reference to base type.
@@ -362,7 +417,7 @@ namespace opencascade {
     {
       // error "type is not a member of enable_if" will be generated if T2 is not sub-type of T
       // (handle is being cast to const& to handle of non-base type)
-      return reinterpret_cast<typename std::enable_if<is_base_but_not_same<T2, T>::value, handle<T2>&>::type>(*this);
+      return reinterpret_cast<typename opencascade::std::enable_if<is_base_but_not_same<T2, T>::value, handle<T2>&>::type>(*this);
     }
 
 #endif /* OCCT_HANDLE_NOCAST */
index bbcf007..b21ba3a 100644 (file)
 
 // Auxiliary tools to check at compile time that class declared as base in 
 // DEFINE_STANDARD_RTTI* macro is actually a base class.
-// For GCC 4.7+, more strict check is possible -- ensuring that base class 
-// is direct base -- using non-standard C++ reflection functionality.
 #if ! defined(OCC_CHECK_BASE_CLASS)
+
 #if (defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 7) || (__GNUC__ > 4)))
 
+// For GCC 4.7+, more strict check is possible -- ensuring that base class 
+// is direct base -- using non-standard C++ reflection functionality.
+
 #include <tr2/type_traits>
 #include <tuple>
 
@@ -58,14 +60,30 @@ namespace opencascade
 
 #define OCC_CHECK_BASE_CLASS(Class,Base) \
   using direct_base_classes = opencascade::direct_base_class_as_tuple<std::tr2::direct_bases<Class>::type>::type; \
-  static_assert(opencascade::has_type<Base, direct_base_classes>::type::value, "OCCT RTTI definition is incorrect: " #Base " is not direct base class of " #Class);
+  static_assert(opencascade::has_type<Base, direct_base_classes>::type::value, "OCCT RTTI definition is incorrect: " #Base " is not direct base class of " #Class); \
+  static_assert(&get_type_name == &Class::get_type_name, "OCCT RTTI definition is misplaced: current class is not " #Class);
+
+#elif (defined(_MSC_VER) && (_MSC_VER < 1600))
+
+// VC9 does not support static_assert and decltype at all
+#define OCC_CHECK_BASE_CLASS(Class,Base)
 
-#else /* ! GCC 4.7+ */
+#elif (defined(_MSC_VER) && (_MSC_VER >= 1900))
 
+// VC14+ allow using address of member functions in static checks,
+// that allows checking for the current type being correctly named in the macro
+#define OCC_CHECK_BASE_CLASS(Class,Base) \
+  static_assert(opencascade::is_base_but_not_same<Base, Class>::value, "OCCT RTTI definition is incorrect: " #Base " is not base class of " #Class); \
+  static_assert(&get_type_name == &Class::get_type_name, "OCCT RTTI definition is misplaced: current class is not " #Class);
+
+#else
+
+// by default, check only the base class
 #define OCC_CHECK_BASE_CLASS(Class,Base) \
   static_assert(opencascade::is_base_but_not_same<Base, Class>::value, "OCCT RTTI definition is incorrect: " #Base " is not base class of " #Class);
 
-#endif /* GCC 4.7+ */
+#endif
+
 #endif /* ! defined(OCC_CHECK_BASE_CLASS) */
 
 //! Helper macro to get instance of a type descriptor for a class in a legacy way.
@@ -81,10 +99,7 @@ public: \
   typedef Base base_type; \
   static const char* get_type_name () { return #Class; OCC_CHECK_BASE_CLASS(Class,Base) } \
   static const Handle(Standard_Type)& get_type_descriptor () { return Standard_Type::Instance<Class>(); } \
-  virtual const Handle(Standard_Type)& DynamicType() const Standard_OVERRIDE { \
-    static_assert(std::is_same<const Class*, decltype(this)>::value, "OCCT RTTI definition is misplaced: current class is not " #Class); \
-    return get_type_descriptor (); \
-  }
+  virtual const Handle(Standard_Type)& DynamicType() const Standard_OVERRIDE { return get_type_descriptor (); }
 
 //! Helper macro to be included in definition of the classes inheriting
 //! Standard_Transient to enable use of OCCT RTTI.
@@ -100,10 +115,7 @@ public: \
 //! Defines implementation of type descriptor and DynamicType() function
 #define IMPLEMENT_STANDARD_RTTIEXT(Class,Base) \
   const Handle(Standard_Type)& Class::get_type_descriptor () { return Standard_Type::Instance<Class>(); } \
-  const Handle(Standard_Type)& Class::DynamicType() const { \
-    static_assert(std::is_same<const Class*, decltype(this)>::value, "OCCT RTTI definition is misplaced: current class is not " #Class); \
-    return STANDARD_TYPE(Class); \
-  }
+  const Handle(Standard_Type)& Class::DynamicType() const { return STANDARD_TYPE(Class); }
 
 // forward declaration of type_instance class
 namespace opencascade {
index e232d66..6216e25 100755 (executable)
 
 #include <cstddef>
 #include <ctime>
-#include <stdint.h>
+
+// VC9 does not have stdint.h
+#if(defined(_MSC_VER) && (_MSC_VER < 1600))
+  // old MSVC - hasn't stdint header
+  typedef unsigned __int8   uint8_t;
+  typedef unsigned __int16  uint16_t;
+  typedef unsigned __int32  uint32_t;
+  typedef unsigned __int64  uint64_t;
+
+  typedef __int8   int8_t;
+  typedef __int16  int16_t;
+  typedef __int32  int32_t;
+  typedef __int64  int64_t;
+#else
+  #include <stdint.h>
+#endif
 
 #if(defined(_MSC_VER) && (_MSC_VER < 1800))
   // only Visual Studio 2013 (vc12) provides <cinttypes> header
@@ -64,8 +79,8 @@ typedef std::time_t   Standard_Time;
 // Unicode primitives, char16_t, char32_t
 typedef char          Standard_Utf8Char;     //!< signed   UTF-8 char
 typedef unsigned char Standard_Utf8UChar;    //!< unsigned UTF-8 char
-#if (defined(__GNUC__) && !defined(__clang__) && ((__GNUC__ == 4 && __GNUC_MINOR__ <= 3) || __GNUC__ < 4))
-// compatibility with old GCC compilers
+#if ((defined(__GNUC__) && !defined(__clang__) && ((__GNUC__ == 4 && __GNUC_MINOR__ <= 3) || __GNUC__ < 4)) || (defined(_MSC_VER) && (_MSC_VER < 1600)))
+// compatibility with old GCC and MSVC compilers
 typedef uint16_t      Standard_ExtCharacter;
 typedef uint16_t      Standard_Utf16Char;
 typedef uint32_t      Standard_Utf32Char;