Fix submodules for realsies

.gitmodules

@@ -1,9 +1,9 @@
-[submodule "third_party/boost"]
-	path = third_party/boost
-	url = https://github.com/citra-emu/ext-boost
 [submodule "third_party/elfio"]
 	path = third_party/elfio
 	url = https://github.com/serge1/ELFIO
 [submodule "third_party/dynarmic"]
 	path = third_party/dynarmic
-	url = https://github.com/merryhime/dynarmic/tree/master/src/dynarmic
+	url = https://github.com/merryhime/dynarmic
+[submodule "third_party/boost"]
+	path = third_party/boost
+	url = https://github.com/citra-emu/ext-boost

tests/HelloWorldSVC/source/main.c

@@ -6,7 +6,7 @@
 
 int main(int argc, char** argv) {
     // Put the string on the heap to make sure heap initialization works
-    const char* buffer = calloc(6969, sizeof(char));
+    char* buffer = calloc(6969, sizeof(char));
     strcpy(buffer, "Hello world\n");
 
     svcOutputDebugString(buffer, strlen(buffer));

third_party/boost/Jamroot

@@ -144,9 +144,12 @@ import option ;
 import tools/boost\_install/boost-install ;
 
 path-constant BOOST_ROOT : . ;
-constant BOOST_VERSION : 1.71.0 ;
+constant BOOST_VERSION : 1.80.0 ;
 constant BOOST_JAMROOT_MODULE : $(__name__) ;
 
+# Allow subprojects to simply `import config : requires ;` to get access to the requires rule
+modules.poke : BOOST_BUILD_PATH : $(BOOST_ROOT)/libs/config/checks [ modules.peek : BOOST_BUILD_PATH ] ;
+
 boostcpp.set-version $(BOOST_VERSION) ;
 
 use-project /boost/architecture : libs/config/checks/architecture ;
@@ -210,18 +213,15 @@ rule handle-static-runtime ( properties * )
     # dangerous on Windows. Therefore, we disallow it. This might be drastic,
     # but it was disabled for a while without anybody complaining.
 
-    # For CW, static runtime is needed so that std::locale works.
+    local argv = [ modules.peek : ARGV ] ;
-    if <link>shared in $(properties) && <runtime-link>static in $(properties) &&
-        ! ( <toolset>cw in $(properties) )
-    {
-        if ! $(.shared-static-warning-emitted)
-        {
-            ECHO "warning: skipping configuration link=shared, runtime-link=static" ;
-            ECHO "warning: this combination is either impossible or too dangerous" ;
-            ECHO "warning: to be of any use" ;
-            .shared-static-warning-emitted = 1 ;
-        }
 
+    if <link>shared in $(properties)
+        && <runtime-link>static in $(properties)
+        # For CW, static runtime is needed so that std::locale works.
+        && ! ( <toolset>cw in $(properties) )
+        && ! --allow-shared-static in $(argv)
+    {
+        boostcpp.emit-shared-static-warning ;
         return <build>no ;
     }
 }

third_party/boost/boost/algorithm/string/compare.hpp

@@ -65,7 +65,7 @@ namespace boost {
             template< typename T1, typename T2 >
                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
             {
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
                     return std::toupper(Arg1)==std::toupper(Arg2);
                 #else
                     return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
@@ -118,7 +118,7 @@ namespace boost {
             template< typename T1, typename T2 >
                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
             {
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
                     return std::toupper(Arg1)<std::toupper(Arg2);
                 #else
                     return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
@@ -171,7 +171,7 @@ namespace boost {
             template< typename T1, typename T2 >
                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
             {
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
                     return std::toupper(Arg1)<=std::toupper(Arg2);
                 #else
                     return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);

third_party/boost/boost/algorithm/string/detail/case_conv.hpp

@@ -15,6 +15,9 @@
 #include <locale>
 #include <functional>
 
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
 
 namespace boost {
@@ -40,7 +43,7 @@ namespace boost {
                 // Operation
                 CharT operator ()( CharT Ch ) const
                 {
-                    #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                    #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
                         return std::tolower( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
                     #else
                         return std::tolower<CharT>( Ch, *m_Loc );
@@ -62,7 +65,7 @@ namespace boost {
                 // Operation
                 CharT operator ()( CharT Ch ) const
                 {
-                    #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                    #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
                         return std::toupper( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
                     #else
                         return std::toupper<CharT>( Ch, *m_Loc );

third_party/boost/boost/algorithm/string/detail/find_format_all.hpp

@@ -18,6 +18,8 @@
 #include <boost/algorithm/string/detail/find_format_store.hpp>
 #include <boost/algorithm/string/detail/replace_storage.hpp>
 
+#include <deque>
+
 namespace boost {
     namespace algorithm {
         namespace detail {

third_party/boost/boost/algorithm/string/detail/finder.hpp

@@ -13,7 +13,7 @@
 
 #include <boost/algorithm/string/config.hpp>
 #include <boost/algorithm/string/constants.hpp>
-#include <boost/detail/iterator.hpp>
+#include <iterator>
 
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/range/begin.hpp>
@@ -127,8 +127,8 @@ namespace boost {
                     if( boost::empty(m_Search) )
                         return result_type( End, End );
 
-                    typedef BOOST_STRING_TYPENAME boost::detail::
+                    typedef BOOST_STRING_TYPENAME
-                        iterator_traits<ForwardIteratorT>::iterator_category category;
+                        std::iterator_traits<ForwardIteratorT>::iterator_category category;
 
                     return findit( Begin, End, category() );
                 }
@@ -344,9 +344,8 @@ namespace boost {
                 typedef iterator_range<ForwardIteratorT> result_type;
 
                 input_iterator_type It=Begin;
-                for(
+                for( unsigned int Index=0; Index<N && It!=End; ++Index,++It )
-                    unsigned int Index=0;
+                    ;
-                    Index<N && It!=End; ++Index,++It ) {};
 
                 return result_type( Begin, It );
             }
@@ -375,8 +374,8 @@ namespace boost {
                 ForwardIteratorT End,
                 unsigned int N )
             {
-                typedef BOOST_STRING_TYPENAME boost::detail::
+                typedef BOOST_STRING_TYPENAME
-                    iterator_traits<ForwardIteratorT>::iterator_category category;
+                    std::iterator_traits<ForwardIteratorT>::iterator_category category;
 
                 return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
             }
@@ -397,10 +396,12 @@ namespace boost {
                 input_iterator_type It2=Begin;
 
                 // Advance It2 by N increments
-                for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};
+                for( Index=0; Index<N && It2!=End; ++Index,++It2 )
+                    ;
 
                 // Advance It, It2 to the end
-                for(; It2!=End; ++It,++It2 ) {};
+                for(; It2!=End; ++It,++It2 )
+                	;
 
                 return result_type( It, It2 );
             }
@@ -417,9 +418,8 @@ namespace boost {
                 typedef iterator_range<ForwardIteratorT> result_type;
 
                 input_iterator_type It=End;
-                for(
+                for( unsigned int Index=0; Index<N && It!=Begin; ++Index,--It )
-                    unsigned int Index=0;
+                    ;
-                    Index<N && It!=Begin; ++Index,--It ) {};
 
                 return result_type( It, End );
             }
@@ -448,8 +448,8 @@ namespace boost {
                 ForwardIteratorT End,
                 unsigned int N )
             {
-                typedef BOOST_STRING_TYPENAME boost::detail::
+                typedef BOOST_STRING_TYPENAME
-                    iterator_traits<ForwardIteratorT>::iterator_category category;
+                    std::iterator_traits<ForwardIteratorT>::iterator_category category;
 
                 return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
             }

third_party/boost/boost/algorithm/string/detail/formatter.hpp

@@ -42,7 +42,7 @@ namespace boost {
                     m_Format(::boost::begin(Format), ::boost::end(Format)) {}
 
                 // Operation
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
                 template<typename Range2T>
                 result_type& operator()(const Range2T&)
                 {

third_party/boost/boost/algorithm/string/find_format.hpp

@@ -12,7 +12,6 @@
 #define BOOST_STRING_FIND_FORMAT_HPP
 
 #include <deque>
-#include <boost/detail/iterator.hpp>
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

third_party/boost/boost/algorithm/string/formatter.hpp

@@ -11,7 +11,6 @@
 #ifndef BOOST_STRING_FORMATTER_HPP
 #define BOOST_STRING_FORMATTER_HPP
 
-#include <boost/detail/iterator.hpp>
 #include <boost/range/value_type.hpp>
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/range/as_literal.hpp>

third_party/boost/boost/align/align.hpp

@@ -0,0 +1,19 @@
+/*
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_ALIGN_HPP
+#define BOOST_ALIGN_ALIGN_HPP
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX11_STD_ALIGN) && !defined(BOOST_LIBSTDCXX_VERSION)
+#include <boost/align/detail/align_cxx11.hpp>
+#else
+#include <boost/align/detail/align.hpp>
+#endif
+
+#endif

third_party/boost/boost/align/aligned_alloc.hpp

@@ -0,0 +1,47 @@
+/*
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_ALIGNED_ALLOC_HPP
+#define BOOST_ALIGN_ALIGNED_ALLOC_HPP
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_HAS_UNISTD_H)
+#include <unistd.h>
+#endif
+
+#if defined(__APPLE__) || defined(__APPLE_CC__) || defined(macintosh)
+#include <AvailabilityMacros.h>
+#endif
+
+#if defined(BOOST_ALIGN_USE_ALIGN)
+#include <boost/align/detail/aligned_alloc.hpp>
+#elif defined(BOOST_ALIGN_USE_NEW)
+#include <boost/align/detail/aligned_alloc_new.hpp>
+#elif defined(_MSC_VER) && !defined(UNDER_CE)
+#include <boost/align/detail/aligned_alloc_msvc.hpp>
+#elif defined(__MINGW32__) && (__MSVCRT_VERSION__ >= 0x0700)
+#include <boost/align/detail/aligned_alloc_msvc.hpp>
+#elif defined(__MINGW32__)
+#include <boost/align/detail/aligned_alloc_mingw.hpp>
+#elif MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
+#include <boost/align/detail/aligned_alloc_posix.hpp>
+#elif MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
+#include <boost/align/detail/aligned_alloc_macos.hpp>
+#elif defined(__ANDROID__)
+#include <boost/align/detail/aligned_alloc_android.hpp>
+#elif defined(__SunOS_5_11) || defined(__SunOS_5_12)
+#include <boost/align/detail/aligned_alloc_posix.hpp>
+#elif defined(sun) || defined(__sun)
+#include <boost/align/detail/aligned_alloc_sunos.hpp>
+#elif (_POSIX_C_SOURCE >= 200112L) || (_XOPEN_SOURCE >= 600)
+#include <boost/align/detail/aligned_alloc_posix.hpp>
+#else
+#include <boost/align/detail/aligned_alloc.hpp>
+#endif
+
+#endif

third_party/boost/boost/align/alignment_of.hpp

@@ -0,0 +1,54 @@
+/*
+Copyright 2014-2016 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_ALIGNMENT_OF_HPP
+#define BOOST_ALIGN_ALIGNMENT_OF_HPP
+
+#include <boost/align/detail/element_type.hpp>
+#include <boost/align/alignment_of_forward.hpp>
+
+#if defined(_MSC_VER) && defined(__clang__)
+#include <boost/align/detail/alignment_of_cxx11.hpp>
+#elif defined(BOOST_MSVC)
+#include <boost/align/detail/alignment_of_msvc.hpp>
+#elif defined(__GNUC__) && defined(__unix__) && !defined(__LP64__)
+#include <boost/align/detail/alignment_of.hpp>
+#elif defined(BOOST_CLANG) && !defined(__x86_64__)
+#include <boost/align/detail/alignment_of.hpp>
+#elif !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#include <boost/align/detail/alignment_of_cxx11.hpp>
+#elif defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600)
+#include <boost/align/detail/alignment_of_gcc.hpp>
+#elif defined(BOOST_CODEGEARC)
+#include <boost/align/detail/alignment_of_codegear.hpp>
+#elif defined(BOOST_CLANG)
+#include <boost/align/detail/alignment_of_clang.hpp>
+#elif __GNUC__ > 4
+#include <boost/align/detail/alignment_of_gcc.hpp>
+#elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)
+#include <boost/align/detail/alignment_of_gcc.hpp>
+#else
+#include <boost/align/detail/alignment_of.hpp>
+#endif
+
+namespace boost {
+namespace alignment {
+
+template<class T>
+struct alignment_of
+    : detail::alignment_of<typename
+        detail::element_type<T>::type>::type { };
+
+#if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
+template<class T>
+constexpr std::size_t alignment_of_v = alignment_of<T>::value;
+#endif
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/alignment_of_forward.hpp

@@ -0,0 +1,20 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_ALIGNMENT_OF_FORWARD_HPP
+#define BOOST_ALIGN_ALIGNMENT_OF_FORWARD_HPP
+
+namespace boost {
+namespace alignment {
+
+template<class T>
+struct alignment_of;
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/align.hpp

@@ -0,0 +1,38 @@
+/*
+Copyright 2014-2020 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGN_HPP
+#define BOOST_ALIGN_DETAIL_ALIGN_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace alignment {
+
+inline void*
+align(std::size_t alignment, std::size_t size, void*& ptr,
+    std::size_t& space)
+{
+    BOOST_ASSERT(boost::alignment::detail::is_alignment(alignment));
+    if (size <= space) {
+        char* p = reinterpret_cast<char*>(~(alignment - 1) &
+            (reinterpret_cast<std::size_t>(ptr) + alignment - 1));
+        std::size_t n = p - static_cast<char*>(ptr);
+        if (n <= space - size) {
+            ptr = p;
+            space -= n;
+            return p;
+        }
+    }
+    return 0;
+}
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/align_cxx11.hpp

@@ -0,0 +1,21 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP
+#define BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP
+
+#include <memory>
+
+namespace boost {
+namespace alignment {
+
+using std::align;
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/aligned_alloc.hpp

@@ -0,0 +1,52 @@
+/*
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/align/align.hpp>
+#include <boost/align/alignment_of.hpp>
+#include <boost/assert.hpp>
+#include <cstdlib>
+
+namespace boost {
+namespace alignment {
+
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    enum {
+        N = alignment_of<void*>::value
+    };
+    if (alignment < N) {
+        alignment = N;
+    }
+    std::size_t n = size + alignment - N;
+    void* p = std::malloc(sizeof(void*) + n);
+    if (p) {
+        void* r = static_cast<char*>(p) + sizeof(void*);
+        (void)boost::alignment::align(alignment, size, r, n);
+        *(static_cast<void**>(r) - 1) = p;
+        p = r;
+    }
+    return p;
+}
+
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
+{
+    if (ptr) {
+        std::free(*(static_cast<void**>(ptr) - 1));
+    }
+}
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/aligned_alloc_android.hpp

@@ -0,0 +1,34 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_ANDROID_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_ANDROID_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/assert.hpp>
+#include <malloc.h>
+
+namespace boost {
+namespace alignment {
+
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    return ::memalign(alignment, size);
+}
+
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
+{
+    ::free(ptr);
+}
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/aligned_alloc_macos.hpp

@@ -0,0 +1,44 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MACOS_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MACOS_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/assert.hpp>
+#include <stdlib.h>
+
+namespace boost {
+namespace alignment {
+
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    if (size == 0) {
+        return 0;
+    }
+    if (alignment < sizeof(void*)) {
+        alignment = sizeof(void*);
+    }
+    void* p;
+    if (::posix_memalign(&p, alignment, size) != 0) {
+        p = 0;
+    }
+    return p;
+}
+
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
+{
+    ::free(ptr);
+}
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/aligned_alloc_mingw.hpp

@@ -0,0 +1,34 @@
+/*
+Copyright 2020 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MINGW_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MINGW_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/assert.hpp>
+#include <malloc.h>
+
+namespace boost {
+namespace alignment {
+
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    return ::__mingw_aligned_malloc(size, alignment);
+}
+
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
+{
+    ::__mingw_aligned_free(ptr);
+}
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/aligned_alloc_msvc.hpp

@@ -0,0 +1,34 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MSVC_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MSVC_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/assert.hpp>
+#include <malloc.h>
+
+namespace boost {
+namespace alignment {
+
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    return ::_aligned_malloc(size, alignment);
+}
+
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
+{
+    ::_aligned_free(ptr);
+}
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/aligned_alloc_new.hpp

@@ -0,0 +1,52 @@
+/*
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_NEW_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_NEW_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/align/align.hpp>
+#include <boost/align/alignment_of.hpp>
+#include <boost/assert.hpp>
+#include <new>
+
+namespace boost {
+namespace alignment {
+
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    enum {
+        N = alignment_of<void*>::value
+    };
+    if (alignment < N) {
+        alignment = N;
+    }
+    std::size_t n = size + alignment - N;
+    void* p = ::operator new(sizeof(void*) + n, std::nothrow);
+    if (p) {
+        void* r = static_cast<char*>(p) + sizeof(void*);
+        (void)boost::alignment::align(alignment, size, r, n);
+        *(static_cast<void**>(r) - 1) = p;
+        p = r;
+    }
+    return p;
+}
+
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
+{
+    if (ptr) {
+        ::operator delete(*(static_cast<void**>(ptr) - 1));
+    }
+}
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/aligned_alloc_posix.hpp

@@ -0,0 +1,41 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_POSIX_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_POSIX_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/assert.hpp>
+#include <stdlib.h>
+
+namespace boost {
+namespace alignment {
+
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    if (alignment < sizeof(void*)) {
+        alignment = sizeof(void*);
+    }
+    void* p;
+    if (::posix_memalign(&p, alignment, size) != 0) {
+        p = 0;
+    }
+    return p;
+}
+
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
+{
+    ::free(ptr);
+}
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/aligned_alloc_sunos.hpp

@@ -0,0 +1,34 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_SUNOS_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_SUNOS_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/assert.hpp>
+#include <stdlib.h>
+
+namespace boost {
+namespace alignment {
+
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    return ::memalign(alignment, size);
+}
+
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
+{
+    ::free(ptr);
+}
+
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/alignment_of.hpp

@@ -0,0 +1,31 @@
+/*
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_HPP
+
+#include <boost/align/detail/min_size.hpp>
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+template<class T>
+struct offset_value {
+    char value;
+    T object;
+};
+
+template<class T>
+struct alignment_of
+    : min_size<sizeof(T), sizeof(offset_value<T>) - sizeof(T)> { };
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/alignment_of_clang.hpp

@@ -0,0 +1,26 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CLANG_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CLANG_HPP
+
+#include <boost/align/detail/integral_constant.hpp>
+#include <cstddef>
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+template<class T>
+struct alignment_of
+    : integral_constant<std::size_t, __alignof(T)> { };
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/alignment_of_codegear.hpp

@@ -0,0 +1,26 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CODEGEAR_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CODEGEAR_HPP
+
+#include <boost/align/detail/integral_constant.hpp>
+#include <cstddef>
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+template<class T>
+struct alignment_of
+    : integral_constant<std::size_t, alignof(T)> { };
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/alignment_of_cxx11.hpp

@@ -0,0 +1,23 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CXX11_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CXX11_HPP
+
+#include <type_traits>
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+using std::alignment_of;
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/alignment_of_gcc.hpp

@@ -0,0 +1,26 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_GCC_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_GCC_HPP
+
+#include <boost/align/detail/integral_constant.hpp>
+#include <cstddef>
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+template<class T>
+struct alignment_of
+    : integral_constant<std::size_t, __alignof__(T)> { };
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/alignment_of_msvc.hpp

@@ -0,0 +1,32 @@
+/*
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_MSVC_HPP
+#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_MSVC_HPP
+
+#include <boost/align/detail/min_size.hpp>
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+template<class T>
+struct offset_value {
+    T first;
+    char value;
+    T second;
+};
+
+template<class T>
+struct alignment_of
+    : min_size<sizeof(T), sizeof(offset_value<T>) - (sizeof(T) << 1)> { };
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/element_type.hpp

@@ -0,0 +1,91 @@
+/*
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ELEMENT_TYPE_HPP
+#define BOOST_ALIGN_DETAIL_ELEMENT_TYPE_HPP
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#include <type_traits>
+#else
+#include <cstddef>
+#endif
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+using std::remove_reference;
+using std::remove_all_extents;
+using std::remove_cv;
+#else
+template<class T>
+struct remove_reference {
+    typedef T type;
+};
+
+template<class T>
+struct remove_reference<T&> {
+    typedef T type;
+};
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+template<class T>
+struct remove_reference<T&&> {
+    typedef T type;
+};
+#endif
+
+template<class T>
+struct remove_all_extents {
+    typedef T type;
+};
+
+template<class T>
+struct remove_all_extents<T[]> {
+    typedef typename remove_all_extents<T>::type type;
+};
+
+template<class T, std::size_t N>
+struct remove_all_extents<T[N]> {
+    typedef typename remove_all_extents<T>::type type;
+};
+
+template<class T>
+struct remove_cv {
+    typedef T type;
+};
+
+template<class T>
+struct remove_cv<const T> {
+    typedef T type;
+};
+
+template<class T>
+struct remove_cv<volatile T> {
+    typedef T type;
+};
+
+template<class T>
+struct remove_cv<const volatile T> {
+    typedef T type;
+};
+#endif
+
+template<class T>
+struct element_type {
+    typedef typename remove_cv<typename remove_all_extents<typename
+        remove_reference<T>::type>::type>::type type;
+};
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/integral_constant.hpp

@@ -0,0 +1,53 @@
+/*
+Copyright 2014-2016 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_INTEGRAL_CONSTANT_HPP
+#define BOOST_ALIGN_DETAIL_INTEGRAL_CONSTANT_HPP
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#include <type_traits>
+#endif
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+using std::integral_constant;
+using std::true_type;
+using std::false_type;
+#else
+template<class T, T Value>
+struct integral_constant {
+    typedef T value_type;
+    typedef integral_constant type;
+
+    BOOST_CONSTEXPR operator value_type() const BOOST_NOEXCEPT {
+        return Value;
+    }
+
+    BOOST_CONSTEXPR value_type operator()() const BOOST_NOEXCEPT {
+        return Value;
+    }
+
+    BOOST_STATIC_CONSTEXPR T value = Value;
+};
+
+template<class T, T Value>
+BOOST_CONSTEXPR_OR_CONST T integral_constant<T, Value>::value;
+
+typedef integral_constant<bool, true> true_type;
+typedef integral_constant<bool, false> false_type;
+#endif
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/is_alignment.hpp

@@ -0,0 +1,28 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP
+#define BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+BOOST_CONSTEXPR inline bool
+is_alignment(std::size_t value) BOOST_NOEXCEPT
+{
+    return (value > 0) && ((value & (value - 1)) == 0);
+}
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/align/detail/min_size.hpp

@@ -0,0 +1,26 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_MIN_SIZE_HPP
+#define BOOST_ALIGN_DETAIL_MIN_SIZE_HPP
+
+#include <boost/align/detail/integral_constant.hpp>
+#include <cstddef>
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+template<std::size_t A, std::size_t B>
+struct min_size
+    : integral_constant<std::size_t, (A < B) ? A : B> { };
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

third_party/boost/boost/archive/archive_exception.hpp

@@ -52,7 +52,7 @@ protected:
 public:
     typedef enum {
         no_exception,       // initialized without code
-        other_exception,    // any excepton not listed below
+        other_exception,    // any exception not listed below
         unregistered_class, // attempt to serialize a pointer of
                             // an unregistered class
         invalid_signature,  // first line of archive does not contain
@@ -63,7 +63,7 @@ public:
                             // serialize an object which has
                             // already been serialized through a pointer.
                             // Were this permitted, the archive load would result
-                            // in the creation of an extra copy of the obect.
+                            // in the creation of an extra copy of the object.
         incompatible_native_format, // attempt to read native binary format
                             // on incompatible platform
         array_size_too_short,// array being loaded doesn't fit in array allocated
@@ -87,9 +87,9 @@ public:
         const char * e1 = NULL,
         const char * e2 = NULL
     ) BOOST_NOEXCEPT;
-    BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT ;
+    BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT;
-    virtual BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
+    BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
-    virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW ;
+    BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
 };
 
 }// namespace archive

third_party/boost/boost/archive/basic_archive.hpp

@@ -18,9 +18,9 @@
 #include <cstring> // count
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
-#include <boost/cstdint.hpp> // size_t
-#include <boost/noncopyable.hpp>
 #include <boost/integer_traits.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/serialization/library_version_type.hpp>
 
 #include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@@ -33,52 +33,19 @@ namespace archive {
 #pragma warning( disable : 4244 4267 )
 #endif
 
-/* NOTE : Warning  : Warning : Warning : Warning : Warning
+BOOST_ARCHIVE_DECL boost::serialization::library_version_type
- * Don't ever changes this.  If you do, they previously created
- * binary archives won't be readable !!!
- */
-class library_version_type {
-private:
-    typedef uint_least16_t base_type;
-    base_type t;
-public:
-    library_version_type(): t(0) {};
-    explicit library_version_type(const unsigned int & t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    library_version_type(const library_version_type & t_) : 
-        t(t_.t)
-    {}
-    library_version_type & operator=(const library_version_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    // used for text output
-    operator base_type () const {
-        return t;
-    }                
-    // used for text input
-    operator base_type & (){
-        return t;
-    }                
-    bool operator==(const library_version_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const library_version_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-BOOST_ARCHIVE_DECL library_version_type
 BOOST_ARCHIVE_VERSION();
 
+// create alias in boost::archive for older user code.
+typedef boost::serialization::library_version_type library_version_type;
+
 class version_type {
 private:
     typedef uint_least32_t base_type;
     base_type t;
 public:
     // should be private - but MPI fails if it's not!!!
-    version_type(): t(0) {};
+    version_type(): t(0) {}
     explicit version_type(const unsigned int & t_) : t(t_){
         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
     }
@@ -111,7 +78,7 @@ private:
     base_type t;
 public:
     // should be private - but then can't use BOOST_STRONG_TYPE below
-    class_id_type() : t(0) {};
+    class_id_type() : t(0) {}
     explicit class_id_type(const int t_) : t(t_){
         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
     }
@@ -142,18 +109,18 @@ public:
     }
 };
 
-#define NULL_POINTER_TAG boost::archive::class_id_type(-1)
+#define BOOST_SERIALIZATION_NULL_POINTER_TAG boost::archive::class_id_type(-1)
 
 class object_id_type {
 private:
     typedef uint_least32_t base_type;
     base_type t;
 public:
-    object_id_type(): t(0) {};
+    object_id_type(): t(0) {}
     // note: presumes that size_t >= unsigned int.
     // use explicit cast to silence useless warning
     explicit object_id_type(const std::size_t & t_) : t(static_cast<base_type>(t_)){
-        // make quadriple sure that we haven't lost any real integer
+        // make quadruple sure that we haven't lost any real integer
         // precision
         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
     }
@@ -188,16 +155,16 @@ struct tracking_type {
     bool t;
     explicit tracking_type(const bool t_ = false)
         : t(t_)
-    {};
+    {}
     tracking_type(const tracking_type & t_)
         : t(t_.t)
     {}
     operator bool () const {
         return t;
-    };
+    }
     operator bool & () {
         return t;
-    };
+    }
     tracking_type & operator=(const bool t_){
         t = t_;
         return *this;
@@ -279,7 +246,7 @@ BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
 // set implementation level to primitive for all types
 // used internally by the serialization library
 
-BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::serialization::library_version_type, primitive_type)
 BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
@@ -294,7 +261,7 @@ BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
 // set types used internally by the serialization library
 // to be bitwise serializable
 
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::serialization::library_version_type)
 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)
 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)

third_party/boost/boost/archive/basic_binary_iarchive.hpp

@@ -30,6 +30,7 @@
 #include <boost/archive/detail/common_iarchive.hpp>
 #include <boost/serialization/collection_size_type.hpp>
 #include <boost/serialization/string.hpp>
+#include <boost/serialization/library_version_type.hpp>
 #include <boost/serialization/item_version_type.hpp>
 #include <boost/integer_traits.hpp>
 
@@ -88,8 +89,8 @@ protected:
     void load_override(class_id_optional_type & /* t */){}
 
     void load_override(tracking_type & t, int /*version*/){
-        library_version_type lvt = this->get_library_version();
+        boost::serialization::library_version_type lv = this->get_library_version();
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lv){
             int_least8_t x=0;
             * this->This() >> x;
             t = boost::archive::tracking_type(x);
@@ -101,7 +102,7 @@ protected:
         }
     }
     void load_override(class_id_type & t){
-        library_version_type lvt = this->get_library_version();
+        boost::serialization::library_version_type lv = this->get_library_version();
         /*
          * library versions:
          *   boost 1.39 -> 5
@@ -120,7 +121,7 @@ protected:
          *
          * the fix here decodes class_id_type on 16bit for all v <= 7, which seems to be the correct behaviour ...
          */
-        if(boost::archive::library_version_type(7) < lvt){
+        if(boost::serialization::library_version_type (7) < lv){
             this->detail_common_iarchive::load_override(t);
         }
         else{
@@ -134,24 +135,24 @@ protected:
     }
 
     void load_override(version_type & t){
-        library_version_type lvt = this->get_library_version();
+        boost::serialization::library_version_type  lv = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
+        if(boost::serialization::library_version_type(7) < lv){
             this->detail_common_iarchive::load_override(t);
         }
         else
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lv){
             uint_least8_t x=0;
             * this->This() >> x;
             t = boost::archive::version_type(x);
         }
         else
-        if(boost::archive::library_version_type(5) < lvt){
+        if(boost::serialization::library_version_type(5) < lv){
             uint_least16_t x=0;
             * this->This() >> x;
             t = boost::archive::version_type(x);
         }
         else
-        if(boost::archive::library_version_type(2) < lvt){
+        if(boost::serialization::library_version_type(2) < lv){
             // upto 255 versions
             unsigned char x=0;
             * this->This() >> x;
@@ -165,13 +166,13 @@ protected:
     }
 
     void load_override(boost::serialization::item_version_type & t){
-        library_version_type lvt = this->get_library_version();
+        boost::serialization::library_version_type lv = this->get_library_version();
-//        if(boost::archive::library_version_type(7) < lvt){
+//        if(boost::serialization::library_version_type(7) < lvt){
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lv){
             this->detail_common_iarchive::load_override(t);
         }
         else
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lv){
             uint_least16_t x=0;
             * this->This() >> x;
             t = boost::serialization::item_version_type(x);
@@ -184,7 +185,7 @@ protected:
     }
 
     void load_override(serialization::collection_size_type & t){
-        if(boost::archive::library_version_type(5) < this->get_library_version()){
+        if(boost::serialization::library_version_type(5) < this->get_library_version()){
             this->detail_common_iarchive::load_override(t);
         }
         else{

third_party/boost/boost/archive/basic_binary_iprimitive.hpp

@@ -48,7 +48,6 @@ namespace std{
 #include <boost/integer.hpp>
 #include <boost/integer_traits.hpp>
 
-//#include <boost/mpl/placeholders.hpp>
 #include <boost/serialization/is_bitwise_serializable.hpp>
 #include <boost/serialization/array_wrapper.hpp>
 

third_party/boost/boost/archive/basic_binary_oarchive.hpp

@@ -97,11 +97,11 @@ protected:
     #if 0
     void save_override(const boost::archive::version_type & t){
         library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
+        if(boost::serialization::library_version_type(7) < lvt){
             this->detail_common_oarchive::save_override(t);
         }
         else
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lvt){
             const boost::uint_least16_t x = t;
             * this->This() << x;
         }
@@ -112,11 +112,11 @@ protected:
     }
     void save_override(const boost::serialization::item_version_type & t){
         library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
+        if(boost::serialization::library_version_type(7) < lvt){
             this->detail_common_oarchive::save_override(t);
         }
         else
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lvt){
             const boost::uint_least16_t x = t;
             * this->This() << x;
         }
@@ -128,11 +128,11 @@ protected:
 
     void save_override(class_id_type & t){
         library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
+        if(boost::serialization::library_version_type(7) < lvt){
             this->detail_common_oarchive::save_override(t);
         }
         else
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lvt){
             const boost::int_least16_t x = t;
             * this->This() << x;
         }
@@ -155,7 +155,7 @@ protected:
 
     #if 0
     void save_override(const serialization::collection_size_type & t){
-        if (get_library_version() < boost::archive::library_version_type(6)){
+        if (get_library_version() < boost::serialization::library_version_type(6)){
             unsigned int x=0;
             * this->This() >> x;
             t = serialization::collection_size_type(x);

third_party/boost/boost/archive/basic_binary_oprimitive.hpp

@@ -43,7 +43,6 @@ namespace std{
 #include <boost/scoped_ptr.hpp>
 #include <boost/serialization/throw_exception.hpp>
 
-//#include <boost/mpl/placeholders.hpp>
 #include <boost/serialization/is_bitwise_serializable.hpp>
 #include <boost/serialization/array_wrapper.hpp>
 

third_party/boost/boost/archive/basic_text_iarchive.hpp

@@ -54,7 +54,7 @@ public:
 #else
 protected:
     #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
+        // for some inexplicable reason insertion of "class" generates compile error
         // on msvc 7.1
         friend detail::interface_iarchive<Archive>;
     #else
@@ -76,12 +76,12 @@ protected:
     load_override(class_name_type & t);
 
     BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init(void);
+    init();
 
     basic_text_iarchive(unsigned int flags) :
         detail::common_iarchive<Archive>(flags)
     {}
-    ~basic_text_iarchive(){}
+    ~basic_text_iarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive

third_party/boost/boost/archive/basic_text_oarchive.hpp

@@ -104,7 +104,7 @@ protected:
         detail::common_oarchive<Archive>(flags),
         delimiter(none)
     {}
-    ~basic_text_oarchive(){}
+    ~basic_text_oarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive

third_party/boost/boost/archive/basic_text_oprimitive.hpp

@@ -154,10 +154,11 @@ protected:
     template<class T>
     void save_impl(const T &t, boost::mpl::bool_<true> &){
         // must be a user mistake - can't serialize un-initialized data
-        if(os.fail())
+        if(os.fail()){
             boost::serialization::throw_exception(
                 archive_exception(archive_exception::output_stream_error)
             );
+        }
         // The formulae for the number of decimla digits required is given in
         // http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf
         // which is derived from Kahan's paper:

third_party/boost/boost/archive/basic_xml_iarchive.hpp

@@ -104,7 +104,7 @@ protected:
     BOOST_ARCHIVE_OR_WARCHIVE_DECL
     basic_xml_iarchive(unsigned int flags);
     BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    ~basic_xml_iarchive();
+    ~basic_xml_iarchive() BOOST_OVERRIDE;
 };
 
 } // namespace archive

third_party/boost/boost/archive/basic_xml_oarchive.hpp

@@ -123,7 +123,7 @@ protected:
     BOOST_ARCHIVE_OR_WARCHIVE_DECL
     basic_xml_oarchive(unsigned int flags);
     BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    ~basic_xml_oarchive();
+    ~basic_xml_oarchive() BOOST_OVERRIDE;
 };
 
 } // namespace archive

third_party/boost/boost/archive/binary_iarchive.hpp

@@ -42,12 +42,16 @@ public:
         binary_iarchive_impl<
             binary_iarchive, std::istream::char_type, std::istream::traits_type
         >(is, flags)
-    {}
+    {
+        init(flags);
+    }
     binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
         binary_iarchive_impl<
             binary_iarchive, std::istream::char_type, std::istream::traits_type
         >(bsb, flags)
-    {}
+    {
+        init(flags);
+    }
 };
 
 } // namespace archive

third_party/boost/boost/archive/binary_iarchive_impl.hpp

@@ -78,9 +78,7 @@ protected:
             0 != (flags & no_codecvt)
         ),
         basic_binary_iarchive<Archive>(flags)
-    {
+    {}
-        init(flags);
-    }
     binary_iarchive_impl(
         std::basic_istream<Elem, Tr> & is,
         unsigned int flags
@@ -90,9 +88,7 @@ protected:
             0 != (flags & no_codecvt)
         ),
         basic_binary_iarchive<Archive>(flags)
-    {
+    {}
-        init(flags);
-    }
 };
 
 } // namespace archive

third_party/boost/boost/archive/binary_oarchive.hpp

@@ -42,12 +42,16 @@ public:
         binary_oarchive_impl<
             binary_oarchive, std::ostream::char_type, std::ostream::traits_type
         >(os, flags)
-    {}
+    {
+        init(flags);
+    }
     binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :
         binary_oarchive_impl<
             binary_oarchive, std::ostream::char_type, std::ostream::traits_type
         >(bsb, flags)
-    {}
+    {
+        init(flags);
+    }
 };
 
 } // namespace archive

third_party/boost/boost/archive/binary_oarchive_impl.hpp

@@ -79,9 +79,7 @@ protected:
             0 != (flags & no_codecvt)
         ),
         basic_binary_oarchive<Archive>(flags)
-    {
+    {}
-        init(flags);
-    }
     binary_oarchive_impl(
         std::basic_ostream<Elem, Tr> & os,
         unsigned int flags
@@ -91,9 +89,7 @@ protected:
             0 != (flags & no_codecvt)
         ),
         basic_binary_oarchive<Archive>(flags)
-    {
+    {}
-        init(flags);
-    }
 };
 
 } // namespace archive

third_party/boost/boost/archive/codecvt_null.hpp

@@ -24,7 +24,7 @@
 #include <boost/config.hpp>
 #include <boost/serialization/force_include.hpp>
 #include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+//#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 #if defined(BOOST_NO_STDC_NAMESPACE)
 namespace std {
@@ -52,21 +52,21 @@ class codecvt_null;
 template<>
 class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
 {
-    virtual bool do_always_noconv() const throw() {
+    bool do_always_noconv() const throw() BOOST_OVERRIDE {
         return true;
     }
 public:
     explicit codecvt_null(std::size_t no_locale_manage = 0) :
         std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
     {}
-    virtual ~codecvt_null(){};
+    ~codecvt_null() BOOST_OVERRIDE {}
 };
 
 template<>
-class BOOST_WARCHIVE_DECL codecvt_null<wchar_t> :
+class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> :
     public std::codecvt<wchar_t, char, std::mbstate_t>
 {
-    virtual std::codecvt_base::result
+    BOOST_SYMBOL_EXPORT std::codecvt_base::result
     do_out(
         std::mbstate_t & state,
         const wchar_t * first1,
@@ -75,8 +75,9 @@ class BOOST_WARCHIVE_DECL codecvt_null<wchar_t> :
         char * first2,
         char * last2,
         char * & next2
-    ) const;
+    ) const BOOST_OVERRIDE;
-    virtual std::codecvt_base::result
+
+    BOOST_SYMBOL_EXPORT std::codecvt_base::result
     do_in(
         std::mbstate_t & state,
         const char * first1,
@@ -85,18 +86,23 @@ class BOOST_WARCHIVE_DECL codecvt_null<wchar_t> :
         wchar_t * first2,
         wchar_t * last2,
         wchar_t * & next2
-    ) const;
+    ) const BOOST_OVERRIDE;
-    virtual int do_encoding( ) const throw( ){
+
+    BOOST_SYMBOL_EXPORT int do_encoding( ) const throw( ) BOOST_OVERRIDE {
         return sizeof(wchar_t) / sizeof(char);
     }
-    virtual int do_max_length( ) const throw( ){
+
+    BOOST_SYMBOL_EXPORT bool do_always_noconv() const throw() BOOST_OVERRIDE {
+        return false;
+    }
+
+    BOOST_SYMBOL_EXPORT int do_max_length( ) const throw( ) BOOST_OVERRIDE {
         return do_encoding();
     }
 public:
-    explicit codecvt_null(std::size_t no_locale_manage = 0) :
+    BOOST_SYMBOL_EXPORT explicit codecvt_null(std::size_t no_locale_manage = 0);
-        std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
+
-    {}
+    BOOST_SYMBOL_EXPORT ~codecvt_null() BOOST_OVERRIDE ;
-    //virtual ~codecvt_null(){};
 };
 
 } // namespace archive
@@ -105,6 +111,6 @@ public:
 #ifdef BOOST_MSVC
 #  pragma warning(pop)
 #endif
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
+//#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
 
 #endif //BOOST_ARCHIVE_CODECVT_NULL_HPP

third_party/boost/boost/archive/detail/basic_iarchive.hpp

@@ -85,8 +85,8 @@ public:
     );
     // real public API starts here
     BOOST_ARCHIVE_DECL void
-    set_library_version(library_version_type archive_library_version);
+    set_library_version(boost::serialization::library_version_type archive_library_version);
-    BOOST_ARCHIVE_DECL library_version_type 
+    BOOST_ARCHIVE_DECL boost::serialization::library_version_type
     get_library_version() const;
     BOOST_ARCHIVE_DECL unsigned int
     get_flags() const;

third_party/boost/boost/archive/detail/basic_oarchive.hpp

@@ -77,11 +77,11 @@ public:
         const basic_pointer_oserializer * bpos_ptr
     );
     void save_null_pointer(){
-        vsave(NULL_POINTER_TAG);
+        vsave(BOOST_SERIALIZATION_NULL_POINTER_TAG);
     }
     // real public interface starts here
     BOOST_ARCHIVE_DECL void end_preamble(); // default implementation does nothing
-    BOOST_ARCHIVE_DECL library_version_type get_library_version() const;
+    BOOST_ARCHIVE_DECL boost::serialization::library_version_type get_library_version() const;
     BOOST_ARCHIVE_DECL unsigned int get_flags() const;
 };
 

third_party/boost/boost/archive/detail/check.hpp

@@ -4,12 +4,14 @@
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER)
 # pragma once
-#pragma inline_depth(511)
+#if !defined(__clang__)
+#pragma inline_depth(255)
 #pragma inline_recursion(on)
 #endif
+#endif
 
 #if defined(__MWERKS__)
-#pragma inline_depth(511)
+#pragma inline_depth(255)
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8

third_party/boost/boost/archive/detail/common_iarchive.hpp

@@ -42,22 +42,22 @@ class BOOST_SYMBOL_VISIBLE common_iarchive :
     friend class interface_iarchive<Archive>;
     friend class basic_iarchive;
 private:
-    virtual void vload(version_type & t){
+    void vload(version_type & t) BOOST_OVERRIDE {
         * this->This() >> t;
     }
-    virtual void vload(object_id_type & t){
+    void vload(object_id_type & t) BOOST_OVERRIDE {
         * this->This() >> t;
     }
-    virtual void vload(class_id_type & t){
+    void vload(class_id_type & t) BOOST_OVERRIDE {
         * this->This() >> t;
     }
-    virtual void vload(class_id_optional_type & t){
+    void vload(class_id_optional_type & t) BOOST_OVERRIDE {
         * this->This() >> t;
     }
-    virtual void vload(tracking_type & t){
+    void vload(tracking_type & t) BOOST_OVERRIDE {
         * this->This() >> t;
     }
-    virtual void vload(class_name_type &s){
+    void vload(class_name_type &s) BOOST_OVERRIDE {
         * this->This() >> s;
     }
 protected:
@@ -86,4 +86,3 @@ protected:
 #endif
 
 #endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
-

third_party/boost/boost/archive/detail/common_oarchive.hpp

@@ -40,28 +40,28 @@ class BOOST_SYMBOL_VISIBLE common_oarchive :
     friend class interface_oarchive<Archive>;
     friend class basic_oarchive;
 private:
-    virtual void vsave(const version_type t){
+    void vsave(const version_type t) BOOST_OVERRIDE {
         * this->This() << t;
     }
-    virtual void vsave(const object_id_type t){
+    void vsave(const object_id_type t) BOOST_OVERRIDE {
         * this->This() << t;
     }
-    virtual void vsave(const object_reference_type t){
+    void vsave(const object_reference_type t) BOOST_OVERRIDE {
         * this->This() << t;
     }
-    virtual void vsave(const class_id_type t){
+    void vsave(const class_id_type t) BOOST_OVERRIDE {
         * this->This() << t;
     }
-    virtual void vsave(const class_id_reference_type t){
+    void vsave(const class_id_reference_type t) BOOST_OVERRIDE {
         * this->This() << t;
     }
-    virtual void vsave(const class_id_optional_type t){
+    void vsave(const class_id_optional_type t) BOOST_OVERRIDE {
         * this->This() << t;
     }
-    virtual void vsave(const class_name_type & t){
+    void vsave(const class_name_type & t) BOOST_OVERRIDE {
         * this->This() << t;
     }
-    virtual void vsave(const tracking_type t){
+    void vsave(const tracking_type t) BOOST_OVERRIDE {
         * this->This() << t;
     }
 protected:

third_party/boost/boost/archive/detail/interface_iarchive.hpp

@@ -34,7 +34,7 @@ template<class Archive>
 class interface_iarchive
 {
 protected:
-    interface_iarchive(){};
+    interface_iarchive() {}
 public:
     /////////////////////////////////////////////////////////
     // archive public interface

third_party/boost/boost/archive/detail/interface_oarchive.hpp

@@ -35,7 +35,7 @@ template<class Archive>
 class interface_oarchive
 {
 protected:
-    interface_oarchive(){};
+    interface_oarchive() {}
 public:
     /////////////////////////////////////////////////////////
     // archive public interface

third_party/boost/boost/archive/detail/iserializer.hpp

@@ -2,14 +2,16 @@
 #define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
+#if defined(BOOST_MSVC)
 # pragma once
-#pragma inline_depth(511)
+#if !defined(__clang__)
+#pragma inline_depth(255)
 #pragma inline_recursion(on)
 #endif
+#endif
 
 #if defined(__MWERKS__)
-#pragma inline_depth(511)
+#pragma inline_depth(255)
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
@@ -60,12 +62,12 @@ namespace std{
 #if !defined(BOOST_MSVC) && \
     (BOOST_WORKAROUND(__IBMCPP__, < 1210) || \
     defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590))
-    #define DONT_USE_HAS_NEW_OPERATOR 1
+    #define BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR 1
 #else
-    #define DONT_USE_HAS_NEW_OPERATOR 0
+    #define BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR 0
 #endif
 
-#if ! DONT_USE_HAS_NEW_OPERATOR
+#if ! BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR
 #include <boost/type_traits/has_new_operator.hpp>
 #endif
 
@@ -120,7 +122,7 @@ template<class Archive, class T>
 class iserializer : public basic_iserializer
 {
 private:
-    virtual void destroy(/*const*/ void *address) const {
+    void destroy(/*const*/ void *address) const BOOST_OVERRIDE {
         boost::serialization::access::destroy(static_cast<T *>(address));
     }
 public:
@@ -132,29 +134,29 @@ public:
             >::get_const_instance()
         )
     {}
-    virtual BOOST_DLLEXPORT void load_object_data(
+    BOOST_DLLEXPORT void load_object_data(
         basic_iarchive & ar,
         void *x,
         const unsigned int file_version
-    ) const BOOST_USED;
+    ) const BOOST_OVERRIDE BOOST_USED;
-    virtual bool class_info() const {
+    bool class_info() const BOOST_OVERRIDE {
         return boost::serialization::implementation_level< T >::value
             >= boost::serialization::object_class_info;
     }
-    virtual bool tracking(const unsigned int /* flags */) const {
+    bool tracking(const unsigned int /* flags */) const BOOST_OVERRIDE {
         return boost::serialization::tracking_level< T >::value
                 == boost::serialization::track_always
             || ( boost::serialization::tracking_level< T >::value
                 == boost::serialization::track_selectively
                 && serialized_as_pointer());
     }
-    virtual version_type version() const {
+    version_type version() const BOOST_OVERRIDE {
         return version_type(::boost::serialization::version< T >::value);
     }
-    virtual bool is_polymorphic() const {
+    bool is_polymorphic() const BOOST_OVERRIDE {
         return boost::is_polymorphic< T >::value;
     }
-    virtual ~iserializer(){};
+    ~iserializer() BOOST_OVERRIDE {}
 };
 
 #ifdef BOOST_MSVC
@@ -208,7 +210,7 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
 template<class T>
 struct heap_allocation {
     // boost::has_new_operator< T > doesn't work on these compilers
-    #if DONT_USE_HAS_NEW_OPERATOR
+    #if BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR
         // This doesn't handle operator new overload for class T
         static T * invoke_new(){
             return static_cast<T *>(operator new(sizeof(T)));
@@ -289,26 +291,26 @@ class pointer_iserializer :
     public basic_pointer_iserializer
 {
 private:
-    virtual void * heap_allocation() const {
+    void * heap_allocation() const BOOST_OVERRIDE {
         detail::heap_allocation<T> h;
         T * t = h.get();
         h.release();
         return t;
     }
-    virtual const basic_iserializer & get_basic_serializer() const {
+    const basic_iserializer & get_basic_serializer() const BOOST_OVERRIDE {
         return boost::serialization::singleton<
             iserializer<Archive, T>
         >::get_const_instance();
     }
-    BOOST_DLLEXPORT virtual void load_object_ptr(
+    BOOST_DLLEXPORT void load_object_ptr(
         basic_iarchive & ar,
         void * x,
         const unsigned int file_version
-    ) const BOOST_USED;
+    ) const BOOST_OVERRIDE BOOST_USED;
 public:
     // this should alway be a singleton so make the constructor protected
     pointer_iserializer();
-    ~pointer_iserializer();
+    ~pointer_iserializer() BOOST_OVERRIDE;
 };
 
 #ifdef BOOST_MSVC
@@ -573,7 +575,7 @@ struct load_array_type {
 
         // convert integers to correct enum to load
         // determine number of elements in the array. Consider the
-        // fact that some machines will align elements on boundries
+        // fact that some machines will align elements on boundaries
         // other than characters.
         std::size_t current_count = sizeof(t) / (
             static_cast<char *>(static_cast<void *>(&t[1]))

third_party/boost/boost/archive/detail/oserializer.hpp

@@ -4,12 +4,14 @@
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER)
 # pragma once
-#pragma inline_depth(511)
+#if !defined(__clang__)
+#pragma inline_depth(255)
 #pragma inline_recursion(on)
 #endif
+#endif
 
 #if defined(__MWERKS__)
-#pragma inline_depth(511)
+#pragma inline_depth(255)
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
@@ -116,26 +118,26 @@ public:
             >::get_const_instance()
         )
     {}
-    virtual BOOST_DLLEXPORT void save_object_data(
+    BOOST_DLLEXPORT void save_object_data(
         basic_oarchive & ar,
         const void *x
-    ) const BOOST_USED;
+    ) const BOOST_OVERRIDE BOOST_USED;
-    virtual bool class_info() const {
+    bool class_info() const BOOST_OVERRIDE {
         return boost::serialization::implementation_level< T >::value
             >= boost::serialization::object_class_info;
     }
-    virtual bool tracking(const unsigned int /* flags */) const {
+    bool tracking(const unsigned int /* flags */) const BOOST_OVERRIDE {
         return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
             || (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
                 && serialized_as_pointer());
     }
-    virtual version_type version() const {
+    version_type version() const BOOST_OVERRIDE {
         return version_type(::boost::serialization::version< T >::value);
     }
-    virtual bool is_polymorphic() const {
+    bool is_polymorphic() const BOOST_OVERRIDE {
         return boost::is_polymorphic< T >::value;
     }
-    virtual ~oserializer(){}
+    ~oserializer() BOOST_OVERRIDE {}
 };
 
 #ifdef BOOST_MSVC
@@ -168,18 +170,18 @@ class pointer_oserializer :
 {
 private:
     const basic_oserializer &
-    get_basic_serializer() const {
+    get_basic_serializer() const BOOST_OVERRIDE {
         return boost::serialization::singleton<
             oserializer<Archive, T>
         >::get_const_instance();
     }
-    virtual BOOST_DLLEXPORT void save_object_ptr(
+    BOOST_DLLEXPORT void save_object_ptr(
         basic_oarchive & ar,
         const void * x
-    ) const BOOST_USED;
+    ) const BOOST_OVERRIDE BOOST_USED;
 public:
     pointer_oserializer();
-    ~pointer_oserializer();
+    ~pointer_oserializer() BOOST_OVERRIDE;
 };
 
 #ifdef BOOST_MSVC

third_party/boost/boost/archive/detail/polymorphic_iarchive_route.hpp

@@ -56,125 +56,125 @@ class polymorphic_iarchive_route :
 {
 private:
     // these are used by the serialization library.
-    virtual void load_object(
+    void load_object(
         void *t,
         const basic_iserializer & bis
-    ){
+    ) BOOST_OVERRIDE {
         ArchiveImplementation::load_object(t, bis);
     }
-    virtual const basic_pointer_iserializer * load_pointer(
+    const basic_pointer_iserializer * load_pointer(
         void * & t,
         const basic_pointer_iserializer * bpis_ptr,
         const basic_pointer_iserializer * (*finder)(
             const boost::serialization::extended_type_info & type
         )
-    ){
+    ) BOOST_OVERRIDE {
         return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);
     }
-    virtual void set_library_version(library_version_type archive_library_version){
+    void set_library_version(boost::serialization::library_version_type archive_library_version) BOOST_OVERRIDE {
         ArchiveImplementation::set_library_version(archive_library_version);
     }
-    virtual library_version_type get_library_version() const{
+    boost::serialization::library_version_type get_library_version() const BOOST_OVERRIDE {
         return ArchiveImplementation::get_library_version();
     }
-    virtual unsigned int get_flags() const {
+    unsigned int get_flags() const BOOST_OVERRIDE {
         return ArchiveImplementation::get_flags();
     }
-    virtual void delete_created_pointers(){
+    void delete_created_pointers() BOOST_OVERRIDE {
         ArchiveImplementation::delete_created_pointers();
     }
-    virtual void reset_object_address(
+    void reset_object_address(
         const void * new_address,
         const void * old_address
-    ){
+    ) BOOST_OVERRIDE {
         ArchiveImplementation::reset_object_address(new_address, old_address);
     }
-    virtual void load_binary(void * t, std::size_t size){
+    void load_binary(void * t, std::size_t size) BOOST_OVERRIDE {
         ArchiveImplementation::load_binary(t, size);
     }
     // primitive types the only ones permitted by polymorphic archives
-    virtual void load(bool & t){
+    void load(bool & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(char & t){
+    void load(char & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(signed char & t){
+    void load(signed char & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(unsigned char & t){
+    void load(unsigned char & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
     #ifndef BOOST_NO_CWCHAR
     #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    virtual void load(wchar_t & t){
+    void load(wchar_t & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
     #endif
     #endif
-    virtual void load(short & t){
+    void load(short & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(unsigned short & t){
+    void load(unsigned short & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(int & t){
+    void load(int & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(unsigned int & t){
+    void load(unsigned int & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(long & t){
+    void load(long & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(unsigned long & t){
+    void load(unsigned long & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
     #if defined(BOOST_HAS_LONG_LONG)
-    virtual void load(boost::long_long_type & t){
+    void load(boost::long_long_type & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(boost::ulong_long_type & t){
+    void load(boost::ulong_long_type & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
     #elif defined(BOOST_HAS_MS_INT64)
-    virtual void load(__int64 & t){
+    void load(__int64 & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(unsigned __int64 & t){
+    void load(unsigned __int64 & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
     #endif
-    virtual void load(float & t){
+    void load(float & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(double & t){
+    void load(double & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
-    virtual void load(std::string & t){
+    void load(std::string & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
     #ifndef BOOST_NO_STD_WSTRING
-    virtual void load(std::wstring & t){
+    void load(std::wstring & t) BOOST_OVERRIDE {
         ArchiveImplementation::load(t);
     }
     #endif
     // used for xml and other tagged formats default does nothing
-    virtual void load_start(const char * name){
+    void load_start(const char * name) BOOST_OVERRIDE {
         ArchiveImplementation::load_start(name);
     }
-    virtual void load_end(const char * name){
+    void load_end(const char * name) BOOST_OVERRIDE {
         ArchiveImplementation::load_end(name);
     }
-    virtual void register_basic_serializer(const basic_iserializer & bis){
+    void register_basic_serializer(const basic_iserializer & bis) BOOST_OVERRIDE {
         ArchiveImplementation::register_basic_serializer(bis);
     }
-    virtual helper_collection &
+    helper_collection &
-    get_helper_collection(){
+    get_helper_collection() BOOST_OVERRIDE {
         return ArchiveImplementation::get_helper_collection();
     }
 public:
-    // this can't be inheriteded because they appear in mulitple
+    // this can't be inherited because they appear in multiple
     // parents
     typedef mpl::bool_<true> is_loading;
     typedef mpl::bool_<false> is_saving;
@@ -202,7 +202,7 @@ public:
     ) :
         ArchiveImplementation(is, flags)
     {}
-    virtual ~polymorphic_iarchive_route(){};
+    ~polymorphic_iarchive_route() BOOST_OVERRIDE {}
 };
 
 } // namespace detail

third_party/boost/boost/archive/detail/polymorphic_oarchive_route.hpp

@@ -56,116 +56,116 @@ class polymorphic_oarchive_route :
 {
 private:
     // these are used by the serialization library.
-    virtual void save_object(
+    void save_object(
         const void *x,
         const detail::basic_oserializer & bos
-    ){
+    ) BOOST_OVERRIDE {
         ArchiveImplementation::save_object(x, bos);
     }
-    virtual void save_pointer(
+    void save_pointer(
         const void * t,
         const detail::basic_pointer_oserializer * bpos_ptr
-    ){
+    ) BOOST_OVERRIDE {
         ArchiveImplementation::save_pointer(t, bpos_ptr);
     }
-    virtual void save_null_pointer(){
+    void save_null_pointer() BOOST_OVERRIDE {
         ArchiveImplementation::save_null_pointer();
     }
     // primitive types the only ones permitted by polymorphic archives
-    virtual void save(const bool t){
+    void save(const bool t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const char t){
+    void save(const char t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const signed char t){
+    void save(const signed char t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const unsigned char t){
+    void save(const unsigned char t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
     #ifndef BOOST_NO_CWCHAR
     #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    virtual void save(const wchar_t t){
+    void save(const wchar_t t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
     #endif
     #endif
-    virtual void save(const short t){
+    void save(const short t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const unsigned short t){
+    void save(const unsigned short t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const int t){
+    void save(const int t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const unsigned int t){
+    void save(const unsigned int t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const long t){
+    void save(const long t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const unsigned long t){
+    void save(const unsigned long t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
     #if defined(BOOST_HAS_LONG_LONG)
-    virtual void save(const boost::long_long_type t){
+    void save(const boost::long_long_type t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const boost::ulong_long_type t){
+    void save(const boost::ulong_long_type t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
     #elif defined(BOOST_HAS_MS_INT64)
-    virtual void save(const boost::int64_t t){
+    void save(const boost::int64_t t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const boost::uint64_t t){
+    void save(const boost::uint64_t t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
     #endif
-    virtual void save(const float t){
+    void save(const float t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const double t){
+    void save(const double t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
-    virtual void save(const std::string & t){
+    void save(const std::string & t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
     #ifndef BOOST_NO_STD_WSTRING
-    virtual void save(const std::wstring & t){
+    void save(const std::wstring & t) BOOST_OVERRIDE {
         ArchiveImplementation::save(t);
     }
     #endif
-    virtual library_version_type get_library_version() const{
+    boost::serialization::library_version_type get_library_version() const BOOST_OVERRIDE {
         return ArchiveImplementation::get_library_version();
     }
-    virtual unsigned int get_flags() const {
+    unsigned int get_flags() const BOOST_OVERRIDE {
         return ArchiveImplementation::get_flags();
     }
-    virtual void save_binary(const void * t, std::size_t size){
+    void save_binary(const void * t, std::size_t size) BOOST_OVERRIDE {
         ArchiveImplementation::save_binary(t, size);
     }
     // used for xml and other tagged formats default does nothing
-    virtual void save_start(const char * name){
+    void save_start(const char * name) BOOST_OVERRIDE {
         ArchiveImplementation::save_start(name);
     }
-    virtual void save_end(const char * name){
+    void save_end(const char * name) BOOST_OVERRIDE {
         ArchiveImplementation::save_end(name);
     }
-    virtual void end_preamble(){
+    void end_preamble() BOOST_OVERRIDE {
         ArchiveImplementation::end_preamble();
     }
-    virtual void register_basic_serializer(const detail::basic_oserializer & bos){
+    void register_basic_serializer(const detail::basic_oserializer & bos) BOOST_OVERRIDE {
         ArchiveImplementation::register_basic_serializer(bos);
     }
-    virtual helper_collection &
+    helper_collection &
-    get_helper_collection(){
+    get_helper_collection() BOOST_OVERRIDE {
         return ArchiveImplementation::get_helper_collection();
     }
 public:
-    // this can't be inheriteded because they appear in mulitple
+    // this can't be inherited because they appear in multiple
     // parents
     typedef mpl::bool_<false> is_loading;
     typedef mpl::bool_<true> is_saving;
@@ -193,7 +193,7 @@ public:
     ) :
         ArchiveImplementation(os, flags)
     {}
-    virtual ~polymorphic_oarchive_route(){};
+    ~polymorphic_oarchive_route() BOOST_OVERRIDE {}
 };
 
 } // namespace detail

third_party/boost/boost/archive/detail/utf8_codecvt_facet.hpp

@@ -17,7 +17,6 @@
 #include <boost/archive/detail/decl.hpp>
 #define BOOST_UTF8_BEGIN_NAMESPACE \
      namespace boost { namespace archive { namespace detail {
-#define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
 #define BOOST_UTF8_END_NAMESPACE }}}
 
 #include <boost/detail/utf8_codecvt_facet.hpp>

third_party/boost/boost/archive/dinkumware.hpp

@@ -127,8 +127,6 @@ operator>>(basic_istream<CharType> &is, boost::uint64_t & t){
     return is;
 }
 
-//#endif
-
 template<>
 class back_insert_iterator<basic_string<char> > : public
     iterator<output_iterator_tag, char>

third_party/boost/boost/archive/impl/basic_binary_iarchive.ipp

@@ -22,7 +22,7 @@ namespace std{
 #endif
 
 #include <boost/detail/workaround.hpp>
-#include <boost/detail/endian.hpp>
+#include <boost/predef/other/endian.h>
 
 #include <boost/archive/basic_binary_iarchive.hpp>
 
@@ -48,7 +48,7 @@ basic_binary_iarchive<Archive>::load_override(class_name_type & t){
 
 template<class Archive>
 BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iarchive<Archive>::init(void){
+basic_binary_iarchive<Archive>::init() {
     // read signature in an archive version independent manner
     std::string file_signature;
     
@@ -84,12 +84,12 @@ basic_binary_iarchive<Archive>::init(void){
 
     // make sure the version of the reading archive library can
     // support the format of the archive being read
-    library_version_type input_library_version;
+    boost::serialization::library_version_type input_library_version;
     //* this->This() >> input_library_version;
     {
         int v = 0;
         v = this->This()->m_sb.sbumpc();
-        #if defined(BOOST_LITTLE_ENDIAN)
+        #if BOOST_ENDIAN_LITTLE_BYTE
         if(v < 6){
             ;
         }
@@ -111,11 +111,11 @@ basic_binary_iarchive<Archive>::init(void){
             // version 8+ followed by a zero
             this->This()->m_sb.sbumpc();
         }
-        #elif defined(BOOST_BIG_ENDIAN)
+        #elif BOOST_ENDIAN_BIG_BYTE
         if(v == 0)
             v = this->This()->m_sb.sbumpc();
         #endif
-        input_library_version = static_cast<library_version_type>(v);
+        input_library_version = static_cast<boost::serialization::library_version_type>(v);
     }
     
     #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))

third_party/boost/boost/archive/impl/basic_binary_oarchive.ipp

@@ -34,7 +34,7 @@ basic_binary_oarchive<Archive>::init(){
     const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
     * this->This() << file_signature;
     // write library version
-    const library_version_type v(BOOST_ARCHIVE_VERSION());
+    const boost::serialization::library_version_type v(BOOST_ARCHIVE_VERSION());
     * this->This() << v;
 }
 

third_party/boost/boost/archive/impl/basic_text_iarchive.ipp

@@ -45,7 +45,7 @@ basic_text_iarchive<Archive>::load_override(class_name_type & t){
 
 template<class Archive>
 BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_iarchive<Archive>::init(void){
+basic_text_iarchive<Archive>::init() {
     // read signature in an archive version independent manner
     std::string file_signature;
     * this->This() >> file_signature;
@@ -56,7 +56,7 @@ basic_text_iarchive<Archive>::init(void){
 
     // make sure the version of the reading archive library can
     // support the format of the archive being read
-    library_version_type input_library_version;
+    boost::serialization::library_version_type input_library_version;
     * this->This() >> input_library_version;
 
     #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))

third_party/boost/boost/archive/impl/basic_text_iprimitive.ipp

@@ -112,8 +112,8 @@ basic_text_iprimitive<IStream>::basic_text_iprimitive(
 ) :
     is(is_),
     flags_saver(is_),
-    precision_saver(is_),
 #ifndef BOOST_NO_STD_LOCALE
+    precision_saver(is_),
     codecvt_null_facet(1),
     archive_locale(is.getloc(), & codecvt_null_facet),
     locale_saver(is)
@@ -125,6 +125,7 @@ basic_text_iprimitive<IStream>::basic_text_iprimitive(
     is_ >> std::noboolalpha;
 }
 #else
+    precision_saver(is_)
 {}
 #endif
 

third_party/boost/boost/archive/impl/basic_text_oarchive.ipp

@@ -54,7 +54,7 @@ basic_text_oarchive<Archive>::init(){
     const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
     * this->This() << file_signature;
     // write library version
-    const library_version_type v(BOOST_ARCHIVE_VERSION());
+    const boost::serialization::library_version_type v(BOOST_ARCHIVE_VERSION());
     * this->This() << v;
 }
 

third_party/boost/boost/archive/impl/basic_text_oprimitive.ipp

@@ -10,7 +10,6 @@
 
 #include <cstddef> // NULL
 #include <algorithm> // std::copy
-#include <exception> // std::uncaught_exception
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
 namespace std{ 
@@ -18,6 +17,8 @@ namespace std{
 } // namespace std
 #endif
 
+#include <boost/core/uncaught_exceptions.hpp>
+
 #include <boost/archive/basic_text_oprimitive.hpp>
 
 #include <boost/archive/iterators/base64_from_binary.hpp>
@@ -86,8 +87,8 @@ basic_text_oprimitive<OStream>::basic_text_oprimitive(
 ) : 
     os(os_),
     flags_saver(os_),
-    precision_saver(os_),
 #ifndef BOOST_NO_STD_LOCALE
+    precision_saver(os_),
     codecvt_null_facet(1),
     archive_locale(os.getloc(), & codecvt_null_facet),
     locale_saver(os)
@@ -99,6 +100,7 @@ basic_text_oprimitive<OStream>::basic_text_oprimitive(
     os_ << std::noboolalpha;
 }
 #else
+    precision_saver(os_)
 {}
 #endif
 
@@ -106,7 +108,7 @@ basic_text_oprimitive<OStream>::basic_text_oprimitive(
 template<class OStream>
 BOOST_ARCHIVE_OR_WARCHIVE_DECL
 basic_text_oprimitive<OStream>::~basic_text_oprimitive(){
-    if(std::uncaught_exception())
+    if(boost::core::uncaught_exceptions() > 0)
         return;
     os << std::endl;
 }

third_party/boost/boost/archive/impl/basic_xml_iarchive.ipp

@@ -37,7 +37,6 @@ basic_xml_iarchive<Archive>::load_start(const char *name){
     }
     // don't check start tag at highest level
     ++depth;
-    return;
 }
 
 template<class Archive>

third_party/boost/boost/archive/impl/text_iarchive_impl.ipp

@@ -115,14 +115,7 @@ text_iarchive_impl<Archive>::text_iarchive_impl(
         0 != (flags & no_codecvt)
     ),
     basic_text_iarchive<Archive>(flags)
-{
+{}
-    if(0 == (flags & no_header))
-        #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-        this->init();
-        #else
-        this->basic_text_iarchive<Archive>::init();
-        #endif
-}
 
 } // namespace archive
 } // namespace boost

third_party/boost/boost/archive/impl/text_oarchive_impl.ipp

@@ -93,12 +93,6 @@ text_oarchive_impl<Archive>::text_oarchive_impl(
     ),
     basic_text_oarchive<Archive>(flags)
 {
-    if(0 == (flags & no_header))
-        #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-        this->init();
-        #else
-        this->basic_text_oarchive<Archive>::init();
-        #endif
 }
 
 template<class Archive>

third_party/boost/boost/archive/impl/text_wiarchive_impl.ipp

@@ -108,8 +108,6 @@ text_wiarchive_impl<Archive>::text_wiarchive_impl(
     ),
     basic_text_iarchive<Archive>(flags)
 {
-    if(0 == (flags & no_header))
-        basic_text_iarchive<Archive>::init();
 }
 
 } // archive

third_party/boost/boost/archive/impl/xml_iarchive_impl.ipp

@@ -11,7 +11,6 @@
 #include <boost/config.hpp>
 #include <cstring> // memcpy
 #include <cstddef> // NULL
-#include <exception>
 
 #if defined(BOOST_NO_STDC_NAMESPACE)
 namespace std{ 
@@ -34,6 +33,7 @@ namespace std{
 #include <boost/archive/dinkumware.hpp>
 #endif
 
+#include <boost/core/uncaught_exceptions.hpp>
 #include <boost/core/no_exceptions_support.hpp>
 
 #include <boost/archive/xml_archive_exception.hpp>
@@ -165,7 +165,7 @@ BOOST_ARCHIVE_DECL void
 xml_iarchive_impl<Archive>::init(){
     gimpl->init(is);
     this->set_library_version(
-        library_version_type(gimpl->rv.version)
+        boost::serialization::library_version_type(gimpl->rv.version)
     );
 }
 
@@ -181,15 +181,12 @@ xml_iarchive_impl<Archive>::xml_iarchive_impl(
     ),
     basic_xml_iarchive<Archive>(flags),
     gimpl(new xml_grammar())
-{
+{}
-    if(0 == (flags & no_header))
-        init();
-}
 
 template<class Archive>
 BOOST_ARCHIVE_DECL
 xml_iarchive_impl<Archive>::~xml_iarchive_impl(){
-    if(std::uncaught_exception())
+    if(boost::core::uncaught_exceptions() > 0)
         return;
     if(0 == (this->get_flags() & no_header)){
         gimpl->windup(is);

third_party/boost/boost/archive/impl/xml_oarchive_impl.ipp

@@ -10,7 +10,6 @@
 #include <iomanip>
 #include <algorithm> // std::copy
 #include <string>
-#include <exception>
 
 #include <cstring> // strlen
 #include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
@@ -20,6 +19,7 @@ namespace std{
 } // namespace std
 #endif
 
+#include <boost/core/uncaught_exceptions.hpp>
 #include <boost/archive/iterators/xml_escape.hpp>
 #include <boost/archive/iterators/ostream_iterator.hpp>
 
@@ -109,10 +109,7 @@ xml_oarchive_impl<Archive>::xml_oarchive_impl(
         0 != (flags & no_codecvt)
     ),
     basic_xml_oarchive<Archive>(flags)
-{
+{}
-    if(0 == (flags & no_header))
-        this->init();
-}
 
 template<class Archive>
 BOOST_ARCHIVE_DECL void
@@ -132,7 +129,7 @@ xml_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
 template<class Archive>
 BOOST_ARCHIVE_DECL
 xml_oarchive_impl<Archive>::~xml_oarchive_impl(){
-    if(std::uncaught_exception())
+    if(boost::core::uncaught_exceptions() > 0)
         return;
     if(0 == (this->get_flags() & no_header))
         this->windup();

third_party/boost/boost/archive/impl/xml_wiarchive_impl.ipp

@@ -20,13 +20,13 @@ namespace std{
 
 #include <boost/assert.hpp>
 #include <algorithm> // std::copy
-#include <exception> // uncaught exception
 #include <boost/detail/workaround.hpp> // Dinkumware and RogueWave
 #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
 #include <boost/archive/dinkumware.hpp>
 #endif
 
 #include <boost/io/ios_state.hpp>
+#include <boost/core/uncaught_exceptions.hpp>
 #include <boost/core/no_exceptions_support.hpp>
 #include <boost/serialization/string.hpp>
 
@@ -143,7 +143,7 @@ BOOST_WARCHIVE_DECL void
 xml_wiarchive_impl<Archive>::init(){
     gimpl->init(is);
     this->set_library_version(
-        library_version_type(gimpl->rv.version)
+        boost::serialization::library_version_type(gimpl->rv.version)
     );
 }
 
@@ -169,14 +169,12 @@ xml_wiarchive_impl<Archive>::xml_wiarchive_impl(
         is_.sync();
         is_.imbue(archive_locale);
     }
-    if(0 == (flags & no_header))
-        init();
 }
 
 template<class Archive>
 BOOST_WARCHIVE_DECL
 xml_wiarchive_impl<Archive>::~xml_wiarchive_impl(){
-    if(std::uncaught_exception())
+    if(boost::core::uncaught_exceptions() > 0)
         return;
     if(0 == (this->get_flags() & no_header)){
         gimpl->windup(is);

third_party/boost/boost/archive/impl/xml_woarchive_impl.ipp

@@ -13,7 +13,6 @@
 #include <string>
 #include <algorithm> // std::copy
 #include <locale>
-#include <exception>
 
 #include <cstring> // strlen
 #include <cstdlib> // mbtowc
@@ -32,6 +31,8 @@ namespace std{
 } // namespace std
 #endif
 
+#include <boost/core/uncaught_exceptions.hpp>
+
 #include <boost/archive/xml_woarchive.hpp>
 #include <boost/archive/detail/utf8_codecvt_facet.hpp>
 
@@ -132,14 +133,12 @@ xml_woarchive_impl<Archive>::xml_woarchive_impl(
         os_.flush();
         os_.imbue(archive_locale);
     }
-    if(0 == (flags & no_header))
-        this->init();
 }
 
 template<class Archive>
 BOOST_WARCHIVE_DECL
 xml_woarchive_impl<Archive>::~xml_woarchive_impl(){
-    if(std::uncaught_exception())
+    if(boost::core::uncaught_exceptions() > 0)
         return;
     if(0 == (this->get_flags() & no_header)){
         os << L"</boost_serialization>";

third_party/boost/boost/archive/iterators/dataflow_exception.hpp

@@ -46,7 +46,7 @@ public:
     dataflow_exception(exception_code c = other_exception) : code(c)
     {}
 
-    virtual const char *what( ) const throw( )
+    const char *what( ) const throw( ) BOOST_OVERRIDE
     {
         const char *msg = "unknown exception code";
         switch(code){

third_party/boost/boost/archive/iterators/unescape.hpp

@@ -71,7 +71,7 @@ private:
         ++(this->base_reference());
         dereference_impl();
         m_full = false;
-    };
+    }
 
 public:
 

third_party/boost/boost/archive/iterators/wchar_from_mb.hpp

@@ -16,7 +16,6 @@
 
 //  See http://www.boost.org for updates, documentation, and revision history.
 
-#include <boost/assert.hpp>
 #include <cctype>
 #include <cstddef> // size_t
 #ifndef BOOST_NO_CWCHAR
@@ -30,6 +29,8 @@ namespace std{
     using ::mbstate_t;
 } // namespace std
 #endif
+#include <boost/assert.hpp>
+#include <boost/core/ignore_unused.hpp>
 #include <boost/array.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/archive/detail/utf8_codecvt_facet.hpp>
@@ -165,6 +166,7 @@ void wchar_from_mb<Base>::drain(){
     const typename boost::iterators::iterator_value<Base>::type * input_new_start;
     typename iterator_value<this_t>::type * next_available;
 
+    BOOST_ATTRIBUTE_UNUSED // redundant with ignore_unused below but clarifies intention
     std::codecvt_base::result r = m_codecvt_facet.in(
         m_mbs,
         m_input.m_buffer.begin(),

third_party/boost/boost/archive/polymorphic_binary_iarchive.hpp

@@ -35,7 +35,7 @@ public:
     polymorphic_binary_iarchive(std::istream & is, unsigned int flags = 0) :
         detail::polymorphic_iarchive_route<binary_iarchive>(is, flags)
     {}
-    ~polymorphic_binary_iarchive(){}
+    ~polymorphic_binary_iarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive
@@ -51,4 +51,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
 )
 
 #endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
-

third_party/boost/boost/archive/polymorphic_binary_oarchive.hpp

@@ -30,7 +30,7 @@ public:
     polymorphic_binary_oarchive(std::ostream & os, unsigned int flags = 0) :
         detail::polymorphic_oarchive_route<binary_oarchive>(os, flags)
     {}
-    ~polymorphic_binary_oarchive(){}
+    ~polymorphic_binary_oarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive
@@ -42,4 +42,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
 )
 
 #endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
-

third_party/boost/boost/archive/polymorphic_iarchive.hpp

@@ -31,6 +31,7 @@ namespace std{
 
 #include <boost/archive/detail/iserializer.hpp>
 #include <boost/archive/detail/interface_iarchive.hpp>
+#include <boost/serialization/library_version_type.hpp>
 #include <boost/serialization/nvp.hpp>
 #include <boost/archive/detail/register_archive.hpp>
 
@@ -116,11 +117,13 @@ public:
         load_end(t.name());
     }
 protected:
-    virtual ~polymorphic_iarchive_impl(){};
+    virtual ~polymorphic_iarchive_impl() {}
 public:
     // utility function implemented by all legal archives
-    virtual void set_library_version(library_version_type archive_library_version) = 0;
+    virtual void set_library_version(
-    virtual library_version_type get_library_version() const = 0;
+        boost::serialization::library_version_type archive_library_version
+    ) = 0;
+    virtual boost::serialization::library_version_type get_library_version() const = 0;
     virtual unsigned int get_flags() const = 0;
     virtual void delete_created_pointers() = 0;
     virtual void reset_object_address(
@@ -156,7 +159,7 @@ class BOOST_SYMBOL_VISIBLE polymorphic_iarchive :
     public polymorphic_iarchive_impl
 {
 public:
-    virtual ~polymorphic_iarchive(){};
+    ~polymorphic_iarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive

third_party/boost/boost/archive/polymorphic_oarchive.hpp

@@ -118,11 +118,11 @@ public:
         save_end(t.name());
     }
 protected:
-    virtual ~polymorphic_oarchive_impl(){};
+    virtual ~polymorphic_oarchive_impl() {}
 public:
     // utility functions implemented by all legal archives
     virtual unsigned int get_flags() const = 0;
-    virtual library_version_type get_library_version() const = 0;
+    virtual boost::serialization::library_version_type get_library_version() const = 0;
     virtual void save_binary(const void * t, std::size_t size) = 0;
 
     virtual void save_object(
@@ -140,7 +140,7 @@ class BOOST_SYMBOL_VISIBLE polymorphic_oarchive :
     public polymorphic_oarchive_impl
 {
 public:
-    virtual ~polymorphic_oarchive(){};
+    ~polymorphic_oarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive

third_party/boost/boost/archive/polymorphic_text_iarchive.hpp

@@ -35,7 +35,7 @@ public:
     polymorphic_text_iarchive(std::istream & is, unsigned int flags = 0) :
         detail::polymorphic_iarchive_route<text_iarchive>(is, flags)
     {}
-    ~polymorphic_text_iarchive(){}
+    ~polymorphic_text_iarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive
@@ -51,4 +51,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
 )
 
 #endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
-

third_party/boost/boost/archive/polymorphic_text_oarchive.hpp

@@ -30,7 +30,7 @@ public:
     polymorphic_text_oarchive(std::ostream & os, unsigned int flags = 0) :
         detail::polymorphic_oarchive_route<text_oarchive>(os, flags)
     {}
-    ~polymorphic_text_oarchive(){}
+    ~polymorphic_text_oarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive
@@ -42,4 +42,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
 )
 
 #endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
-

third_party/boost/boost/archive/polymorphic_text_wiarchive.hpp

@@ -39,7 +39,7 @@ public:
     polymorphic_text_wiarchive(std::wistream & is, unsigned int flags = 0) :
         detail::polymorphic_iarchive_route<text_wiarchive>(is, flags)
     {}
-    ~polymorphic_text_wiarchive(){}
+    ~polymorphic_text_wiarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive
@@ -56,4 +56,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
 
 #endif // BOOST_NO_STD_WSTREAMBUF
 #endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
-

third_party/boost/boost/archive/polymorphic_text_woarchive.hpp

@@ -34,7 +34,7 @@ public:
     polymorphic_text_woarchive(std::wostream & os, unsigned int flags = 0) :
         detail::polymorphic_oarchive_route<text_woarchive>(os, flags)
     {}
-    ~polymorphic_text_woarchive(){}
+    ~polymorphic_text_woarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive
@@ -47,4 +47,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
 
 #endif // BOOST_NO_STD_WSTREAMBUF
 #endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
-

third_party/boost/boost/archive/polymorphic_xml_iarchive.hpp

@@ -35,7 +35,7 @@ public:
     polymorphic_xml_iarchive(std::istream & is, unsigned int flags = 0) :
         detail::polymorphic_iarchive_route<xml_iarchive>(is, flags)
     {}
-    ~polymorphic_xml_iarchive(){}
+    ~polymorphic_xml_iarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive
@@ -51,4 +51,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
 )
 
 #endif // BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
-

third_party/boost/boost/archive/polymorphic_xml_oarchive.hpp

@@ -30,7 +30,7 @@ public:
     polymorphic_xml_oarchive(std::ostream & os, unsigned int flags = 0) :
         detail::polymorphic_oarchive_route<xml_oarchive>(os, flags)
     {}
-    ~polymorphic_xml_oarchive(){}
+    ~polymorphic_xml_oarchive() BOOST_OVERRIDE {}
 };
 } // namespace archive
 } // namespace boost
@@ -41,4 +41,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
 )
 
 #endif // BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
-

third_party/boost/boost/archive/polymorphic_xml_wiarchive.hpp

@@ -34,7 +34,7 @@ public:
     polymorphic_xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
         detail::polymorphic_iarchive_route<xml_wiarchive>(is, flags)
     {}
-    ~polymorphic_xml_wiarchive(){}
+    ~polymorphic_xml_wiarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive
@@ -47,4 +47,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
 
 #endif // BOOST_NO_STD_WSTREAMBUF
 #endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
-

third_party/boost/boost/archive/polymorphic_xml_woarchive.hpp

@@ -34,7 +34,7 @@ public:
     polymorphic_xml_woarchive(std::wostream & os, unsigned int flags = 0) :
         detail::polymorphic_oarchive_route<xml_woarchive>(os, flags)
     {}
-    ~polymorphic_xml_woarchive(){}
+    ~polymorphic_xml_woarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive
@@ -47,4 +47,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
 
 #endif // BOOST_NO_STD_WSTREAMBUF
 #endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
-

third_party/boost/boost/archive/text_iarchive.hpp

@@ -89,7 +89,7 @@ protected:
     text_iarchive_impl(std::istream & is, unsigned int flags);
     // don't import inline definitions! leave this as a reminder.
     //BOOST_ARCHIVE_DECL
-    ~text_iarchive_impl(){};
+    ~text_iarchive_impl() BOOST_OVERRIDE {}
 };
 
 } // namespace archive
@@ -115,8 +115,11 @@ public:
     text_iarchive(std::istream & is_, unsigned int flags = 0) :
         // note: added _ to suppress useless gcc warning
         text_iarchive_impl<text_iarchive>(is_, flags)
-    {}
+    {
-    ~text_iarchive(){}
+        if(0 == (flags & no_header))
+             init();
+    }
+    ~text_iarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive

third_party/boost/boost/archive/text_oarchive.hpp

@@ -86,14 +86,14 @@ protected:
     text_oarchive_impl(std::ostream & os, unsigned int flags);
     // don't import inline definitions! leave this as a reminder.
     //BOOST_ARCHIVE_DECL
-    ~text_oarchive_impl(){};
+    ~text_oarchive_impl() BOOST_OVERRIDE {}
 public:
     BOOST_ARCHIVE_DECL void
     save_binary(const void *address, std::size_t count);
 };
 
 // do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from text_oarchive_impl instead.  This will
+// via inheritance, derived from text_oarchive_impl instead.  This will
 // preserve correct static polymorphism.
 class BOOST_SYMBOL_VISIBLE text_oarchive :
     public text_oarchive_impl<text_oarchive>
@@ -102,8 +102,11 @@ public:
     text_oarchive(std::ostream & os_, unsigned int flags = 0) :
         // note: added _ to suppress useless gcc warning
         text_oarchive_impl<text_oarchive>(os_, flags)
-    {}
+    {
-    ~text_oarchive(){}
+        if(0 == (flags & no_header))
+            init();
+    }
+    ~text_oarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive

third_party/boost/boost/archive/text_wiarchive.hpp

@@ -94,7 +94,7 @@ protected:
     }
     BOOST_WARCHIVE_DECL
     text_wiarchive_impl(std::wistream & is, unsigned int flags);
-    ~text_wiarchive_impl(){};
+    ~text_wiarchive_impl() BOOST_OVERRIDE {}
 };
 
 } // namespace archive
@@ -119,8 +119,11 @@ class BOOST_SYMBOL_VISIBLE text_wiarchive :
 public:
     text_wiarchive(std::wistream & is, unsigned int flags = 0) :
         text_wiarchive_impl<text_wiarchive>(is, flags)
-    {}
+    {
-    ~text_wiarchive(){}
+        if(0 == (flags & no_header))
+            init();
+    }
+    ~text_wiarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive

third_party/boost/boost/archive/text_woarchive.hpp

@@ -101,10 +101,7 @@ protected:
             0 != (flags & no_codecvt)
         ),
         basic_text_oarchive<Archive>(flags)
-    {
+    {}
-        if(0 == (flags & no_header))
-            basic_text_oarchive<Archive>::init();
-    }
 public:
     void save_binary(const void *address, std::size_t count){
         put(static_cast<wchar_t>('\n'));
@@ -127,7 +124,7 @@ public:
 // typedef text_oarchive_impl<text_oarchive_impl<...> > text_oarchive;
 
 // do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from text_oarchive_impl instead.  This will
+// via inheritance, derived from text_oarchive_impl instead.  This will
 // preserve correct static polymorphism.
 class BOOST_SYMBOL_VISIBLE text_woarchive :
     public text_woarchive_impl<text_woarchive>
@@ -135,8 +132,11 @@ class BOOST_SYMBOL_VISIBLE text_woarchive :
 public:
     text_woarchive(std::wostream & os, unsigned int flags = 0) :
         text_woarchive_impl<text_woarchive>(os, flags)
-    {}
+    {
-    ~text_woarchive(){}
+        if(0 == (flags & no_header))
+            init();
+    }
+    ~text_woarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive

third_party/boost/boost/archive/xml_archive_exception.hpp

@@ -45,8 +45,8 @@ public:
         const char * e1 = NULL,
         const char * e2 = NULL
     );
-    BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &) ;
+    BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &);
-    virtual BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
+    BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
 };
 
 }// namespace archive

third_party/boost/boost/archive/xml_iarchive.hpp

@@ -101,7 +101,7 @@ protected:
     BOOST_ARCHIVE_DECL
     xml_iarchive_impl(std::istream & is, unsigned int flags);
     BOOST_ARCHIVE_DECL
-    ~xml_iarchive_impl();
+    ~xml_iarchive_impl() BOOST_OVERRIDE;
 };
 
 } // namespace archive
@@ -125,8 +125,11 @@ class BOOST_SYMBOL_VISIBLE xml_iarchive :
 public:
     xml_iarchive(std::istream & is, unsigned int flags = 0) :
         xml_iarchive_impl<xml_iarchive>(is, flags)
-    {}
+    {
-    ~xml_iarchive(){};
+        if(0 == (flags & no_header))
+            init();
+    }
+    ~xml_iarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive

third_party/boost/boost/archive/xml_oarchive.hpp

@@ -86,7 +86,7 @@ protected:
     BOOST_ARCHIVE_DECL
     xml_oarchive_impl(std::ostream & os, unsigned int flags);
     BOOST_ARCHIVE_DECL
-    ~xml_oarchive_impl();
+    ~xml_oarchive_impl() BOOST_OVERRIDE;
 public:
     BOOST_ARCHIVE_DECL
     void save_binary(const void *address, std::size_t count);
@@ -112,7 +112,7 @@ namespace archive {
 // typedef xml_oarchive_impl<xml_oarchive_impl<...> > xml_oarchive;
 
 // do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from xml_oarchive_impl instead.  This will
+// via inheritance, derived from xml_oarchive_impl instead.  This will
 // preserve correct static polymorphism.
 class BOOST_SYMBOL_VISIBLE xml_oarchive :
     public xml_oarchive_impl<xml_oarchive>
@@ -120,8 +120,11 @@ class BOOST_SYMBOL_VISIBLE xml_oarchive :
 public:
     xml_oarchive(std::ostream & os, unsigned int flags = 0) :
         xml_oarchive_impl<xml_oarchive>(os, flags)
-    {}
+    {
-    ~xml_oarchive(){}
+        if(0 == (flags & no_header))
+            init();
+    }
+    ~xml_oarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive

third_party/boost/boost/archive/xml_wiarchive.hpp

@@ -29,7 +29,6 @@
 #include <boost/archive/basic_xml_iarchive.hpp>
 #include <boost/archive/detail/register_archive.hpp>
 #include <boost/serialization/item_version_type.hpp>
-// #include <boost/archive/detail/utf8_codecvt_facet.hpp>
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
@@ -105,9 +104,9 @@ protected:
     BOOST_WARCHIVE_DECL void
     init();
     BOOST_WARCHIVE_DECL
-    xml_wiarchive_impl(std::wistream & is, unsigned int flags) ;
+    xml_wiarchive_impl(std::wistream & is, unsigned int flags);
     BOOST_WARCHIVE_DECL
-    ~xml_wiarchive_impl();
+    ~xml_wiarchive_impl() BOOST_OVERRIDE;
 };
 
 } // namespace archive
@@ -132,8 +131,11 @@ class BOOST_SYMBOL_VISIBLE xml_wiarchive :
 public:
     xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
         xml_wiarchive_impl<xml_wiarchive>(is, flags)
-    {}
+    {
-    ~xml_wiarchive(){}
+    if(0 == (flags & no_header))
+        init();
+    }
+    ~xml_wiarchive() BOOST_OVERRIDE {}
 };
 
 } // namespace archive