update boost

linx64/include/boost/align/detail/add_reference.hpp

@@ -0,0 +1,44 @@
+/*
+Copyright 2019 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_ADD_REFERENCE_HPP
+#define BOOST_ALIGN_DETAIL_ADD_REFERENCE_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::add_lvalue_reference;
+#else
+template<class T>
+struct add_lvalue_reference {
+    typedef T& type;
+};
+
+template<>
+struct add_lvalue_reference<void> {
+    typedef void type;
+};
+
+template<>
+struct add_lvalue_reference<const void> {
+    typedef const void type;
+};
+#endif
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

linx64/include/boost/align/detail/addressof.hpp

@@ -1,33 +0,0 @@
-/*
-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_ADDRESSOF_HPP
-#define BOOST_ALIGN_DETAIL_ADDRESSOF_HPP
-
-#include <boost/config.hpp>
-
-#if !defined(BOOST_NO_CXX11_ADDRESSOF)
-#include <memory>
-#else
-#include <boost/core/addressof.hpp>
-#endif
-
-namespace boost {
-namespace alignment {
-namespace detail {
-
-#if !defined(BOOST_NO_CXX11_ADDRESSOF)
-using std::addressof;
-#else
-using boost::addressof;
-#endif
-
-} /* detail */
-} /* alignment */
-} /* boost */
-
-#endif

linx64/include/boost/align/detail/align.hpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2014-2016 Glen Joseph Fernandes
+Copyright 2014-2020 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -18,14 +18,14 @@ inline void*
 align(std::size_t alignment, std::size_t size, void*& ptr,
     std::size_t& space)
 {
-    BOOST_ASSERT(detail::is_alignment(alignment));
+    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 = space - (p - static_cast<char*>(ptr));
-        if (size <= n) {
+        std::size_t n = p - static_cast<char*>(ptr);
+        if (n <= space - size) {
             ptr = p;
-            space = n;
+            space -= n;
             return p;
         }
     }

linx64/include/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

linx64/include/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

linx64/include/boost/align/detail/integral_constant.hpp

@@ -20,6 +20,8 @@ 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 {
@@ -39,6 +41,9 @@ struct integral_constant {
 
 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 */

linx64/include/boost/align/detail/is_aligned.hpp

@@ -15,14 +15,14 @@ namespace boost {
 namespace alignment {
 
 inline bool
-is_aligned(const void* ptr, std::size_t alignment) BOOST_NOEXCEPT
+is_aligned(const volatile void* ptr, std::size_t alignment) BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
     return (reinterpret_cast<std::size_t>(ptr) & (alignment - 1)) == 0;
 }
 
 inline bool
-is_aligned(std::size_t alignment, const void* ptr) BOOST_NOEXCEPT
+is_aligned(std::size_t alignment, const volatile void* ptr) BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
     return (reinterpret_cast<std::size_t>(ptr) & (alignment - 1)) == 0;

linx64/include/boost/align/detail/not_pointer.hpp

@@ -0,0 +1,27 @@
+/*
+Copyright 2019 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_NOT_POINTER_HPP
+#define BOOST_ALIGN_DETAIL_NOT_POINTER_HPP
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+template<class T, class U>
+struct not_pointer {
+    typedef U type;
+};
+
+template<class T, class U>
+struct not_pointer<T*, U> { };
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif

linx64/include/boost/align/detail/throw_exception.hpp

@@ -0,0 +1,44 @@
+/*
+Copyright 2019 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_THROW_EXCEPTION_HPP
+#define BOOST_ALIGN_DETAIL_THROW_EXCEPTION_HPP
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_EXCEPTIONS)
+#include <exception>
+#endif
+
+namespace boost {
+
+#if defined(BOOST_NO_EXCEPTIONS)
+BOOST_NORETURN void throw_exception(const std::exception&);
+#endif
+
+namespace alignment {
+namespace detail {
+
+#if !defined(BOOST_NO_EXCEPTIONS)
+template<class E>
+BOOST_NORETURN inline void
+throw_exception(const E& error)
+{
+    throw error;
+}
+#else
+BOOST_NORETURN inline void
+throw_exception(const std::exception& error)
+{
+    boost::throw_exception(error);
+}
+#endif
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif