update boost to 1.60

3rdparty/boost/boost/align/align.hpp

@@ -1,6 +1,6 @@
 /*
 (c) 2014 Glen Joseph Fernandes
-glenjofe at gmail dot com
+<glenjofe -at- gmail.com>
 
 Distributed under the Boost Software
 License, Version 1.0.

3rdparty/boost/boost/align/detail/address.hpp

@@ -1,6 +1,6 @@
 /*
 (c) 2014 Glen Joseph Fernandes
-glenjofe at gmail dot com
+<glenjofe -at- gmail.com>
 
 Distributed under the Boost Software
 License, Version 1.0.
@@ -17,13 +17,13 @@ namespace alignment {
 namespace detail {
 
 #if defined(BOOST_HAS_INTPTR_T)
-typedef boost::uintptr_t address_t;
+typedef boost::uintptr_t address;
 #else
-typedef std::size_t address_t;
+typedef std::size_t address;
 #endif
 
-} /* :detail */
-} /* :alignment */
-} /* :boost */
+} /* .detail */
+} /* .alignment */
+} /* .boost */
 
 #endif

3rdparty/boost/boost/align/detail/align.hpp

@@ -1,6 +1,6 @@
 /*
 (c) 2014 Glen Joseph Fernandes
-glenjofe at gmail dot com
+<glenjofe -at- gmail.com>
 
 Distributed under the Boost Software
 License, Version 1.0.
@@ -21,7 +21,7 @@ inline void* align(std::size_t alignment, std::size_t size,
     void*& ptr, std::size_t& space)
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
-    std::size_t n = detail::address_t(ptr) & (alignment - 1);
+    std::size_t n = detail::address(ptr) & (alignment - 1);
     if (n != 0) {
         n = alignment - n;
     }
@@ -34,7 +34,7 @@ inline void* align(std::size_t alignment, std::size_t size,
     return p;
 }
 
-} /* :alignment */
-} /* :boost */
+} /* .alignment */
+} /* .boost */
 
 #endif

3rdparty/boost/boost/align/detail/align_cxx11.hpp

@@ -1,6 +1,6 @@
 /*
 (c) 2014 Glen Joseph Fernandes
-glenjofe at gmail dot com
+<glenjofe -at- gmail.com>
 
 Distributed under the Boost Software
 License, Version 1.0.
@@ -16,7 +16,7 @@ namespace alignment {
 
 using std::align;
 
-} /* :alignment */
-} /* :boost */
+} /* .alignment */
+} /* .boost */
 
 #endif

3rdparty/boost/boost/align/detail/is_alignment.hpp

@@ -1,6 +1,6 @@
 /*
 (c) 2014 Glen Joseph Fernandes
-glenjofe at gmail dot com
+<glenjofe -at- gmail.com>
 
 Distributed under the Boost Software
 License, Version 1.0.
@@ -22,8 +22,8 @@ BOOST_CONSTEXPR inline bool is_alignment(std::size_t value)
     return (value > 0) && ((value & (value - 1)) == 0);
 }
 
-} /* :detail */
-} /* :alignment */
-} /* :boost */
+} /* .detail */
+} /* .alignment */
+} /* .boost */
 
 #endif

3rdparty/boost/boost/aligned_storage.hpp

@@ -1,143 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost aligned_storage.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2002-2003
-// Eric Friedman, Itay Maman
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ALIGNED_STORAGE_HPP
-#define BOOST_ALIGNED_STORAGE_HPP
-
-#include <cstddef> // for std::size_t
-
-#include "boost/config.hpp"
-#include "boost/detail/workaround.hpp"
-#include "boost/type_traits/alignment_of.hpp"
-#include "boost/type_traits/type_with_alignment.hpp"
-#include "boost/type_traits/is_pod.hpp"
-
-#include "boost/mpl/eval_if.hpp"
-#include "boost/mpl/identity.hpp"
-
-#include "boost/type_traits/detail/bool_trait_def.hpp"
-
-namespace boost {
-
-namespace detail { namespace aligned_storage {
-
-BOOST_STATIC_CONSTANT(
-      std::size_t
-    , alignment_of_max_align = ::boost::alignment_of<max_align>::value
-    );
-
-//
-// To be TR1 conforming this must be a POD type:
-//
-template <
-      std::size_t size_
-    , std::size_t alignment_
->
-struct aligned_storage_imp
-{
-    union data_t
-    {
-        char buf[size_];
-
-        typename ::boost::mpl::eval_if_c<
-              alignment_ == std::size_t(-1)
-            , ::boost::mpl::identity< ::boost::detail::max_align >
-            , ::boost::type_with_alignment<alignment_>
-            >::type align_;
-    } data_;
-    void* address() const { return const_cast<aligned_storage_imp*>(this); }
-};
-
-template< std::size_t alignment_ >
-struct aligned_storage_imp<0u,alignment_>
-{
-    /* intentionally empty */
-    void* address() const { return 0; }
-};
-
-}} // namespace detail::aligned_storage
-
-template <
-      std::size_t size_
-    , std::size_t alignment_ = std::size_t(-1)
->
-class aligned_storage : 
-#ifndef __BORLANDC__
-   private 
-#else
-   public
-#endif
-   ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> 
-{
- 
-public: // constants
-
-    typedef ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
-
-    BOOST_STATIC_CONSTANT(
-          std::size_t
-        , size = size_
-        );
-    BOOST_STATIC_CONSTANT(
-          std::size_t
-        , alignment = (
-              alignment_ == std::size_t(-1)
-            ? ::boost::detail::aligned_storage::alignment_of_max_align
-            : alignment_
-            )
-        );
-
-private: // noncopyable
-
-    aligned_storage(const aligned_storage&);
-    aligned_storage& operator=(const aligned_storage&);
-
-public: // structors
-
-    aligned_storage()
-    {
-    }
-
-    ~aligned_storage()
-    {
-    }
-
-public: // accessors
-
-    void* address()
-    {
-        return static_cast<type*>(this)->address();
-    }
-
-    const void* address() const
-    {
-        return static_cast<const type*>(this)->address();
-    }
-};
-
-//
-// Make sure that is_pod recognises aligned_storage<>::type
-// as a POD (Note that aligned_storage<> itself is not a POD):
-//
-template <std::size_t size_, std::size_t alignment_>
-struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
-   BOOST_TT_AUX_BOOL_C_BASE(true)
-{ 
-    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(true)
-}; 
-
-
-} // namespace boost
-
-#include "boost/type_traits/detail/bool_trait_undef.hpp"
-
-#endif // BOOST_ALIGNED_STORAGE_HPP

3rdparty/boost/boost/assert.hpp

@@ -3,10 +3,12 @@
 //                     BOOST_ASSERT_MSG(expr, msg)
 //                     BOOST_VERIFY(expr)
 //                     BOOST_VERIFY_MSG(expr, msg)
+//                     BOOST_ASSERT_IS_VOID
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2007, 2014 Peter Dimov
 //  Copyright (c) Beman Dawes 2011
+//  Copyright (c) 2015 Ion Gaztanaga
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -24,16 +26,18 @@
 //
 
 //
-// BOOST_ASSERT, BOOST_ASSERT_MSG
+// BOOST_ASSERT, BOOST_ASSERT_MSG, BOOST_ASSERT_IS_VOID
 //
 
 #undef BOOST_ASSERT
 #undef BOOST_ASSERT_MSG
+#undef BOOST_ASSERT_IS_VOID
 
 #if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) )
 
 # define BOOST_ASSERT(expr) ((void)0)
 # define BOOST_ASSERT_MSG(expr, msg) ((void)0)
+# define BOOST_ASSERT_IS_VOID
 
 #elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) )
 
@@ -55,6 +59,9 @@ namespace boost
 
 # define BOOST_ASSERT(expr) assert(expr)
 # define BOOST_ASSERT_MSG(expr, msg) assert((expr)&&(msg))
+#if defined(NDEBUG)
+# define BOOST_ASSERT_IS_VOID
+#endif
 
 #endif
 

3rdparty/boost/boost/bind.hpp

@@ -10,7 +10,7 @@
 //
 //  bind.hpp - binds function objects to arguments
 //
-//  Copyright (c) 2009 Peter Dimov
+//  Copyright (c) 2009, 2015 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -21,4 +21,21 @@
 
 #include <boost/bind/bind.hpp>
 
+#ifndef BOOST_BIND_NO_PLACEHOLDERS
+
+#if defined(BOOST_CLANG)
+# pragma clang diagnostic push
+# if  __has_warning("-Wheader-hygiene")
+#  pragma clang diagnostic ignored "-Wheader-hygiene"
+# endif
+#endif
+
+using namespace boost::placeholders;
+
+#if defined(BOOST_CLANG)
+# pragma clang diagnostic pop
+#endif
+
+#endif // #ifndef BOOST_BIND_NO_PLACEHOLDERS
+
 #endif // #ifndef BOOST_BIND_HPP_INCLUDED

3rdparty/boost/boost/bind/arg.hpp

@@ -28,17 +28,17 @@ namespace boost
 
 template< int I > struct arg
 {
-    arg()
+    BOOST_CONSTEXPR arg()
     {
     }
 
-    template< class T > arg( T const & /* t */ )
+    template< class T > BOOST_CONSTEXPR arg( T const & /* t */ )
     {
         BOOST_STATIC_ASSERT( I == is_placeholder<T>::value );
     }
 };
 
-template< int I > bool operator==( arg<I> const &, arg<I> const & )
+template< int I > BOOST_CONSTEXPR bool operator==( arg<I> const &, arg<I> const & )
 {
     return true;
 }

3rdparty/boost/boost/bind/bind.hpp

@@ -32,6 +32,10 @@
 #include <boost/core/enable_if.hpp>
 #include <boost/core/is_same.hpp>
 
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+#include <utility> // std::forward
+#endif
+
 // Borland-specific bug, visit_each() silently fails to produce code
 
 #if defined(__BORLANDC__)
@@ -863,14 +867,337 @@ public:
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-template< class A > struct list_add_cref
+template< class A1 > class rrlist1
 {
-    typedef A const & type;
+private:
+
+    A1 & a1_; // not A1&& because of msvc-10.0
+
+public:
+
+    explicit rrlist1( A1 & a1 ): a1_( a1 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } // not static_cast because of g++ 4.9
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 };
 
-template< class A > struct list_add_cref< A& >
+template< class A1, class A2 > class rrlist2
 {
-    typedef A & type;
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+
+public:
+
+    rrlist2( A1 & a1, A2 & a2 ): a1_( a1 ), a2_( a2 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+};
+
+template< class A1, class A2, class A3 > class rrlist3
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+
+public:
+
+    rrlist3( A1 & a1, A2 & a2, A3 & a3 ): a1_( a1 ), a2_( a2 ), a3_( a3 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+};
+
+template< class A1, class A2, class A3, class A4 > class rrlist4
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+
+public:
+
+    rrlist4( A1 & a1, A2 & a2, A3 & a3, A4 & a4 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+};
+
+template< class A1, class A2, class A3, class A4, class A5 > class rrlist5
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+    A5 & a5_;
+
+public:
+
+    rrlist5( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+};
+
+template< class A1, class A2, class A3, class A4, class A5, class A6 > class rrlist6
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+    A5 & a5_;
+    A6 & a6_;
+
+public:
+
+    rrlist6( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+};
+
+template< class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class rrlist7
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+    A5 & a5_;
+    A6 & a6_;
+    A7 & a7_;
+
+public:
+
+    rrlist7( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+};
+
+template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class rrlist8
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+    A5 & a5_;
+    A6 & a6_;
+    A7 & a7_;
+    A8 & a8_;
+
+public:
+
+    rrlist8( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
+    A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
+    A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+};
+
+template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 > class rrlist9
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+    A5 & a5_;
+    A6 & a6_;
+    A7 & a7_;
+    A8 & a8_;
+    A9 & a9_;
+
+public:
+
+    rrlist9( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ), a9_( a9 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
+    A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); }
+    A9 && operator[] (boost::arg<9>) const { return std::forward<A9>( a9_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
+    A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); }
+    A9 && operator[] (boost::arg<9> (*) ()) const { return std::forward<A9>( a9_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 };
 
 template<class R, class F, class L> class bind_t
@@ -903,221 +1230,109 @@ public:
 
     template<class A1> result_type operator()( A1 && a1 )
     {
-        list1< typename list_add_cref<A1>::type > a( a1 );
+        rrlist1< A1 > a( a1 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1> result_type operator()( A1 && a1 ) const
     {
-        list1< typename list_add_cref<A1>::type > a( a1 );
+        rrlist1< A1 > a( a1 );
         return l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 )
     {
-        list2< typename list_add_cref<A1>::type, typename list_add_cref<A2>::type > a( a1, a2 );
+        rrlist2< A1, A2 > a( a1, a2 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 ) const
     {
-        list2< typename list_add_cref<A1>::type, typename list_add_cref<A2>::type > a( a1, a2 );
+        rrlist2< A1, A2 > a( a1, a2 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 )
     {
-        list3<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type
-        > a( a1, a2, a3 );
-
+        rrlist3< A1, A2, A3 > a( a1, a2, a3 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 ) const
     {
-        list3<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type
-        > a( a1, a2, a3 );
-
+        rrlist3< A1, A2, A3 > a( a1, a2, a3 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
     {
-        list4<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type
-        > a( a1, a2, a3, a4 );
-
+        rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 ) const
     {
-        list4<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type
-        > a( a1, a2, a3, a4 );
-
+        rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
     {
-        list5<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type,
-            typename list_add_cref<A5>::type
-        > a( a1, a2, a3, a4, a5 );
-
+        rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 ) const
     {
-        list5<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type,
-            typename list_add_cref<A5>::type
-        > a( a1, a2, a3, a4, a5 );
-
+        rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
     {
-        list6<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type,
-            typename list_add_cref<A5>::type,
-            typename list_add_cref<A6>::type
-        > a( a1, a2, a3, a4, a5, a6 );
-
+        rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 ) const
     {
-        list6<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type,
-            typename list_add_cref<A5>::type,
-            typename list_add_cref<A6>::type
-        > a( a1, a2, a3, a4, a5, a6 );
-
+        rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
     {
-        list7<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type,
-            typename list_add_cref<A5>::type,
-            typename list_add_cref<A6>::type,
-            typename list_add_cref<A7>::type
-        > a( a1, a2, a3, a4, a5, a6, a7 );
-
+        rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 ) const
     {
-        list7<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type,
-            typename list_add_cref<A5>::type,
-            typename list_add_cref<A6>::type,
-            typename list_add_cref<A7>::type
-        > a( a1, a2, a3, a4, a5, a6, a7 );
-
+        rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
     {
-        list8<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type,
-            typename list_add_cref<A5>::type,
-            typename list_add_cref<A6>::type,
-            typename list_add_cref<A7>::type,
-            typename list_add_cref<A8>::type
-        > a( a1, a2, a3, a4, a5, a6, a7, a8 );
-
+        rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 ) const
     {
-        list8<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type,
-            typename list_add_cref<A5>::type,
-            typename list_add_cref<A6>::type,
-            typename list_add_cref<A7>::type,
-            typename list_add_cref<A8>::type
-        > a( a1, a2, a3, a4, a5, a6, a7, a8 );
-
+        rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
     {
-        list9<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type,
-            typename list_add_cref<A5>::type,
-            typename list_add_cref<A6>::type,
-            typename list_add_cref<A7>::type,
-            typename list_add_cref<A8>::type,
-            typename list_add_cref<A9>::type
-        > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
-
+        rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 ) const
     {
-        list9<
-            typename list_add_cref<A1>::type,
-            typename list_add_cref<A2>::type,
-            typename list_add_cref<A3>::type,
-            typename list_add_cref<A4>::type,
-            typename list_add_cref<A5>::type,
-            typename list_add_cref<A6>::type,
-            typename list_add_cref<A7>::type,
-            typename list_add_cref<A8>::type,
-            typename list_add_cref<A9>::type
-        > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
-
+        rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
         return l_( type<result_type>(), f_, a, 0 );
     }
 

3rdparty/boost/boost/bind/placeholders.hpp

@@ -11,10 +11,11 @@
 //  bind/placeholders.hpp - _N definitions
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright 2015 Peter Dimov
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
 //
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //
@@ -22,48 +23,40 @@
 #include <boost/bind/arg.hpp>
 #include <boost/config.hpp>
 
-namespace
+namespace boost
+{
+
+namespace placeholders
 {
 
 #if defined(__BORLANDC__) || defined(__GNUC__) && (__GNUC__ < 4)
 
-static inline boost::arg<1> _1() { return boost::arg<1>(); }
-static inline boost::arg<2> _2() { return boost::arg<2>(); }
-static inline boost::arg<3> _3() { return boost::arg<3>(); }
-static inline boost::arg<4> _4() { return boost::arg<4>(); }
-static inline boost::arg<5> _5() { return boost::arg<5>(); }
-static inline boost::arg<6> _6() { return boost::arg<6>(); }
-static inline boost::arg<7> _7() { return boost::arg<7>(); }
-static inline boost::arg<8> _8() { return boost::arg<8>(); }
-static inline boost::arg<9> _9() { return boost::arg<9>(); }
-
-#elif defined(BOOST_MSVC) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__) || \
-    defined(__GNUC__) && (__GNUC__ == 4 && __GNUC_MINOR__ < 2)  
-
-static boost::arg<1> _1;
-static boost::arg<2> _2;
-static boost::arg<3> _3;
-static boost::arg<4> _4;
-static boost::arg<5> _5;
-static boost::arg<6> _6;
-static boost::arg<7> _7;
-static boost::arg<8> _8;
-static boost::arg<9> _9;
+inline boost::arg<1> _1() { return boost::arg<1>(); }
+inline boost::arg<2> _2() { return boost::arg<2>(); }
+inline boost::arg<3> _3() { return boost::arg<3>(); }
+inline boost::arg<4> _4() { return boost::arg<4>(); }
+inline boost::arg<5> _5() { return boost::arg<5>(); }
+inline boost::arg<6> _6() { return boost::arg<6>(); }
+inline boost::arg<7> _7() { return boost::arg<7>(); }
+inline boost::arg<8> _8() { return boost::arg<8>(); }
+inline boost::arg<9> _9() { return boost::arg<9>(); }
 
 #else
 
-boost::arg<1> _1;
-boost::arg<2> _2;
-boost::arg<3> _3;
-boost::arg<4> _4;
-boost::arg<5> _5;
-boost::arg<6> _6;
-boost::arg<7> _7;
-boost::arg<8> _8;
-boost::arg<9> _9;
+BOOST_STATIC_CONSTEXPR boost::arg<1> _1;
+BOOST_STATIC_CONSTEXPR boost::arg<2> _2;
+BOOST_STATIC_CONSTEXPR boost::arg<3> _3;
+BOOST_STATIC_CONSTEXPR boost::arg<4> _4;
+BOOST_STATIC_CONSTEXPR boost::arg<5> _5;
+BOOST_STATIC_CONSTEXPR boost::arg<6> _6;
+BOOST_STATIC_CONSTEXPR boost::arg<7> _7;
+BOOST_STATIC_CONSTEXPR boost::arg<8> _8;
+BOOST_STATIC_CONSTEXPR boost::arg<9> _9;
 
 #endif
 
-} // unnamed namespace
+} // namespace placeholders
+
+} // namespace boost
 
 #endif // #ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED

3rdparty/boost/boost/concept_check.hpp

@@ -19,7 +19,7 @@
 
 # include <boost/concept/assert.hpp>
 
-# include <boost/iterator.hpp>
+# include <iterator>
 # include <boost/type_traits/conversion_traits.hpp>
 # include <utility>
 # include <boost/type_traits/is_same.hpp>
@@ -27,7 +27,6 @@
 # include <boost/mpl/assert.hpp>
 # include <boost/mpl/bool.hpp>
 # include <boost/detail/workaround.hpp>
-# include <boost/detail/iterator.hpp>
 
 # include <boost/concept/usage.hpp>
 # include <boost/concept/detail/concept_def.hpp>
@@ -504,11 +503,11 @@ namespace boost
     : Assignable<TT>
     , EqualityComparable<TT>
   {
-      typedef typename boost::detail::iterator_traits<TT>::value_type value_type;
-      typedef typename boost::detail::iterator_traits<TT>::difference_type difference_type;
-      typedef typename boost::detail::iterator_traits<TT>::reference reference;
-      typedef typename boost::detail::iterator_traits<TT>::pointer pointer;
-      typedef typename boost::detail::iterator_traits<TT>::iterator_category iterator_category;
+      typedef typename std::iterator_traits<TT>::value_type value_type;
+      typedef typename std::iterator_traits<TT>::difference_type difference_type;
+      typedef typename std::iterator_traits<TT>::reference reference;
+      typedef typename std::iterator_traits<TT>::pointer pointer;
+      typedef typename std::iterator_traits<TT>::iterator_category iterator_category;
 
       BOOST_CONCEPT_USAGE(InputIterator)
       {
@@ -617,7 +616,7 @@ namespace boost
    private:
     TT a, b;
     TT i, j;
-      typename boost::detail::iterator_traits<TT>::difference_type n;
+      typename std::iterator_traits<TT>::difference_type n;
   };
 
   BOOST_concept(Mutable_RandomAccessIterator,(TT))
@@ -630,7 +629,7 @@ namespace boost
       }
    private:
     TT i;
-    typename boost::detail::iterator_traits<TT>::difference_type n;
+    typename std::iterator_traits<TT>::difference_type n;
   };
 
   //===========================================================================

3rdparty/boost/boost/config/compiler/clang.hpp

@@ -23,6 +23,10 @@
 #define __has_extension __has_feature
 #endif
 
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif
+
 #if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
 #  define BOOST_NO_EXCEPTIONS
 #endif
@@ -58,9 +62,11 @@
 // even though it defines __SIZEOF_INT128__.
 // See https://svn.boost.org/trac/boost/ticket/10418
 // Only re-enable this for nvcc if you're absolutely sure
-// of the circumstances under which it's supported:
+// of the circumstances under which it's supported.
+// Similarly __SIZEOF_INT128__ is defined when targetting msvc
+// compatibility even though the required support functions are absent.
 //
-#if defined(__SIZEOF_INT128__) && !defined(__CUDACC__)
+#if defined(__SIZEOF_INT128__) && !defined(__CUDACC__) && !defined(_MSC_VER)
 #  define BOOST_HAS_INT128
 #endif
 
@@ -255,13 +261,15 @@
 // All versions with __cplusplus above this value seem to support this:
 #  define BOOST_NO_CXX14_DIGIT_SEPARATORS
 #endif
-
-
-// Unused attribute:
-#if defined(__GNUC__) && (__GNUC__ >= 4)
-#  define BOOST_ATTRIBUTE_UNUSED __attribute__((unused))
+//
+// __builtin_unreachable:
+#if defined(__has_builtin) && __has_builtin(__builtin_unreachable)
+#define BOOST_UNREACHABLE_RETURN(x) __builtin_unreachable();
 #endif
 
+// Clang has supported the 'unused' attribute since the first release.
+#define BOOST_ATTRIBUTE_UNUSED __attribute__((__unused__))
+
 #ifndef BOOST_COMPILER
 #  define BOOST_COMPILER "Clang version " __clang_version__
 #endif

3rdparty/boost/boost/config/compiler/gcc.hpp

@@ -143,6 +143,19 @@
 #if defined(__SIZEOF_INT128__) && !defined(__CUDACC__)
 #  define BOOST_HAS_INT128
 #endif
+//
+// Recent GCC versions have a __float128 native type, we need to
+// include a std lib header to detect this - not ideal, but we'll
+// be including <cstddef> later anyway when we select the std lib.
+//
+#ifdef __cplusplus
+#include <cstddef>
+#else
+#include <stddef.h>
+#endif
+#if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__)
+# define BOOST_HAS_FLOAT128
+#endif
 
 // C++0x features in 4.3.n and later
 //
@@ -263,7 +276,12 @@
 //
 // Unused attribute:
 #if __GNUC__ >= 4
-#  define BOOST_ATTRIBUTE_UNUSED __attribute__((unused))
+#  define BOOST_ATTRIBUTE_UNUSED __attribute__((__unused__))
+#endif
+//
+// __builtin_unreachable:
+#if BOOST_GCC_VERSION >= 40800
+#define BOOST_UNREACHABLE_RETURN(x) __builtin_unreachable();
 #endif
 
 #ifndef BOOST_COMPILER

3rdparty/boost/boost/config/compiler/intel.hpp

@@ -20,6 +20,9 @@
 
 #include <boost/config/compiler/visualc.hpp>
 
+#undef BOOST_MSVC
+#undef BOOST_MSVC_FULL_VER
+
 #if (__INTEL_COMPILER >= 1500) && (_MSC_VER >= 1900)
 //
 // These appear to be supported, even though VC++ may not support them:
@@ -36,6 +39,9 @@
 
 #include <boost/config/compiler/gcc.hpp>
 
+#undef BOOST_GCC_VERSION
+#undef BOOST_GCC_CXX11
+
 #endif
 
 #undef BOOST_COMPILER

3rdparty/boost/boost/config/compiler/sunpro_cc.hpp

@@ -125,19 +125,15 @@
 #define BOOST_NO_CXX11_FINAL
 #endif
 
-//
-// Issues that effect all known versions:
-//
-// Variadic templates pass our test case, but enabling this
-// causes the compiler to issue a signal 11 and bail out
-// in various libraries.  The others fail our test cases.
-//
+#if (__SUNPRO_CC < 0x5140) || (__cplusplus < 201103)
 #define BOOST_NO_CXX11_VARIADIC_TEMPLATES
 #define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
 #define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
 #define BOOST_NO_CXX11_DECLTYPE_N3276
 #define BOOST_NO_CXX11_USER_DEFINED_LITERALS
 #define BOOST_NO_CXX11_REF_QUALIFIERS
+#endif
+
 #define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 //
 // C++0x features

3rdparty/boost/boost/config/compiler/visualc.hpp

@@ -55,6 +55,7 @@
 #  define BOOST_NO_CXX11_EXTERN_TEMPLATE
 // Variadic macros do not exist for VC7.1 and lower
 #  define BOOST_NO_CXX11_VARIADIC_MACROS
+#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
 #endif
 
 #if _MSC_VER < 1500  // 140X == VC++ 8.0

3rdparty/boost/boost/config/platform/cloudabi.hpp

@@ -0,0 +1,18 @@
+//       Copyright Nuxi, https://nuxi.nl/ 2015.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_PLATFORM "CloudABI"
+
+#define BOOST_HAS_DIRENT_H
+#define BOOST_HAS_STDINT_H
+#define BOOST_HAS_UNISTD_H
+
+#define BOOST_HAS_CLOCK_GETTIME
+#define BOOST_HAS_EXPM1
+#define BOOST_HAS_GETTIMEOFDAY
+#define BOOST_HAS_LOG1P
+#define BOOST_HAS_NANOSLEEP
+#define BOOST_HAS_PTHREADS
+#define BOOST_HAS_SCHED_YIELD

3rdparty/boost/boost/config/platform/macos.hpp

@@ -47,7 +47,7 @@
 #    define BOOST_NO_STDC_NAMESPACE
 #  endif
 
-#  if (__GNUC__ == 4)
+#  if (__GNUC__ >= 4)
 
 // Both gcc and intel require these.  
 #    define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE

3rdparty/boost/boost/config/platform/win32.hpp

@@ -74,6 +74,14 @@
 #  define BOOST_HAS_GETSYSTEMTIMEASFILETIME
 #endif
 
+//
+// Windows Runtime
+//
+#if defined(WINAPI_FAMILY) && \
+  (WINAPI_FAMILY == WINAPI_FAMILY_APP || WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
+#  define BOOST_NO_ANSI_APIS
+#endif
+
 #ifndef BOOST_DISABLE_WIN32
 // WEK: Added
 #define BOOST_HAS_FTIME

3rdparty/boost/boost/config/select_platform_config.hpp

@@ -80,6 +80,10 @@
 #elif defined(__VMS) 
 // VMS:
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/vms.hpp" 
+
+#elif defined(__CloudABI__)
+// Nuxi CloudABI:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cloudabi.hpp"
 #else
 
 #  if defined(unix) \

3rdparty/boost/boost/config/stdlib/dinkumware.hpp

@@ -172,10 +172,19 @@
 // Bug specific to VC14, 
 // See https://connect.microsoft.com/VisualStudio/feedback/details/1348277/link-error-when-using-std-codecvt-utf8-utf16-char16-t
 // and discussion here: http://blogs.msdn.com/b/vcblog/archive/2014/11/12/visual-studio-2015-preview-now-available.aspx?PageIndex=2
-#if  _CPPLIB_VER == 650
+#if defined(_CPPLIB_VER) && (_CPPLIB_VER == 650)
 #  define BOOST_NO_CXX11_HDR_CODECVT
 #endif
 
+#if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 650)
+// If _HAS_AUTO_PTR_ETC is defined to 0, std::auto_ptr is not available.
+// See https://www.visualstudio.com/en-us/news/vs2015-vs.aspx#C++
+// and http://blogs.msdn.com/b/vcblog/archive/2015/06/19/c-11-14-17-features-in-vs-2015-rtm.aspx
+#  if defined(_HAS_AUTO_PTR_ETC) && (_HAS_AUTO_PTR_ETC == 0)
+#    define BOOST_NO_AUTO_PTR
+#  endif
+#endif
+
 #ifdef _CPPLIB_VER
 #  define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER
 #else

3rdparty/boost/boost/config/stdlib/libstdcpp3.hpp

@@ -251,6 +251,10 @@
 #define BOOST_NO_CXX11_HDR_FUTURE
 #define BOOST_NO_CXX11_HDR_FORWARD_LIST 
 #define BOOST_NO_CXX11_HDR_ATOMIC
+// shared_ptr is present, but is not convertible to bool
+// which causes all kinds of problems especially in Boost.Thread
+// but probably elsewhere as well.
+#define BOOST_NO_CXX11_SMART_PTR
 #endif
 
 #if (!defined(_GLIBCXX_HAS_GTHREADS) || !defined(_GLIBCXX_USE_C99_STDINT_TR1))

3rdparty/boost/boost/config/suffix.hpp

@@ -444,10 +444,12 @@ namespace std {
 // is defined, in which case it evaluates to return x; Use when you have a return
 // statement that can never be reached.
 
-#ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION
+#ifndef BOOST_UNREACHABLE_RETURN
+#  ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION
 #     define BOOST_UNREACHABLE_RETURN(x) return x;
-#else
+#  else
 #     define BOOST_UNREACHABLE_RETURN(x)
+#  endif
 #endif
 
 // BOOST_DEDUCED_TYPENAME workaround ------------------------------------------//
@@ -501,6 +503,16 @@ namespace boost{
 #  endif
 }
 #endif
+// same again for __float128:
+#if defined(BOOST_HAS_FLOAT128) && defined(__cplusplus)
+namespace boost {
+#  ifdef __GNUC__
+   __extension__ typedef __float128 float128_type;
+#  else
+   typedef __float128 float128_type;
+#  endif
+}
+#endif
 
 // BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------//
 

3rdparty/boost/boost/container/container_fwd.hpp

@@ -24,6 +24,7 @@
 //!   - boost::container::vector
 //!   - boost::container::stable_vector
 //!   - boost::container::static_vector
+//!   - boost::container::small_vector
 //!   - boost::container::slist
 //!   - boost::container::list
 //!   - boost::container::set
@@ -38,11 +39,19 @@
 //!   - boost::container::string
 //!   - boost::container::wstring
 //!
-//! It forward declares the following allocators:
+//! Forward declares the following allocators:
 //!   - boost::container::allocator
 //!   - boost::container::node_allocator
 //!   - boost::container::adaptive_pool
 //!
+//! Forward declares the following polymorphic resource classes:
+//!   - boost::container::pmr::memory_resource
+//!   - boost::container::pmr::polymorphic_allocator
+//!   - boost::container::pmr::monotonic_buffer_resource
+//!   - boost::container::pmr::pool_options
+//!   - boost::container::pmr::unsynchronized_pool_resource
+//!   - boost::container::pmr::synchronized_pool_resource
+//!
 //! And finally it defines the following types
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -54,11 +63,18 @@
 
 namespace boost{
 namespace intrusive{
+namespace detail{
    //Create namespace to avoid compilation errors
-}}
+}}}
 
 namespace boost{ namespace container{ namespace container_detail{
    namespace bi = boost::intrusive;
+   namespace bid = boost::intrusive::detail;
+}}}
+
+namespace boost{ namespace container{ namespace pmr{
+   namespace bi = boost::intrusive;
+   namespace bid = boost::intrusive::detail;
 }}}
 
 #include <cstddef>
@@ -210,6 +226,26 @@ template
    , std::size_t Version = 2>
 class node_allocator;
 
+namespace pmr {
+
+class memory_resource;
+
+template<class T>
+class polymorphic_allocator;
+
+class monotonic_buffer_resource;
+
+struct pool_options;
+
+template <class Allocator>
+class resource_adaptor_imp;
+
+class unsynchronized_pool_resource;
+
+class synchronized_pool_resource;
+
+}  //namespace pmr {
+
 #else
 
 //! Default options for tree-based associative containers

3rdparty/boost/boost/container/detail/std_fwd.hpp

@@ -23,26 +23,8 @@
 //                        Standard predeclarations
 //////////////////////////////////////////////////////////////////////////////
 
-#if defined(_LIBCPP_VERSION)
-   #define BOOST_CONTAINER_CLANG_INLINE_STD_NS
-   #pragma GCC diagnostic push
-   #if defined(__clang__)
-      #pragma GCC diagnostic ignored "-Wc++11-extensions"
-   #endif
-   #define BOOST_CONTAINER_STD_NS_BEG _LIBCPP_BEGIN_NAMESPACE_STD
-   #define BOOST_CONTAINER_STD_NS_END _LIBCPP_END_NAMESPACE_STD
-#elif defined(BOOST_GNU_STDLIB) && defined(_GLIBCXX_BEGIN_NAMESPACE_VERSION)  //GCC >= 4.6
-   #define BOOST_CONTAINER_STD_NS_BEG namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION
-   #define BOOST_CONTAINER_STD_NS_END _GLIBCXX_END_NAMESPACE_VERSION  } // namespace
-#elif defined(BOOST_GNU_STDLIB) && defined(_GLIBCXX_BEGIN_NAMESPACE)  //GCC >= 4.2
-   #define BOOST_CONTAINER_STD_NS_BEG _GLIBCXX_BEGIN_NAMESPACE(std)
-   #define BOOST_CONTAINER_STD_NS_END _GLIBCXX_END_NAMESPACE
-#else
-   #define BOOST_CONTAINER_STD_NS_BEG namespace std{
-   #define BOOST_CONTAINER_STD_NS_END }
-#endif
-
-BOOST_CONTAINER_STD_NS_BEG
+#include <boost/move/detail/std_ns_begin.hpp>
+BOOST_MOVE_STD_NS_BEG
 
 template<class T>
 class allocator;
@@ -66,11 +48,9 @@ class insert_iterator;
 
 struct allocator_arg_t;
 
-BOOST_CONTAINER_STD_NS_END
+struct piecewise_construct_t;
 
-#ifdef BOOST_CONTAINER_CLANG_INLINE_STD_NS
-   #pragma GCC diagnostic pop
-   #undef BOOST_CONTAINER_CLANG_INLINE_STD_NS
-#endif   //BOOST_CONTAINER_CLANG_INLINE_STD_NS
+BOOST_MOVE_STD_NS_END
+#include <boost/move/detail/std_ns_end.hpp>
 
 #endif //#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP

3rdparty/boost/boost/core/demangle.hpp

@@ -27,8 +27,15 @@
 
 #if defined( BOOST_CORE_HAS_CXXABI_H )
 # include <cxxabi.h>
+// For some archtectures (mips, mips64, x86, x86_64) cxxabi.h in Android NDK is implemented by gabi++ library
+// (https://android.googlesource.com/platform/ndk/+/master/sources/cxx-stl/gabi++/), which does not implement
+// abi::__cxa_demangle(). We detect this implementation by checking the include guard here.
+# if defined( __GABIXX_CXXABI_H__ )
+#  undef BOOST_CORE_HAS_CXXABI_H
+# else
 #  include <cstdlib>
 #  include <cstddef>
+# endif
 #endif
 
 namespace boost

3rdparty/boost/boost/core/enable_if.hpp

@@ -23,6 +23,11 @@
 
 namespace boost
 {
+  template<typename T, typename R=void>
+  struct enable_if_has_type
+  {
+    typedef R type;
+  };
  
   template <bool B, class T = void>
   struct enable_if_c {
@@ -80,6 +85,10 @@ namespace boost {
   template <typename T>
   struct enable_if_does_not_work_on_this_compiler;
 
+  template<typename T, typename R=void>
+  struct enable_if_has_type : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
   template <bool B, class T = detail::enable_if_default_T>
   struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
   { };

3rdparty/boost/boost/cstdint.hpp

@@ -69,7 +69,7 @@
 
 # endif
 
-#ifdef __QNX__
+#if defined(__QNX__) && defined(__EXT_QNX) 
 
 // QNX (Dinkumware stdlib) defines these as non-standard names.
 // Reflect to the standard names.

3rdparty/boost/boost/exception/exception.hpp

@@ -432,6 +432,11 @@ boost
             {
             }
 
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility push (default)
+# endif
+#endif
         template <class T>
         class
         clone_impl:
@@ -473,6 +478,11 @@ boost
                 }
             };
         }
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility pop
+# endif
+#endif
 
     template <class T>
     inline

3rdparty/boost/boost/format/feed_args.hpp

@@ -172,6 +172,10 @@ namespace detail {
         typedef typename string_type::size_type size_type;
 
         basic_oaltstringstream<Ch, Tr, Alloc>  oss( &buf);
+
+        if(loc_p != NULL)
+            oss.imbue(*loc_p);
+        
         specs.fmtstate_.apply_on(oss, loc_p);
 
         // the stream format state can be modified by manipulators in the argument :

3rdparty/boost/boost/functional/hash/hash.hpp

@@ -411,7 +411,7 @@ namespace boost
     // passed by copy.
     //
     // BOOST_HASH_SPECIALIZE_REF - define a specialization for a type which is
-    // passed by copy.
+    // passed by const reference.
     //
     // These are undefined later.
 

3rdparty/boost/boost/lexical_cast.hpp

@@ -30,20 +30,19 @@
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/lexical_cast/bad_lexical_cast.hpp>
 #include <boost/lexical_cast/try_lexical_convert.hpp>
-#include <boost/utility/value_init.hpp>
 
 namespace boost 
 {
     template <typename Target, typename Source>
     inline Target lexical_cast(const Source &arg)
     {
-        boost::value_initialized<Target> result;
+        Target result;
 
-        if (!boost::conversion::detail::try_lexical_convert(arg, get(result))) {
+        if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
             boost::conversion::detail::throw_bad_cast<Source, Target>();
         }
 
-        return get(result);
+        return result;
     }
 
     template <typename Target>

3rdparty/boost/boost/lexical_cast/detail/converter_lexical.hpp

@@ -364,7 +364,6 @@ namespace boost {
 #endif
         };
 
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
         // Helper for floating point types.
         // -1.23456789e-123456
         // ^                   sign
@@ -380,6 +379,8 @@ namespace boost {
                 Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_float<Source> >::type
             >
         {
+
+#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
             BOOST_STATIC_ASSERT(
                     std::numeric_limits<Source>::max_exponent10 <=  999999L &&
                     std::numeric_limits<Source>::min_exponent10 >= -999999L
@@ -388,8 +389,10 @@ namespace boost {
             BOOST_STATIC_CONSTANT(std::size_t, value =
                     5 + lcast_precision<Source>::value + 6
                 );
-        };
+#else // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+            BOOST_STATIC_CONSTANT(std::size_t, value = 156);
 #endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+        };
     }
 
     namespace detail // lexical_cast_stream_traits<Source, Target>

3rdparty/boost/boost/lexical_cast/try_lexical_convert.hpp

@@ -23,6 +23,13 @@
 #   pragma once
 #endif
 
+#if defined(__clang__) || (defined(__GNUC__) && \
+    !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && \
+    (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#endif
+
 #include <string>
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/identity.hpp>
@@ -195,5 +202,11 @@ namespace boost {
 
 } // namespace boost
 
+#if defined(__clang__) || (defined(__GNUC__) && \
+    !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && \
+    (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+#pragma GCC diagnostic pop
+#endif
+
 #endif // BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
 

3rdparty/boost/boost/math/policies/policy.hpp

@@ -33,9 +33,9 @@ namespace boost{ namespace math{
 namespace tools{
 
 template <class T>
-int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T));
+BOOST_MATH_CONSTEXPR int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT;
 template <class T>
-T epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T));
+BOOST_MATH_CONSTEXPR T epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T);
 
 }
 
@@ -44,6 +44,28 @@ namespace policies{
 //
 // Define macros for our default policies, if they're not defined already:
 //
+// Special cases for exceptions disabled first:
+//
+#ifdef BOOST_NO_EXCEPTIONS
+#  ifndef BOOST_MATH_DOMAIN_ERROR_POLICY
+#    define BOOST_MATH_DOMAIN_ERROR_POLICY errno_on_error
+#  endif
+#  ifndef BOOST_MATH_POLE_ERROR_POLICY
+#     define BOOST_MATH_POLE_ERROR_POLICY errno_on_error
+#  endif
+#  ifndef BOOST_MATH_OVERFLOW_ERROR_POLICY
+#     define BOOST_MATH_OVERFLOW_ERROR_POLICY errno_on_error
+#  endif
+#  ifndef BOOST_MATH_EVALUATION_ERROR_POLICY
+#     define BOOST_MATH_EVALUATION_ERROR_POLICY errno_on_error
+#  endif
+#  ifndef BOOST_MATH_ROUNDING_ERROR_POLICY
+#     define BOOST_MATH_ROUNDING_ERROR_POLICY errno_on_error
+#  endif
+#endif
+//
+// Then the regular cases:
+//
 #ifndef BOOST_MATH_DOMAIN_ERROR_POLICY
 #define BOOST_MATH_DOMAIN_ERROR_POLICY throw_on_error
 #endif
@@ -622,81 +644,81 @@ struct normalise<policy<detail::forwarding_arg1, detail::forwarding_arg2>,
    typedef policy<detail::forwarding_arg1, detail::forwarding_arg2> type;
 };
 
-inline policy<> make_policy()
+inline BOOST_MATH_CONSTEXPR policy<> make_policy() BOOST_NOEXCEPT
 { return policy<>(); }
 
 template <class A1>
-inline typename normalise<policy<>, A1>::type make_policy(const A1&)
+inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1>::type make_policy(const A1&) BOOST_NOEXCEPT
 { 
    typedef typename normalise<policy<>, A1>::type result_type;
    return result_type(); 
 }
 
 template <class A1, class A2>
-inline typename normalise<policy<>, A1, A2>::type make_policy(const A1&, const A2&)
+inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2>::type make_policy(const A1&, const A2&) BOOST_NOEXCEPT
 { 
    typedef typename normalise<policy<>, A1, A2>::type result_type;
    return result_type(); 
 }
 
 template <class A1, class A2, class A3>
-inline typename normalise<policy<>, A1, A2, A3>::type make_policy(const A1&, const A2&, const A3&)
+inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3>::type make_policy(const A1&, const A2&, const A3&) BOOST_NOEXCEPT
 { 
    typedef typename normalise<policy<>, A1, A2, A3>::type result_type;
    return result_type(); 
 }
 
 template <class A1, class A2, class A3, class A4>
-inline typename normalise<policy<>, A1, A2, A3, A4>::type make_policy(const A1&, const A2&, const A3&, const A4&)
+inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4>::type make_policy(const A1&, const A2&, const A3&, const A4&) BOOST_NOEXCEPT
 { 
    typedef typename normalise<policy<>, A1, A2, A3, A4>::type result_type;
    return result_type(); 
 }
 
 template <class A1, class A2, class A3, class A4, class A5>
-inline typename normalise<policy<>, A1, A2, A3, A4, A5>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&)
+inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&) BOOST_NOEXCEPT
 { 
    typedef typename normalise<policy<>, A1, A2, A3, A4, A5>::type result_type;
    return result_type(); 
 }
 
 template <class A1, class A2, class A3, class A4, class A5, class A6>
-inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&)
+inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&) BOOST_NOEXCEPT
 { 
    typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type result_type;
    return result_type(); 
 }
 
 template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&)
+inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&) BOOST_NOEXCEPT
 { 
    typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7>::type result_type;
    return result_type(); 
 }
 
 template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&)
+inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&) BOOST_NOEXCEPT
 { 
    typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8>::type result_type;
    return result_type(); 
 }
 
 template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&)
+inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&) BOOST_NOEXCEPT
 { 
    typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9>::type result_type;
    return result_type(); 
 }
 
 template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&)
+inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&) BOOST_NOEXCEPT
 { 
    typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::type result_type;
    return result_type(); 
 }
 
 template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
-inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&, const A11&)
+inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&, const A11&) BOOST_NOEXCEPT
 {
    typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::type result_type;
    return result_type();
@@ -825,7 +847,7 @@ struct precision<BOOST_MATH_FLOAT128_TYPE, Policy>
 namespace detail{
 
 template <class T, class Policy>
-inline int digits_imp(mpl::true_ const&)
+inline BOOST_MATH_CONSTEXPR int digits_imp(mpl::true_ const&) BOOST_NOEXCEPT
 {
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
    BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized);
@@ -837,7 +859,7 @@ inline int digits_imp(mpl::true_ const&)
 }
 
 template <class T, class Policy>
-inline int digits_imp(mpl::false_ const&)
+inline BOOST_MATH_CONSTEXPR int digits_imp(mpl::false_ const&) BOOST_NOEXCEPT
 {
    return tools::digits<T>();
 }
@@ -845,26 +867,26 @@ inline int digits_imp(mpl::false_ const&)
 } // namespace detail
 
 template <class T, class Policy>
-inline int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T))
+inline BOOST_MATH_CONSTEXPR int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT
 {
    typedef mpl::bool_< std::numeric_limits<T>::is_specialized > tag_type;
    return detail::digits_imp<T, Policy>(tag_type());
 }
 template <class T, class Policy>
-inline int digits_base10(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T))
+inline BOOST_MATH_CONSTEXPR int digits_base10(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT
 {
    return boost::math::policies::digits<T, Policy>() * 301 / 1000L;
 }
 
 template <class Policy>
-inline unsigned long get_max_series_iterations()
+inline BOOST_MATH_CONSTEXPR unsigned long get_max_series_iterations() BOOST_NOEXCEPT
 {
    typedef typename Policy::max_series_iterations_type iter_type;
    return iter_type::value;
 }
 
 template <class Policy>
-inline unsigned long get_max_root_iterations()
+inline BOOST_MATH_CONSTEXPR unsigned long get_max_root_iterations() BOOST_NOEXCEPT
 {
    typedef typename Policy::max_root_iterations_type iter_type;
    return iter_type::value;
@@ -875,7 +897,7 @@ namespace detail{
 template <class T, class Digits, class Small, class Default>
 struct series_factor_calc
 {
-   static T get()
+   static T get() BOOST_MATH_NOEXCEPT(T)
    {
       return ldexp(T(1.0), 1 - Digits::value);
    }
@@ -884,7 +906,7 @@ struct series_factor_calc
 template <class T, class Digits>
 struct series_factor_calc<T, Digits, mpl::true_, mpl::true_>
 {
-   static T get()
+   static BOOST_MATH_CONSTEXPR T get() BOOST_MATH_NOEXCEPT(T)
    {
       return boost::math::tools::epsilon<T>();
    }
@@ -892,23 +914,24 @@ struct series_factor_calc<T, Digits, mpl::true_, mpl::true_>
 template <class T, class Digits>
 struct series_factor_calc<T, Digits, mpl::true_, mpl::false_>
 {
-   static T get()
+   BOOST_STATIC_CONSTANT(boost::uintmax_t, v = static_cast<boost::uintmax_t>(1u) << (Digits::value - 1));
+
+   static BOOST_MATH_CONSTEXPR T get() BOOST_MATH_NOEXCEPT(T)
    {
-      static const boost::uintmax_t v = static_cast<boost::uintmax_t>(1u) << (Digits::value - 1);
       return 1 / static_cast<T>(v);
    }
 };
 template <class T, class Digits>
 struct series_factor_calc<T, Digits, mpl::false_, mpl::true_>
 {
-   static T get()
+   static BOOST_MATH_CONSTEXPR T get() BOOST_MATH_NOEXCEPT(T)
    {
       return boost::math::tools::epsilon<T>();
    }
 };
 
 template <class T, class Policy>
-inline T get_epsilon_imp(mpl::true_ const&)
+inline BOOST_MATH_CONSTEXPR T get_epsilon_imp(mpl::true_ const&) BOOST_MATH_NOEXCEPT(T)
 {
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
    BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized);
@@ -924,7 +947,7 @@ inline T get_epsilon_imp(mpl::true_ const&)
 }
 
 template <class T, class Policy>
-inline T get_epsilon_imp(mpl::false_ const&)
+inline BOOST_MATH_CONSTEXPR T get_epsilon_imp(mpl::false_ const&) BOOST_MATH_NOEXCEPT(T)
 {
    return tools::epsilon<T>();
 }
@@ -932,7 +955,7 @@ inline T get_epsilon_imp(mpl::false_ const&)
 } // namespace detail
 
 template <class T, class Policy>
-inline T get_epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T))
+inline BOOST_MATH_CONSTEXPR T get_epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
 {
    typedef mpl::bool_< (std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::radix == 2)) > tag_type;
    return detail::get_epsilon_imp<T, Policy>(tag_type());
@@ -973,7 +996,7 @@ struct constructor_error_check
 {
    typedef typename Policy::domain_error_type domain_error_type;
    typedef typename mpl::if_c<
-      (domain_error_type::value == throw_on_error) || (domain_error_type::value == user_error),
+      (domain_error_type::value == throw_on_error) || (domain_error_type::value == user_error) || (domain_error_type::value == errno_on_error),
       mpl::true_,
       mpl::false_>::type type;
 };
@@ -987,10 +1010,33 @@ struct method_error_check
       mpl::false_,
       mpl::true_>::type type;
 };
+//
+// Does the Policy ever throw on error?
+//
+template <class Policy>
+struct is_noexcept_error_policy
+{
+   typedef typename Policy::domain_error_type               t1;
+   typedef typename Policy::pole_error_type                 t2;
+   typedef typename Policy::overflow_error_type             t3;
+   typedef typename Policy::underflow_error_type            t4;
+   typedef typename Policy::denorm_error_type               t5;
+   typedef typename Policy::evaluation_error_type           t6;
+   typedef typename Policy::rounding_error_type             t7;
+   typedef typename Policy::indeterminate_result_error_type t8;
+
+   BOOST_STATIC_CONSTANT(bool, value = 
+      ((t1::value != throw_on_error) && (t1::value != user_error)
+      && (t2::value != throw_on_error) && (t2::value != user_error)
+      && (t3::value != throw_on_error) && (t3::value != user_error)
+      && (t4::value != throw_on_error) && (t4::value != user_error)
+      && (t5::value != throw_on_error) && (t5::value != user_error)
+      && (t6::value != throw_on_error) && (t6::value != user_error)
+      && (t7::value != throw_on_error) && (t7::value != user_error)
+      && (t8::value != throw_on_error) && (t8::value != user_error)));
+};
 
 }}} // namespaces
 
 #endif // BOOST_MATH_POLICY_HPP
 
-
-

3rdparty/boost/boost/math/special_functions/fpclassify.hpp

@@ -80,6 +80,9 @@ is used.
 #if defined(_MSC_VER) || defined(__BORLANDC__)
 #include <float.h>
 #endif
+#ifdef BOOST_MATH_USE_FLOAT128
+#include "quadmath.h"
+#endif
 
 #ifdef BOOST_NO_STDC_NAMESPACE
   namespace std{ using ::abs; using ::fabs; }
@@ -121,7 +124,10 @@ inline bool is_nan_helper(T, const boost::false_type&)
 {
    return false;
 }
-
+#ifdef BOOST_MATH_USE_FLOAT128
+inline bool is_nan_helper(__float128 f, const boost::true_type&) { return ::isnanq(f); }
+inline bool is_nan_helper(__float128 f, const boost::false_type&) { return ::isnanq(f); }
+#endif
 }
 
 namespace math{
@@ -513,6 +519,13 @@ inline bool (isinf)(long double x)
    return detail::isinf_impl(static_cast<value_type>(x), method());
 }
 #endif
+#ifdef BOOST_MATH_USE_FLOAT128
+template<>
+inline bool (isinf)(__float128 x)
+{
+   return ::isinfq(x);
+}
+#endif
 
 //------------------------------------------------------------------------------
 
@@ -598,6 +611,13 @@ inline bool (isnan)(long double x)
    return detail::isnan_impl(x, method());
 }
 #endif
+#ifdef BOOST_MATH_USE_FLOAT128
+template<>
+inline bool (isnan)(__float128 x)
+{
+   return ::isnanq(x);
+}
+#endif
 
 } // namespace math
 } // namespace boost

3rdparty/boost/boost/math/special_functions/math_fwd.hpp

@@ -181,19 +181,19 @@ namespace boost
    template <class T>
    typename tools::promote_args<T>::type
          legendre_p(int l, T x);
-
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
    template <class T, class Policy>
    typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
          legendre_p(int l, T x, const Policy& pol);
-
+#endif
    template <class T>
    typename tools::promote_args<T>::type
          legendre_q(unsigned l, T x);
-
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
    template <class T, class Policy>
    typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
          legendre_q(unsigned l, T x, const Policy& pol);
-
+#endif
    template <class T1, class T2, class T3>
    typename tools::promote_args<T1, T2, T3>::type
          legendre_next(unsigned l, unsigned m, T1 x, T2 Pl, T3 Plm1);
@@ -607,8 +607,10 @@ namespace boost
       template <class T1, class T2, class Policy>
       struct bessel_traits
       {
-         typedef typename tools::promote_args<
-            T1, T2
+         typedef typename mpl::if_<
+            is_integral<T1>,
+            typename tools::promote_args<T2>::type,
+            typename tools::promote_args<T1, T2>::type
          >::type result_type;
 
          typedef typename policies::precision<result_type, Policy>::type precision_type;
@@ -994,6 +996,16 @@ namespace boost
    template <class T>
    typename tools::promote_args<T>::type float_advance(const T& val, int distance);
 
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type ulp(const T& val, const Policy& pol);
+   template <class T>
+   typename tools::promote_args<T>::type ulp(const T& val);
+
+   template <class T, class U>
+   typename tools::promote_args<T, U>::type relative_difference(const T&, const U&);
+   template <class T, class U>
+   typename tools::promote_args<T, U>::type epsilon_difference(const T&, const U&);
+
    template<class T>
    T unchecked_bernoulli_b2n(const std::size_t n);
    template <class T, class Policy>
@@ -1447,6 +1459,7 @@ template <class OutputIterator, class T>\
    template <class T> T float_next(const T& a){ return boost::math::float_next(a, Policy()); }\
    template <class T> T float_prior(const T& a){ return boost::math::float_prior(a, Policy()); }\
    template <class T> T float_distance(const T& a, const T& b){ return boost::math::float_distance(a, b, Policy()); }\
+   template <class T> T ulp(const T& a){ return boost::math::ulp(a, Policy()); }\
    \
    template <class RT1, class RT2>\
    inline typename boost::math::tools::promote_args<RT1, RT2>::type owens_t(RT1 a, RT2 z){ return boost::math::owens_t(a, z, Policy()); }\

3rdparty/boost/boost/math/tools/config.hpp

@@ -11,6 +11,7 @@
 #endif
 
 #include <boost/config.hpp>
+#include <boost/predef.h>
 #include <boost/cstdint.hpp> // for boost::uintmax_t
 #include <boost/detail/workaround.hpp>
 #include <boost/type_traits/is_integral.hpp>
@@ -183,14 +184,20 @@
 //
 #ifdef BOOST_MSVC
 #  define BOOST_MATH_POLY_METHOD 2
+#  define BOOST_MATH_RATIONAL_METHOD 1
 #elif defined(BOOST_INTEL)
 #  define BOOST_MATH_POLY_METHOD 2
-#  define BOOST_MATH_RATIONAL_METHOD 2
+#  define BOOST_MATH_RATIONAL_METHOD 1
 #elif defined(__GNUC__)
+#if __GNUC__ < 4
 #  define BOOST_MATH_POLY_METHOD 3
 #  define BOOST_MATH_RATIONAL_METHOD 3
 #  define BOOST_MATH_INT_TABLE_TYPE(RT, IT) RT
 #  define BOOST_MATH_INT_VALUE_SUFFIX(RV, SUF) RV##.0L
+#else
+#  define BOOST_MATH_POLY_METHOD 3
+#  define BOOST_MATH_RATIONAL_METHOD 1
+#endif
 #endif
 
 #if defined(BOOST_NO_LONG_LONG) && !defined(BOOST_MATH_INT_TABLE_TYPE)
@@ -198,21 +205,55 @@
 #  define BOOST_MATH_INT_VALUE_SUFFIX(RV, SUF) RV##.0L
 #endif
 
+//
+// constexpr support, early GCC implementations can't cope so disable
+// constexpr for them:
+//
+#if !defined(__clang) && defined(__GNUC__)
+#if (__GNUC__ * 100 + __GNUC_MINOR__) < 490
+#  define BOOST_MATH_DISABLE_CONSTEXPR
+#endif
+#endif
+
+#ifdef BOOST_MATH_DISABLE_CONSTEXPR
+#  define BOOST_MATH_CONSTEXPR
+#else
+#  define BOOST_MATH_CONSTEXPR BOOST_CONSTEXPR
+#endif
+
+//
+// noexcept support:
+//
+#ifndef BOOST_NO_CXX11_NOEXCEPT
+#ifndef BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#include <type_traits>
+#  define BOOST_MATH_NOEXCEPT(T) noexcept(std::is_floating_point<T>::value)
+#  define BOOST_MATH_IS_FLOAT(T) (std::is_floating_point<T>::value)
+#else
+#include <boost/type_traits/is_floating_point.hpp>
+#  define BOOST_MATH_NOEXCEPT(T) noexcept(boost::is_floating_point<T>::value)
+#  define BOOST_MATH_IS_FLOAT(T) (boost::is_floating_point<T>::value)
+#endif
+#else
+#  define BOOST_MATH_NOEXCEPT(T)
+#  define BOOST_MATH_IS_FLOAT(T) false
+#endif
+
 //
 // The maximum order of polynomial that will be evaluated 
 // via an unrolled specialisation:
 //
 #ifndef BOOST_MATH_MAX_POLY_ORDER
-#  define BOOST_MATH_MAX_POLY_ORDER 17
+#  define BOOST_MATH_MAX_POLY_ORDER 20
 #endif 
 //
 // Set the method used to evaluate polynomials and rationals:
 //
 #ifndef BOOST_MATH_POLY_METHOD
-#  define BOOST_MATH_POLY_METHOD 1
+#  define BOOST_MATH_POLY_METHOD 2
 #endif 
 #ifndef BOOST_MATH_RATIONAL_METHOD
-#  define BOOST_MATH_RATIONAL_METHOD 0
+#  define BOOST_MATH_RATIONAL_METHOD 1
 #endif 
 //
 // decide whether to store constants as integers or reals:
@@ -224,7 +265,19 @@
 #  define BOOST_MATH_INT_VALUE_SUFFIX(RV, SUF) RV##SUF
 #endif
 //
-// Test whether to support __float128:
+// Test whether to support __float128, if we don't have quadmath.h then this can't currently work:
+//
+#ifndef BOOST_MATH_USE_FLOAT128
+#ifdef __has_include
+#if ! __has_include("quadmath.h")
+#define BOOST_MATH_DISABLE_FLOAT128
+#endif
+#elif !defined(BOOST_ARCH_X86)
+#define BOOST_MATH_DISABLE_FLOAT128
+#endif
+#endif
+//
+// And then the actual configuration:
 //
 #if defined(_GLIBCXX_USE_FLOAT128) && defined(BOOST_GCC) && !defined(__STRICT_ANSI__) \
    && !defined(BOOST_MATH_DISABLE_FLOAT128) || defined(BOOST_MATH_USE_FLOAT128)
@@ -296,13 +349,13 @@ namespace tools
 {
 
 template <class T>
-inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c)
+inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c) BOOST_MATH_NOEXCEPT(T)
 {
    return (std::max)((std::max)(a, b), c);
 }
 
 template <class T>
-inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c, T d)
+inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c, T d) BOOST_MATH_NOEXCEPT(T)
 {
    return (std::max)((std::max)(a, b), (std::max)(c, d));
 }
@@ -310,7 +363,7 @@ inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c, T d)
 } // namespace tools
 
 template <class T>
-void suppress_unused_variable_warning(const T&)
+void suppress_unused_variable_warning(const T&) BOOST_MATH_NOEXCEPT(T)
 {
 }
 

3rdparty/boost/boost/math/tools/promotion.hpp

@@ -86,12 +86,19 @@ namespace boost
 
         typedef typename mpl::if_<
           typename mpl::and_<is_floating_point<T1P>, is_floating_point<T2P> >::type, // both T1P and T2P are floating-point?
+#ifdef BOOST_MATH_USE_FLOAT128
+           typename mpl::if_< typename mpl::or_<is_same<__float128, T1P>, is_same<__float128, T2P> >::type, // either long double?
+            __float128,
+#endif
              typename mpl::if_< typename mpl::or_<is_same<long double, T1P>, is_same<long double, T2P> >::type, // either long double?
                long double, // then result type is long double.
                typename mpl::if_< typename mpl::or_<is_same<double, T1P>, is_same<double, T2P> >::type, // either double?
                   double, // result type is double.
                   float // else result type is float.
              >::type
+#ifdef BOOST_MATH_USE_FLOAT128
+             >::type
+#endif
              >::type,
           // else one or the other is a user-defined type:
           typename mpl::if_< typename mpl::and_<mpl::not_<is_floating_point<T2P> >, ::boost::is_convertible<T1P, T2P> >, T2P, T1P>::type>::type type;

3rdparty/boost/boost/math/tools/real_cast.hpp

@@ -6,6 +6,8 @@
 #ifndef BOOST_MATH_TOOLS_REAL_CAST_HPP
 #define BOOST_MATH_TOOLS_REAL_CAST_HPP
 
+#include <boost/math/tools/config.hpp>
+
 #ifdef _MSC_VER
 #pragma once
 #endif
@@ -15,7 +17,7 @@ namespace boost{ namespace math
   namespace tools
   {
     template <class To, class T>
-    inline To real_cast(T t)
+    inline BOOST_MATH_CONSTEXPR To real_cast(T t) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && BOOST_MATH_IS_FLOAT(To))
     {
        return static_cast<To>(t);
     }

3rdparty/boost/boost/move/core.hpp

@@ -27,6 +27,8 @@
 #include <boost/move/detail/config_begin.hpp>
 #include <boost/move/detail/workaround.hpp>
 
+// @cond
+
 //boost_move_no_copy_constructor_or_assign typedef
 //used to detect noncopyable types for other Boost libraries.
 #if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
@@ -49,6 +51,8 @@
    //
 #endif   //BOOST_NO_CXX11_DELETED_FUNCTIONS
 
+// @endcond
+
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
 
    #include <boost/move/detail/type_traits.hpp>

3rdparty/boost/boost/move/detail/meta_utils.hpp

@@ -332,6 +332,11 @@ struct eval_if
     : if_<C,T1,T2>::type
 {};
 
+
+#if defined(BOOST_GCC) && (BOOST_GCC <= 40000)
+#define BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN
+#endif
+
 template<class T, class U, class R = void>
 struct enable_if_convertible
    : enable_if< is_convertible<T, U>, R>

3rdparty/boost/boost/move/detail/std_ns_begin.hpp

@@ -0,0 +1,30 @@
+#//////////////////////////////////////////////////////////////////////////////
+#//
+#// (C) Copyright Ion Gaztanaga 2015-2015.
+#// Distributed under the Boost Software License, Version 1.0.
+#// (See accompanying file LICENSE_1_0.txt or copy at
+#// http://www.boost.org/LICENSE_1_0.txt)
+#//
+#// See http://www.boost.org/libs/move for documentation.
+#//
+#//////////////////////////////////////////////////////////////////////////////
+#
+#if defined(_LIBCPP_VERSION)
+   #if defined(__clang__)
+      #define BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
+      #pragma GCC diagnostic push
+      #pragma GCC diagnostic ignored "-Wc++11-extensions"
+   #endif
+   #define BOOST_MOVE_STD_NS_BEG _LIBCPP_BEGIN_NAMESPACE_STD
+   #define BOOST_MOVE_STD_NS_END _LIBCPP_END_NAMESPACE_STD
+#elif defined(BOOST_GNU_STDLIB) && defined(_GLIBCXX_BEGIN_NAMESPACE_VERSION)  //GCC >= 4.6
+   #define BOOST_MOVE_STD_NS_BEG namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION
+   #define BOOST_MOVE_STD_NS_END _GLIBCXX_END_NAMESPACE_VERSION  } // namespace
+#elif defined(BOOST_GNU_STDLIB) && defined(_GLIBCXX_BEGIN_NAMESPACE)  //GCC >= 4.2
+   #define BOOST_MOVE_STD_NS_BEG _GLIBCXX_BEGIN_NAMESPACE(std)
+   #define BOOST_MOVE_STD_NS_END _GLIBCXX_END_NAMESPACE
+#else
+   #define BOOST_MOVE_STD_NS_BEG namespace std{
+   #define BOOST_MOVE_STD_NS_END }
+#endif
+

3rdparty/boost/boost/move/detail/std_ns_end.hpp

@@ -0,0 +1,14 @@
+#//////////////////////////////////////////////////////////////////////////////
+#//
+#// (C) Copyright Ion Gaztanaga 2015-2015.
+#// Distributed under the Boost Software License, Version 1.0.
+#// (See accompanying file LICENSE_1_0.txt or copy at
+#// http://www.boost.org/LICENSE_1_0.txt)
+#//
+#// See http://www.boost.org/libs/move for documentation.
+#//
+#//////////////////////////////////////////////////////////////////////////////
+#ifdef BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
+   #pragma GCC diagnostic pop
+   #undef BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
+#endif   //BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH

3rdparty/boost/boost/move/detail/type_traits.hpp

@@ -480,7 +480,7 @@ template <class T>
 struct remove_all_extents<T[]>
 {  typedef typename remove_all_extents<T>::type type; };
 
-template <class T, size_t N>
+template <class T, std::size_t N>
 struct remove_all_extents<T[N]>
 {  typedef typename remove_all_extents<T>::type type;};
 
@@ -1003,7 +1003,7 @@ BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1000)
 
 #else //BOOST_NO_ALIGNMENT
 
-template<class T, size_t Len>
+template<class T, std::size_t Len>
 union aligned_union
 {	
    T aligner;

3rdparty/boost/boost/move/utility_core.hpp

@@ -265,6 +265,8 @@
 
 
       #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+         //! <b>Effects</b>: Calls `boost::move` if `input_reference` is not a lvalue reference.
+         //!   Otherwise returns the reference
          template <class T> output_reference move_if_not_lvalue_reference(input_reference) noexcept;
       #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
 

3rdparty/boost/boost/mpl/string.hpp

@@ -59,7 +59,7 @@ namespace boost { namespace mpl
     #define BOOST_MPL_MULTICHAR_LENGTH(c)                                                           \
       (std::size_t)((c<CHAR_MIN) ? 4 : ((c>0xffffff)+(c>0xffff)+(c>0xff)+1))
 
-    #if defined(BOOST_ENDIAN_LITTLE_BYTE) && defined(__SUNPRO_CC)
+    #if BOOST_ENDIAN_LITTLE_BYTE && defined(__SUNPRO_CC)
 
         #define BOOST_MPL_MULTICHAR_AT(c,i)                                                         \
           (char)(0xff&((unsigned)(c)>>(8*(std::size_t)(i))))

3rdparty/boost/boost/none.hpp

@@ -22,8 +22,10 @@
 namespace boost {
 
 #ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
+
 none_t const none = (static_cast<none_t>(0)) ;
-#else
+
+#elif defined BOOST_OPTIONAL_USE_SINGLETON_DEFINITION_OF_NONE
 
 namespace detail { namespace optional_detail {
 
@@ -45,9 +47,13 @@ namespace {
   const none_t& none = detail::optional_detail::none_instance<none_t>::instance; 
 }
 
-#endif
+#else
+
+const none_t none ((none_t::init_tag()));
+
+#endif // older definitions
 
 } // namespace boost
 
-#endif
+#endif // header guard
 

3rdparty/boost/boost/none_t.hpp

@@ -16,13 +16,25 @@
 namespace boost {
 
 #ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
+
 namespace detail { struct none_helper{}; }
 typedef int detail::none_helper::*none_t ;
-#else
+
+#elif defined BOOST_OPTIONAL_USE_SINGLETON_DEFINITION_OF_NONE
+
 class none_t {};
-#endif
+
+#else
+
+struct none_t
+{
+  struct init_tag{};
+  explicit none_t(init_tag){} // to prevent default constructor
+};
+
+#endif // old implementation workarounds
 
 } // namespace boost
 
-#endif
+#endif // header guard
 

3rdparty/boost/boost/operators.hpp

@@ -82,8 +82,10 @@
 #ifndef BOOST_OPERATORS_HPP
 #define BOOST_OPERATORS_HPP
 
+#include <cstddef>
+#include <iterator>
+
 #include <boost/config.hpp>
-#include <boost/iterator.hpp>
 #include <boost/detail/workaround.hpp>
 
 #if defined(__sgi) && !defined(__GNUC__)
@@ -891,13 +893,13 @@ template <class T,
           class R = V const &>
 struct input_iterator_helper
   : input_iteratable<T, P
-  , boost::iterator<std::input_iterator_tag, V, D, P, R
+  , std::iterator<std::input_iterator_tag, V, D, P, R
     > > {};
 
 template<class T>
 struct output_iterator_helper
   : output_iteratable<T
-  , boost::iterator<std::output_iterator_tag, void, void, void, void
+  , std::iterator<std::output_iterator_tag, void, void, void, void
   > >
 {
   T& operator*()  { return static_cast<T&>(*this); }
@@ -911,7 +913,7 @@ template <class T,
           class R = V&>
 struct forward_iterator_helper
   : forward_iteratable<T, P
-  , boost::iterator<std::forward_iterator_tag, V, D, P, R
+  , std::iterator<std::forward_iterator_tag, V, D, P, R
     > > {};
 
 template <class T,
@@ -921,7 +923,7 @@ template <class T,
           class R = V&>
 struct bidirectional_iterator_helper
   : bidirectional_iteratable<T, P
-  , boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
+  , std::iterator<std::bidirectional_iterator_tag, V, D, P, R
     > > {};
 
 template <class T,
@@ -931,7 +933,7 @@ template <class T,
           class R = V&>
 struct random_access_iterator_helper
   : random_access_iteratable<T, P, D, R
-  , boost::iterator<std::random_access_iterator_tag, V, D, P, R
+  , std::iterator<std::random_access_iterator_tag, V, D, P, R
     > >
 {
   friend D requires_difference_operator(const T& x, const T& y) {

3rdparty/boost/boost/predef.h

@@ -17,6 +17,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/predef/os.h>
 #include <boost/predef/other.h>
 #include <boost/predef/platform.h>
+#include <boost/predef/hardware.h>
 
 #include <boost/predef/version.h>
 

3rdparty/boost/boost/predef/detail/_cassert.h

@@ -8,7 +8,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 #ifndef BOOST_PREDEF_DETAIL__CASSERT_H
 #define BOOST_PREDEF_DETAIL__CASSERT_H
 
-#if defined(__cpluplus)
+#if defined(__cplusplus)
 #include <cassert>
 #else
 #include <assert.h>

3rdparty/boost/boost/predef/detail/_exception.h

@@ -8,7 +8,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 #ifndef BOOST_PREDEF_DETAIL__EXCEPTION_H
 #define BOOST_PREDEF_DETAIL__EXCEPTION_H
 
-#if defined(__cpluplus)
+#if defined(__cplusplus)
 #include <exception>
 #endif
 

3rdparty/boost/boost/predef/hardware.h

@@ -0,0 +1,16 @@
+/*
+Copyright Charly Chevalier 2015
+Copyright Joel Falcou 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#if !defined(BOOST_PREDEF_HARDWARE_H) || defined(BOOST_PREDEF_INTERNAL_GENERATE_TESTS)
+#ifndef BOOST_PREDEF_HARDWARE_H
+#define BOOST_PREDEF_HARDWARE_H
+#endif
+
+#include <boost/predef/hardware/simd.h>
+
+#endif

3rdparty/boost/boost/predef/hardware/simd.h

@@ -0,0 +1,107 @@
+/*
+Copyright Charly Chevalier 2015
+Copyright Joel Falcou 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#include <boost/predef/hardware/simd/x86.h>
+#include <boost/predef/hardware/simd/x86_amd.h>
+#include <boost/predef/hardware/simd/arm.h>
+#include <boost/predef/hardware/simd/ppc.h>
+
+#ifndef BOOST_PREDEF_HARDWARE_SIMD_H
+#define BOOST_PREDEF_HARDWARE_SIMD_H
+
+#include <boost/predef/version_number.h>
+
+/*`
+ [section Using the `BOOST_HW_SIMD_*` predefs]
+ [include ../doc/hardware_simd.qbk]
+ [endsect]
+
+ [/ --------------------------- ]
+
+ [section `BOOST_HW_SIMD_*`]
+
+ [heading `BOOST_HW_SIMD`]
+
+ The SIMD extension detected for a specific architectures.
+ Version number depends on the detected extension.
+
+ [table
+     [[__predef_symbol__] [__predef_version__]]
+
+     [[`BOOST_HW_SIMD_X86_AVAILABLE`] [__predef_detection__]]
+     [[`BOOST_HW_SIMD_X86_AMD_AVAILABLE`] [__predef_detection__]]
+     [[`BOOST_HW_SIMD_ARM_AVAILABLE`] [__predef_detection__]]
+     [[`BOOST_HW_SIMD_PPC_AVAILABLE`] [__predef_detection__]]
+     ]
+
+ [include ../include/boost/predef/hardware/simd/x86.h]
+ [include ../include/boost/predef/hardware/simd/x86_amd.h]
+ [include ../include/boost/predef/hardware/simd/arm.h]
+ [include ../include/boost/predef/hardware/simd/ppc.h]
+
+ [endsect]
+
+ [/ --------------------------- ]
+
+ [section `BOOST_HW_SIMD_X86_*_VERSION`]
+ [include ../include/boost/predef/hardware/simd/x86/versions.h]
+ [endsect]
+
+ [section `BOOST_HW_SIMD_X86_AMD_*_VERSION`]
+ [include ../include/boost/predef/hardware/simd/x86_amd/versions.h]
+ [endsect]
+
+ [section `BOOST_HW_SIMD_ARM_*_VERSION`]
+ [include ../include/boost/predef/hardware/simd/arm/versions.h]
+ [endsect]
+
+ [section `BOOST_HW_SIMD_PPC_*_VERSION`]
+ [include ../include/boost/predef/hardware/simd/ppc/versions.h]
+ [endsect]
+
+ */
+
+// We check if SIMD extension of multiples architectures have been detected,
+// if yes, then this is an error!
+//
+// NOTE: _X86_AMD implies _X86, so there is no need to check for it here!
+//
+#if defined(BOOST_HW_SIMD_ARM_AVAILABLE) && defined(BOOST_HW_SIMD_PPC_AVAILABLE) ||\
+    defined(BOOST_HW_SIMD_ARM_AVAILABLE) && defined(BOOST_HW_SIMD_X86_AVAILABLE) ||\
+    defined(BOOST_HW_SIMD_PPC_AVAILABLE) && defined(BOOST_HW_SIMD_X86_AVAILABLE)
+#   error "Multiple SIMD architectures detected, this cannot happen!"
+#endif
+
+#if defined(BOOST_HW_SIMD_X86_AVAILABLE)
+#   define BOOST_HW_SIMD BOOST_HW_SIMD_X86
+#endif
+
+#if defined(BOOST_HW_SIMD_X86_AMD_AVAILABLE)
+#   define BOOST_HW_SIMD BOOST_HW_SIMD_X86_AMD
+#endif
+
+#if defined(BOOST_HW_SIMD_ARM_AVAILABLE)
+#   define BOOST_HW_SIMD BOOST_HW_SIMD_ARM
+#endif
+
+#if defined(BOOST_HW_SIMD_PPC_AVAILABLE)
+#   define BOOST_HW_SIMD BOOST_HW_SIMD_PPC
+#endif
+
+#if defined(BOOST_HW_SIMD)
+#   define BOOST_HW_SIMD_AVAILABLE
+#else
+#   define BOOST_HW_SIMD BOOST_VERSION_NUMBER_NOT_AVAILABLE
+#endif
+
+#define BOOST_HW_SIMD_NAME "Hardware SIMD"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_HW_SIMD, BOOST_HW_SIMD_NAME)

3rdparty/boost/boost/predef/hardware/simd/arm.h

@@ -0,0 +1,57 @@
+/*
+Copyright Charly Chevalier 2015
+Copyright Joel Falcou 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_PREDEF_HARDWARE_SIMD_ARM_H
+#define BOOST_PREDEF_HARDWARE_SIMD_ARM_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/hardware/simd/arm/versions.h>
+
+/*`
+ [heading `BOOST_HW_SIMD_ARM`]
+
+ The SIMD extension for ARM (*if detected*).
+ Version number depends on the most recent detected extension.
+
+ [table
+     [[__predef_symbol__] [__predef_version__]]
+
+     [[`__ARM_NEON__`] [__predef_detection__]]
+     [[`__aarch64__`] [__predef_detection__]]
+     [[`_M_ARM`] [__predef_detection__]]
+     ]
+
+ [table
+     [[__predef_symbol__] [__predef_version__]]
+
+     [[`__ARM_NEON__`] [BOOST_HW_SIMD_ARM_NEON_VERSION]]
+     [[`__aarch64__`] [BOOST_HW_SIMD_ARM_NEON_VERSION]]
+     [[`_M_ARM`] [BOOST_HW_SIMD_ARM_NEON_VERSION]]
+     ]
+
+ */
+
+#define BOOST_HW_SIMD_ARM BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#undef BOOST_HW_SIMD_ARM
+#if !defined(BOOST_HW_SIMD_ARM) && (defined(__ARM_NEON__) || defined(__aarch64__) || defined (_M_ARM))
+#   define BOOST_HW_SIMD_ARM BOOST_HW_SIMD_ARM_NEON_VERSION
+#endif
+
+#if !defined(BOOST_HW_SIMD_ARM)
+#   define BOOST_HW_SIMD_ARM BOOST_VERSION_NUMBER_NOT_AVAILABLE
+#else
+#   define BOOST_HW_SIMD_ARM_AVAILABLE
+#endif
+
+#define BOOST_HW_SIMD_ARM_NAME "ARM SIMD"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_HW_SIMD_ARM, BOOST_HW_SIMD_ARM_NAME)

3rdparty/boost/boost/predef/hardware/simd/arm/versions.h

@@ -0,0 +1,32 @@
+/*
+Copyright Charly Chevalier 2015
+Copyright Joel Falcou 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_PREDEF_HARDWARE_SIMD_ARM_VERSIONS_H
+#define BOOST_PREDEF_HARDWARE_SIMD_ARM_VERSIONS_H
+
+#include <boost/predef/version_number.h>
+
+/*`
+ Those defines represent ARM SIMD extensions versions.
+
+ [note You *MUST* compare them with the predef `BOOST_HW_SIMD_ARM`.]
+ */
+
+// ---------------------------------
+
+/*`
+ [heading `BOOST_HW_SIMD_ARM_NEON_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/ARM_architecture#Advanced_SIMD_.28NEON.29 NEON]
+ ARM extension version number.
+
+ Version number is: *1.0.0*.
+ */
+#define BOOST_HW_SIMD_ARM_NEON_VERSION BOOST_VERSION_NUMBER(1, 0, 0)
+
+#endif

3rdparty/boost/boost/predef/hardware/simd/ppc.h

@@ -0,0 +1,69 @@
+/*
+Copyright Charly Chevalier 2015
+Copyright Joel Falcou 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_PREDEF_HARDWARE_SIMD_PPC_H
+#define BOOST_PREDEF_HARDWARE_SIMD_PPC_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/hardware/simd/ppc/versions.h>
+
+/*`
+ [heading `BOOST_HW_SIMD_PPC`]
+
+ The SIMD extension for PowerPC (*if detected*).
+ Version number depends on the most recent detected extension.
+
+ [table
+     [[__predef_symbol__] [__predef_version__]]
+
+     [[`__VECTOR4DOUBLE__`] [__predef_detection__]]
+
+     [[`__ALTIVEC__`] [__predef_detection__]]
+     [[`__VEC__`] [__predef_detection__]]
+
+     [[`__VSX__`] [__predef_detection__]]
+     ]
+
+ [table
+     [[__predef_symbol__] [__predef_version__]]
+
+     [[`__VECTOR4DOUBLE__`] [BOOST_HW_SIMD_PPC_QPX_VERSION]]
+
+     [[`__ALTIVEC__`] [BOOST_HW_SIMD_PPC_VMX_VERSION]]
+     [[`__VEC__`] [BOOST_HW_SIMD_PPC_VMX_VERSION]]
+
+     [[`__VSX__`] [BOOST_HW_SIMD_PPC_VSX_VERSION]]
+     ]
+
+ */
+
+#define BOOST_HW_SIMD_PPC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#undef BOOST_HW_SIMD_PPC
+#if !defined(BOOST_HW_SIMD_PPC) && defined(__VECTOR4DOUBLE__)
+#   define BOOST_HW_SIMD_PPC BOOST_HW_SIMD_PPC_QPX_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_PPC) && defined(__VSX__)
+#   define BOOST_HW_SIMD_PPC BOOST_HW_SIMD_PPC_VSX_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_PPC) && (defined(__ALTIVEC__) || defined(__VEC__))
+#   define BOOST_HW_SIMD_PPC BOOST_HW_SIMD_PPC_VMX_VERSION
+#endif
+
+#if !defined(BOOST_HW_SIMD_PPC)
+#   define BOOST_HW_SIMD_PPC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+#else
+#   define BOOST_HW_SIMD_PPC_AVAILABLE
+#endif
+
+#define BOOST_HW_SIMD_PPC_NAME "PPC SIMD"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_HW_SIMD_PPC, BOOST_HW_SIMD_PPC_NAME)

3rdparty/boost/boost/predef/hardware/simd/ppc/versions.h

@@ -0,0 +1,51 @@
+/*
+Copyright Charly Chevalier 2015
+Copyright Joel Falcou 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_PREDEF_HARDWARE_SIMD_PPC_VERSIONS_H
+#define BOOST_PREDEF_HARDWARE_SIMD_PPC_VERSIONS_H
+
+#include <boost/predef/version_number.h>
+
+/*`
+ Those defines represent Power PC SIMD extensions versions.
+
+ [note You *MUST* compare them with the predef `BOOST_HW_SIMD_PPC`.]
+ */
+
+// ---------------------------------
+
+/*`
+ [heading `BOOST_HW_SIMD_PPC_VMX_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/AltiVec#VMX128 VMX] powerpc extension
+ version number.
+
+ Version number is: *1.0.0*.
+ */
+#define BOOST_HW_SIMD_PPC_VMX_VERSION BOOST_VERSION_NUMBER(1, 0, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_PPC_VSX_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/AltiVec#VSX VSX] powerpc extension version
+ number.
+
+ Version number is: *1.1.0*.
+ */
+#define BOOST_HW_SIMD_PPC_VSX_VERSION BOOST_VERSION_NUMBER(1, 1, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_PPC_QPX_VERSION`]
+
+ The QPX powerpc extension version number.
+
+ Version number is: *2.0.0*.
+ */
+#define BOOST_HW_SIMD_PPC_QPX_VERSION BOOST_VERSION_NUMBER(2, 0, 0)
+
+#endif

3rdparty/boost/boost/predef/hardware/simd/x86.h

@@ -0,0 +1,123 @@
+/*
+Copyright Charly Chevalier 2015
+Copyright Joel Falcou 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_PREDEF_HARDWARE_SIMD_X86_H
+#define BOOST_PREDEF_HARDWARE_SIMD_X86_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/hardware/simd/x86/versions.h>
+
+/*`
+ [heading `BOOST_HW_SIMD_X86`]
+
+ The SIMD extension for x86 (*if detected*).
+ Version number depends on the most recent detected extension.
+
+ [table
+     [[__predef_symbol__] [__predef_version__]]
+
+     [[`__SSE__`] [__predef_detection__]]
+     [[`_M_X64`] [__predef_detection__]]
+     [[`_M_IX86_FP >= 1`] [__predef_detection__]]
+
+     [[`__SSE2__`] [__predef_detection__]]
+     [[`_M_X64`] [__predef_detection__]]
+     [[`_M_IX86_FP >= 2`] [__predef_detection__]]
+
+     [[`__SSE3__`] [__predef_detection__]]
+
+     [[`__SSSE3__`] [__predef_detection__]]
+
+     [[`__SSE4_1__`] [__predef_detection__]]
+
+     [[`__SSE4_2__`] [__predef_detection__]]
+
+     [[`__AVX__`] [__predef_detection__]]
+
+     [[`__FMA__`] [__predef_detection__]]
+
+     [[`__AVX2__`] [__predef_detection__]]
+     ]
+
+ [table
+     [[__predef_symbol__] [__predef_version__]]
+
+     [[`__SSE__`] [BOOST_HW_SIMD_X86_SSE_VERSION]]
+     [[`_M_X64`] [BOOST_HW_SIMD_X86_SSE_VERSION]]
+     [[`_M_IX86_FP >= 1`] [BOOST_HW_SIMD_X86_SSE_VERSION]]
+
+     [[`__SSE2__`] [BOOST_HW_SIMD_X86_SSE2_VERSION]]
+     [[`_M_X64`] [BOOST_HW_SIMD_X86_SSE2_VERSION]]
+     [[`_M_IX86_FP >= 2`] [BOOST_HW_SIMD_X86_SSE2_VERSION]]
+
+     [[`__SSE3__`] [BOOST_HW_SIMD_X86_SSE3_VERSION]]
+
+     [[`__SSSE3__`] [BOOST_HW_SIMD_X86_SSSE3_VERSION]]
+
+     [[`__SSE4_1__`] [BOOST_HW_SIMD_X86_SSE4_1_VERSION]]
+
+     [[`__SSE4_2__`] [BOOST_HW_SIMD_X86_SSE4_2_VERSION]]
+
+     [[`__AVX__`] [BOOST_HW_SIMD_X86_AVX_VERSION]]
+
+     [[`__FMA__`] [BOOST_HW_SIMD_X86_FMA3_VERSION]]
+
+     [[`__AVX2__`] [BOOST_HW_SIMD_x86_AVX2_VERSION]]
+     ]
+
+ */
+
+#define BOOST_HW_SIMD_X86 BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#undef BOOST_HW_SIMD_X86
+#if !defined(BOOST_HW_SIMD_X86) && defined(__MIC__)
+#   define BOOST_HW_SIMD_X86 BOOST_HW_SIMD_X86_MIC_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86) && defined(__AVX2__)
+#   define BOOST_HW_SIMD_X86 BOOST_HW_SIMD_X86_AVX2_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86) && defined(__AVX__)
+#   define BOOST_HW_SIMD_X86 BOOST_HW_SIMD_X86_AVX_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86) && defined(__FMA__)
+#   define BOOST_HW_SIMD_X86 BOOST_HW_SIMD_X86_FMA_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86) && defined(__SSE4_2__)
+#   define BOOST_HW_SIMD_X86 BOOST_HW_SIMD_X86_SSE4_2_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86) && defined(__SSE4_1__)
+#   define BOOST_HW_SIMD_X86 BOOST_HW_SIMD_X86_SSE4_1_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86) && defined(__SSSE3__)
+#   define BOOST_HW_SIMD_X86 BOOST_HW_SIMD_X86_SSSE3_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86) && defined(__SSE3__)
+#   define BOOST_HW_SIMD_X86 BOOST_HW_SIMD_X86_SSE3_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86) && (defined(__SSE2__) || defined(_M_X64) || _M_IX86_FP >= 2)
+#   define BOOST_HW_SIMD_X86 BOOST_HW_SIMD_X86_SSE2_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86) && (defined(__SSE__) || defined(_M_X64) || _M_IX86_FP >= 1)
+#   define BOOST_HW_SIMD_X86 BOOST_HW_SIMD_X86_SSE_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86) && defined(__MMX__)
+#   define BOOST_HW_SIMD_X86 BOOST_HW_SIMD_X86_MMX_VERSION
+#endif
+
+#if !defined(BOOST_HW_SIMD_X86)
+#   define BOOST_HW_SIMD_X86 BOOST_VERSION_NUMBER_NOT_AVAILABLE
+#else
+#   define BOOST_HW_SIMD_X86_AVAILABLE
+#endif
+
+#define BOOST_HW_SIMD_X86_NAME "x86 SIMD"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_HW_SIMD_X86, BOOST_HW_SIMD_X86_NAME)

3rdparty/boost/boost/predef/hardware/simd/x86/versions.h

@@ -0,0 +1,129 @@
+/*
+Copyright Charly Chevalier 2015
+Copyright Joel Falcou 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_PREDEF_HARDWARE_SIMD_X86_VERSIONS_H
+#define BOOST_PREDEF_HARDWARE_SIMD_X86_VERSIONS_H
+
+#include <boost/predef/version_number.h>
+
+/*`
+ Those defines represent x86 SIMD extensions versions.
+
+ [note You *MUST* compare them with the predef `BOOST_HW_SIMD_X86`.]
+ */
+
+// ---------------------------------
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_MMX_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/MMX_(instruction_set) MMX] x86 extension
+ version number.
+
+ Version number is: *0.99.0*.
+ */
+#define BOOST_HW_SIMD_X86_MMX_VERSION BOOST_VERSION_NUMBER(0, 99, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_SSE_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/Streaming_SIMD_Extensions SSE] x86 extension
+ version number.
+
+ Version number is: *1.0.0*.
+ */
+#define BOOST_HW_SIMD_X86_SSE_VERSION BOOST_VERSION_NUMBER(1, 0, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_SSE2_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/SSE2 SSE2] x86 extension version number.
+
+ Version number is: *2.0.0*.
+ */
+#define BOOST_HW_SIMD_X86_SSE2_VERSION BOOST_VERSION_NUMBER(2, 0, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_SSE3_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/SSE3 SSE3] x86 extension version number.
+
+ Version number is: *3.0.0*.
+ */
+#define BOOST_HW_SIMD_X86_SSE3_VERSION BOOST_VERSION_NUMBER(3, 0, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_SSSE3_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/SSSE3 SSSE3] x86 extension version number.
+
+ Version number is: *3.1.0*.
+ */
+#define BOOST_HW_SIMD_X86_SSSE3_VERSION BOOST_VERSION_NUMBER(3, 1, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_SSE4_1_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/SSE4#SSE4.1 SSE4_1] x86 extension version
+ number.
+
+ Version number is: *4.1.0*.
+ */
+#define BOOST_HW_SIMD_X86_SSE4_1_VERSION BOOST_VERSION_NUMBER(4, 1, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_SSE4_2_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/SSE4##SSE4.2 SSE4_2] x86 extension version
+ number.
+
+ Version number is: *4.2.0*.
+ */
+#define BOOST_HW_SIMD_X86_SSE4_2_VERSION BOOST_VERSION_NUMBER(4, 2, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_AVX_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/Advanced_Vector_Extensions AVX] x86
+ extension version number.
+
+ Version number is: *5.0.0*.
+ */
+#define BOOST_HW_SIMD_X86_AVX_VERSION BOOST_VERSION_NUMBER(5, 0, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_FMA3_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/FMA_instruction_set FMA3] x86 extension
+ version number.
+
+ Version number is: *5.2.0*.
+ */
+#define BOOST_HW_SIMD_X86_FMA3_VERSION BOOST_VERSION_NUMBER(5, 2, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_AVX2_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/Advanced_Vector_Extensions#Advanced_Vector_Extensions_2 AVX2]
+ x86 extension version number.
+
+ Version number is: *5.3.0*.
+ */
+#define BOOST_HW_SIMD_X86_AVX2_VERSION BOOST_VERSION_NUMBER(5, 3, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_MIC_VERSION`]
+
+ The [@https://en.wikipedia.org/wiki/Xeon_Phi MIC] (Xeon Phi) x86 extension
+ version number.
+
+ Version number is: *9.0.0*.
+ */
+#define BOOST_HW_SIMD_X86_MIC_VERSION BOOST_VERSION_NUMBER(9, 0, 0)
+
+#endif

3rdparty/boost/boost/predef/hardware/simd/x86_amd.h

@@ -0,0 +1,87 @@
+/*
+Copyright Charly Chevalier 2015
+Copyright Joel Falcou 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_PREDEF_HARDWARE_SIMD_X86_AMD_H
+#define BOOST_PREDEF_HARDWARE_SIMD_X86_AMD_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/hardware/simd/x86_amd/versions.h>
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_AMD`]
+
+ The SIMD extension for x86 (AMD) (*if detected*).
+ Version number depends on the most recent detected extension.
+
+ [table
+     [[__predef_symbol__] [__predef_version__]]
+
+     [[`__SSE4A__`] [__predef_detection__]]
+
+     [[`__FMA4__`] [__predef_detection__]]
+
+     [[`__XOP__`] [__predef_detection__]]
+
+     [[`BOOST_HW_SIMD_X86`] [__predef_detection__]]
+     ]
+
+ [table
+     [[__predef_symbol__] [__predef_version__]]
+
+     [[`__SSE4A__`] [BOOST_HW_SIMD_x86_SSE4A_VERSION]]
+
+     [[`__FMA4__`] [BOOST_HW_SIMD_x86_FMA4_VERSION]]
+
+     [[`__XOP__`] [BOOST_HW_SIMD_x86_XOP_VERSION]]
+
+     [[`BOOST_HW_SIMD_X86`] [BOOST_HW_SIMD_x86]]
+     ]
+
+ [note This predef includes every other x86 SIMD extensions and also has other
+ more specific extensions (FMA4, XOP, SSE4a). You should use this predef
+ instead of `BOOST_HW_SIMD_X86` to test if those specific extensions have
+ been detected.]
+
+ */
+
+#define BOOST_HW_SIMD_X86_AMD BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+// AMD CPUs also use x86 architecture. We first try to detect if any AMD
+// specific extension are detected, if yes, then try to detect more recent x86
+// common extensions.
+
+#undef BOOST_HW_SIMD_X86_AMD
+#if !defined(BOOST_HW_SIMD_X86_AMD) && defined(__XOP__)
+#   define BOOST_HW_SIMD_X86_AMD BOOST_HW_SIMD_X86_AMD_XOP_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86_AMD) && defined(__FMA4__)
+#   define BOOST_HW_SIMD_X86_AMD BOOST_HW_SIMD_X86_AMD_FMA4_VERSION
+#endif
+#if !defined(BOOST_HW_SIMD_X86_AMD) && defined(__SSE4A__)
+#   define BOOST_HW_SIMD_X86_AMD BOOST_HW_SIMD_X86_AMD_SSE4A_VERSION
+#endif
+
+#if !defined(BOOST_HW_SIMD_X86_AMD)
+#   define BOOST_HW_SIMD_X86_AMD BOOST_VERSION_NUMBER_NOT_AVAILABLE
+#else
+    // At this point, we know that we have an AMD CPU, we do need to check for
+    // other x86 extensions to determine the final version number.
+#   include <boost/predef/hardware/simd/x86.h>
+#   if BOOST_HW_SIMD_X86 > BOOST_HW_SIMD_X86_AMD
+#      undef BOOST_HW_SIMD_X86_AMD
+#      define BOOST_HW_SIMD_X86_AMD BOOST_HW_SIMD_X86
+#   endif
+#   define BOOST_HW_SIMD_X86_AMD_AVAILABLE
+#endif
+
+#define BOOST_HW_SIMD_X86_AMD_NAME "x86 (AMD) SIMD"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_HW_SIMD_X86_AMD, BOOST_HW_SIMD_X86_AMD_NAME)

3rdparty/boost/boost/predef/hardware/simd/x86_amd/versions.h

@@ -0,0 +1,51 @@
+/*
+Copyright Charly Chevalier 2015
+Copyright Joel Falcou 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_PREDEF_HARDWARE_SIMD_X86_AMD_VERSIONS_H
+#define BOOST_PREDEF_HARDWARE_SIMD_X86_AMD_VERSIONS_H
+
+#include <boost/predef/version_number.h>
+
+/*`
+ Those defines represent x86 (AMD specific) SIMD extensions versions.
+
+ [note You *MUST* compare them with the predef `BOOST_HW_SIMD_X86_AMD`.]
+ */
+
+
+// ---------------------------------
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_SSE4A_VERSION`]
+
+ [@https://en.wikipedia.org/wiki/SSE4##SSE4A SSE4A] x86 extension (AMD specific).
+
+ Version number is: *4.0.0*.
+ */
+#define BOOST_HW_SIMD_X86_AMD_SSE4A_VERSION BOOST_VERSION_NUMBER(4, 0, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_XOP_VERSION`]
+
+ [@https://en.wikipedia.org/wiki/XOP_instruction_set XOP] x86 extension (AMD specific).
+
+ Version number is: *5.1.0*.
+ */
+#define BOOST_HW_SIMD_X86_AMD_FMA4_VERSION BOOST_VERSION_NUMBER(5, 1, 0)
+
+/*`
+ [heading `BOOST_HW_SIMD_X86_XOP_VERSION`]
+
+ [@https://en.wikipedia.org/wiki/XOP_instruction_set XOP] x86 extension (AMD specific).
+
+ Version number is: *5.1.1*.
+ */
+#define BOOST_HW_SIMD_X86_AMD_XOP_VERSION BOOST_VERSION_NUMBER(5, 1, 1)
+
+
+#endif

3rdparty/boost/boost/predef/platform/windows_desktop.h

@@ -33,7 +33,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 #endif
  
 #if BOOST_PLAT_WINDOWS_DESKTOP
-#   define BOOST_PLAT_WINDOWS_DESKTOP_AVALIABLE
+#   define BOOST_PLAT_WINDOWS_DESKTOP_AVAILABLE
 #   include <boost/predef/detail/platform_detected.h>
 #endif
 

3rdparty/boost/boost/predef/platform/windows_phone.h

@@ -31,7 +31,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 #endif
  
 #if BOOST_PLAT_WINDOWS_PHONE
-#   define BOOST_PLAT_WINDOWS_PHONE_AVALIABLE
+#   define BOOST_PLAT_WINDOWS_PHONE_AVAILABLE
 #   include <boost/predef/detail/platform_detected.h>
 #endif
 

3rdparty/boost/boost/predef/platform/windows_runtime.h

@@ -33,7 +33,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 #endif
  
 #if BOOST_PLAT_WINDOWS_RUNTIME
-#   define BOOST_PLAT_WINDOWS_RUNTIME_AVALIABLE
+#   define BOOST_PLAT_WINDOWS_RUNTIME_AVAILABLE
 #   include <boost/predef/detail/platform_detected.h>
 #endif
 

3rdparty/boost/boost/predef/platform/windows_store.h

@@ -31,7 +31,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 #endif
  
 #if BOOST_PLAT_WINDOWS_STORE
-#   define BOOST_PLAT_WINDOWS_STORE_AVALIABLE
+#   define BOOST_PLAT_WINDOWS_STORE_AVAILABLE
 #   include <boost/predef/detail/platform_detected.h>
 #endif
 

3rdparty/boost/boost/predef/version.h

@@ -10,6 +10,6 @@ http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/predef/version_number.h>
 
-#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,3,0)
+#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,4,0)
 
 #endif

3rdparty/boost/boost/preprocessor/facilities/identity.hpp

@@ -8,6 +8,7 @@
 #  */
 #
 # /* Revised by Paul Mensonides (2002) */
+# /* Revised by Edward Diener (2015) */
 #
 # /* See http://www.boost.org for most recent version. */
 #
@@ -15,9 +16,12 @@
 # define BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP
 #
 # include <boost/preprocessor/facilities/empty.hpp>
+# include <boost/preprocessor/tuple/eat.hpp>
 #
 # /* BOOST_PP_IDENTITY */
 #
 # define BOOST_PP_IDENTITY(item) item BOOST_PP_EMPTY
 #
+# define BOOST_PP_IDENTITY_N(item,n) item BOOST_PP_TUPLE_EAT_N(n)
+#
 # endif

3rdparty/boost/boost/preprocessor/list/append.hpp

@@ -1,40 +0,0 @@
-# /* Copyright (C) 2001
-#  * Housemarque Oy
-#  * http://www.housemarque.com
-#  *
-#  * Distributed under the Boost Software License, Version 1.0. (See
-#  * accompanying file LICENSE_1_0.txt or copy at
-#  * http://www.boost.org/LICENSE_1_0.txt)
-#  */
-#
-# /* Revised by Paul Mensonides (2002) */
-#
-# /* See http://www.boost.org for most recent version. */
-#
-# ifndef BOOST_PREPROCESSOR_LIST_APPEND_HPP
-# define BOOST_PREPROCESSOR_LIST_APPEND_HPP
-#
-# include <boost/preprocessor/config/config.hpp>
-# include <boost/preprocessor/list/fold_right.hpp>
-#
-# /* BOOST_PP_LIST_APPEND */
-#
-# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
-#    define BOOST_PP_LIST_APPEND(a, b) BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_APPEND_O, b, a)
-# else
-#    define BOOST_PP_LIST_APPEND(a, b) BOOST_PP_LIST_APPEND_I(a, b)
-#    define BOOST_PP_LIST_APPEND_I(a, b) BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_APPEND_O, b, a)
-# endif
-#
-# define BOOST_PP_LIST_APPEND_O(d, s, x) (x, s)
-#
-# /* BOOST_PP_LIST_APPEND_D */
-#
-# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
-#    define BOOST_PP_LIST_APPEND_D(d, a, b) BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_APPEND_O, b, a)
-# else
-#    define BOOST_PP_LIST_APPEND_D(d, a, b) BOOST_PP_LIST_APPEND_D_I(d, a, b)
-#    define BOOST_PP_LIST_APPEND_D_I(d, a, b) BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_APPEND_O, b, a)
-# endif
-#
-# endif

3rdparty/boost/boost/preprocessor/list/transform.hpp

@@ -1,49 +0,0 @@
-# /* Copyright (C) 2001
-#  * Housemarque Oy
-#  * http://www.housemarque.com
-#  *
-#  * Distributed under the Boost Software License, Version 1.0. (See
-#  * accompanying file LICENSE_1_0.txt or copy at
-#  * http://www.boost.org/LICENSE_1_0.txt)
-#  */
-#
-# /* Revised by Paul Mensonides (2002) */
-#
-# /* See http://www.boost.org for most recent version. */
-#
-# ifndef BOOST_PREPROCESSOR_LIST_TRANSFORM_HPP
-# define BOOST_PREPROCESSOR_LIST_TRANSFORM_HPP
-#
-# include <boost/preprocessor/config/config.hpp>
-# include <boost/preprocessor/list/fold_right.hpp>
-# include <boost/preprocessor/tuple/elem.hpp>
-# include <boost/preprocessor/tuple/rem.hpp>
-#
-# /* BOOST_PP_LIST_TRANSFORM */
-#
-# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
-#    define BOOST_PP_LIST_TRANSFORM(op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list))
-# else
-#    define BOOST_PP_LIST_TRANSFORM(op, data, list) BOOST_PP_LIST_TRANSFORM_I(op, data, list)
-#    define BOOST_PP_LIST_TRANSFORM_I(op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list))
-# endif
-#
-# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
-#    define BOOST_PP_LIST_TRANSFORM_O(d, odr, elem) BOOST_PP_LIST_TRANSFORM_O_D(d, BOOST_PP_TUPLE_ELEM(3, 0, odr), BOOST_PP_TUPLE_ELEM(3, 1, odr), BOOST_PP_TUPLE_ELEM(3, 2, odr), elem)
-# else
-#    define BOOST_PP_LIST_TRANSFORM_O(d, odr, elem) BOOST_PP_LIST_TRANSFORM_O_I(d, BOOST_PP_TUPLE_REM_3 odr, elem)
-#    define BOOST_PP_LIST_TRANSFORM_O_I(d, im, elem) BOOST_PP_LIST_TRANSFORM_O_D(d, im, elem)
-# endif
-#
-# define BOOST_PP_LIST_TRANSFORM_O_D(d, op, data, res, elem) (op, data, (op(d, data, elem), res))
-#
-# /* BOOST_PP_LIST_TRANSFORM_D */
-#
-# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
-#    define BOOST_PP_LIST_TRANSFORM_D(d, op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list))
-# else
-#    define BOOST_PP_LIST_TRANSFORM_D(d, op, data, list) BOOST_PP_LIST_TRANSFORM_D_I(d, op, data, list)
-#    define BOOST_PP_LIST_TRANSFORM_D_I(d, op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list))
-# endif
-#
-# endif

3rdparty/boost/boost/preprocessor/tuple/eat.hpp

@@ -8,7 +8,7 @@
 #  */
 #
 # /* Revised by Paul Mensonides (2002-2011) */
-# /* Revised by Edward Diener (2011) */
+# /* Revised by Edward Diener (2011,2015) */
 #
 # /* See http://www.boost.org for most recent version. */
 #
@@ -38,6 +38,15 @@
 #    endif
 #    define BOOST_PP_TUPLE_EAT_I(size) BOOST_PP_TUPLE_EAT_ ## size
 # endif
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC()
+#     define BOOST_PP_TUPLE_EAT_N(size) BOOST_PP_TUPLE_EAT_N_I(size)
+# else
+#     define BOOST_PP_TUPLE_EAT_N(size) BOOST_PP_TUPLE_EAT_N_OO((size))
+#     define BOOST_PP_TUPLE_EAT_N_OO(par) BOOST_PP_TUPLE_EAT_N_I ## par
+# endif
+# define BOOST_PP_TUPLE_EAT_N_I(size) BOOST_PP_TUPLE_EAT_ ## size
+#
 # define BOOST_PP_TUPLE_EAT_1(e0)
 # define BOOST_PP_TUPLE_EAT_2(e0, e1)
 # define BOOST_PP_TUPLE_EAT_3(e0, e1, e2)

3rdparty/boost/boost/regex/config.hpp

@@ -25,6 +25,7 @@
 #if defined(__BORLANDC__)
 #  include <boost/regex/config/borland.hpp>
 #endif
+#include <boost/version.hpp>
 
 /*****************************************************************************
  *
@@ -41,6 +42,7 @@
 #  include BOOST_REGEX_USER_CONFIG
 
 #  include <boost/config.hpp>
+#  include <boost/predef.h>
 
 #else
    /*
@@ -69,6 +71,13 @@
 #define UNICODE
 #endif
 
+
+/*
+* Define a macro for the namespace that details are placed in, this includes the Boost
+* version number to avoid mismatched header and library versions:
+*/
+#define BOOST_REGEX_DETAIL_NS BOOST_JOIN(re_detail_, BOOST_VERSION)
+
 /*
  * Fix for gcc prior to 3.4: std::ctype<wchar_t> doesn't allow
  * masks to be combined, for example:
@@ -92,7 +101,13 @@
 #if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
 #  define BOOST_REGEX_NO_EXTERNAL_TEMPLATES
 #endif
-/*
+ /*
+ * Oracle compiler in C++11 mode doesn't like external templates for some reason:
+ */
+#ifdef __SUNPRO_CC
+#  define BOOST_REGEX_NO_EXTERNAL_TEMPLATES
+#endif
+ /*
  * Shared regex lib will crash without this, frankly it looks a lot like a gcc bug:
  */
 #if defined(__MINGW32__)
@@ -133,8 +148,14 @@
 
 /* disable our own file-iterators and mapfiles if we can't
  * support them: */
-#if !defined(BOOST_HAS_DIRENT_H) && !(defined(_WIN32) && !defined(BOOST_REGEX_NO_W32))
+#if defined(_WIN32)
+#  if defined(BOOST_REGEX_NO_W32) || BOOST_PLAT_WINDOWS_STORE
 #    define BOOST_REGEX_NO_FILEITER
+#  endif
+#else // defined(_WIN32)
+#  if !defined(BOOST_HAS_DIRENT_H)
+#    define BOOST_REGEX_NO_FILEITER
+#  endif
 #endif
 
 /* backwards compatibitity: */
@@ -163,10 +184,20 @@
  * with MSVC and the /Zc:wchar_t option we place some extra unsigned short versions
  * of the non-inline functions in the library, so that users can still link to the lib,
  * irrespective of whether their own code is built with /Zc:wchar_t.
- * Note that this does NOT WORK with VC10 when the C++ locale is in effect as
+ * Note that this does NOT WORK with VC10 and VC14 when the C++ locale is in effect as
  * the locale's <unsigned short> facets simply do not compile in that case.
+ * As we default to the C++ locale when compiling for the windows runtime we
+ * skip in this case aswell.
  */
-#if defined(__cplusplus) && (defined(BOOST_MSVC) || defined(__ICL)) && !defined(BOOST_NO_INTRINSIC_WCHAR_T) && defined(BOOST_WINDOWS) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) && !defined(BOOST_RWSTD_VER) && ((_MSC_VER < 1600) || !defined(BOOST_REGEX_USE_CPP_LOCALE))
+#if defined(__cplusplus) && \
+      (defined(BOOST_MSVC) || defined(__ICL)) && \
+      !defined(BOOST_NO_INTRINSIC_WCHAR_T) && \
+      defined(BOOST_WINDOWS) && \
+      !defined(__SGI_STL_PORT) && \
+      !defined(_STLPORT_VERSION) && \
+      !defined(BOOST_RWSTD_VER) && \
+      ((_MSC_VER < 1600) || !defined(BOOST_REGEX_USE_CPP_LOCALE)) && \
+      !BOOST_PLAT_WINDOWS_RUNTIME
 #  define BOOST_REGEX_HAS_OTHER_WCHAR_T
 #  ifdef BOOST_MSVC
 #     pragma warning(push)
@@ -264,8 +295,19 @@
 #  define BOOST_REGEX_USE_C_LOCALE
 #endif
 
+/* use C++ locale when targeting windows store */
+#if BOOST_PLAT_WINDOWS_RUNTIME
+#  define BOOST_REGEX_USE_CPP_LOCALE
+#  define BOOST_REGEX_NO_WIN32_LOCALE
+#endif
+
 /* Win32 defaults to native Win32 locale: */
-#if defined(_WIN32) && !defined(BOOST_REGEX_USE_WIN32_LOCALE) && !defined(BOOST_REGEX_USE_C_LOCALE) && !defined(BOOST_REGEX_USE_CPP_LOCALE) && !defined(BOOST_REGEX_NO_W32)
+#if defined(_WIN32) && \
+    !defined(BOOST_REGEX_USE_WIN32_LOCALE) && \
+    !defined(BOOST_REGEX_USE_C_LOCALE) && \
+    !defined(BOOST_REGEX_USE_CPP_LOCALE) && \
+    !defined(BOOST_REGEX_NO_W32) && \
+    !defined(BOOST_REGEX_NO_WIN32_LOCALE)
 #  define BOOST_REGEX_USE_WIN32_LOCALE
 #endif
 /* otherwise use C++ locale if supported: */
@@ -334,7 +376,7 @@ if(0 == (x))\
 #if defined(__cplusplus) && defined(BOOST_REGEX_HAS_MS_STACK_GUARD)
 
 namespace boost{
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 BOOST_REGEX_DECL void BOOST_REGEX_CALL reset_stack_guard_page();
 
@@ -387,7 +429,7 @@ BOOST_REGEX_DECL void BOOST_REGEX_CALL reset_stack_guard_page();
  ****************************************************************************/
 
 #if defined(__cplusplus) && defined(BOOST_REGEX_NON_RECURSIVE)
-namespace boost{ namespace re_detail{
+namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
 
 BOOST_REGEX_DECL void* BOOST_REGEX_CALL get_mem_block();
 BOOST_REGEX_DECL void BOOST_REGEX_CALL put_mem_block(void*);

3rdparty/boost/boost/regex/icu.hpp

@@ -34,7 +34,7 @@
 
 namespace boost{
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 // 
 // Implementation details:
@@ -108,18 +108,18 @@ public:
    struct boost_extensions_tag{};
 
    icu_regex_traits()
-      : m_pimpl(re_detail::get_icu_regex_traits_implementation(U_NAMESPACE_QUALIFIER Locale()))
+      : m_pimpl(BOOST_REGEX_DETAIL_NS::get_icu_regex_traits_implementation(U_NAMESPACE_QUALIFIER Locale()))
    {
    }
    static size_type length(const char_type* p);
 
    ::boost::regex_constants::syntax_type syntax_type(char_type c)const
    {
-      return ((c < 0x7f) && (c > 0)) ? re_detail::get_default_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
+      return ((c < 0x7f) && (c > 0)) ? BOOST_REGEX_DETAIL_NS::get_default_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
    }
    ::boost::regex_constants::escape_syntax_type escape_syntax_type(char_type c) const
    {
-      return ((c < 0x7f) && (c > 0)) ? re_detail::get_default_escape_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
+      return ((c < 0x7f) && (c > 0)) ? BOOST_REGEX_DETAIL_NS::get_default_escape_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
    }
    char_type translate(char_type c) const
    {
@@ -154,7 +154,7 @@ public:
    bool isctype(char_type c, char_class_type f) const;
    int toi(const char_type*& p1, const char_type* p2, int radix)const
    {
-      return re_detail::global_toi(p1, p2, radix, *this);
+      return BOOST_REGEX_DETAIL_NS::global_toi(p1, p2, radix, *this);
    }
    int value(char_type c, int radix)const
    {
@@ -163,7 +163,7 @@ public:
    locale_type imbue(locale_type l)
    {
       locale_type result(m_pimpl->getloc());
-      m_pimpl = re_detail::get_icu_regex_traits_implementation(l);
+      m_pimpl = BOOST_REGEX_DETAIL_NS::get_icu_regex_traits_implementation(l);
       return result;
    }
    locale_type getloc()const
@@ -172,7 +172,7 @@ public:
    }
    std::string error_string(::boost::regex_constants::error_type n) const
    {
-      return re_detail::get_default_error_string(n);
+      return BOOST_REGEX_DETAIL_NS::get_default_error_string(n);
    }
 private:
    icu_regex_traits(const icu_regex_traits&);
@@ -208,7 +208,7 @@ private:
 
    static char_class_type lookup_icu_mask(const ::UChar32* p1, const ::UChar32* p2);
 
-   boost::shared_ptr< ::boost::re_detail::icu_regex_traits_implementation> m_pimpl;
+   boost::shared_ptr< ::boost::BOOST_REGEX_DETAIL_NS::icu_regex_traits_implementation> m_pimpl;
 };
 
 } // namespace boost
@@ -241,7 +241,7 @@ typedef match_results<const ::UChar*> u16match;
 //
 // Construction of 32-bit regex types from UTF-8 and UTF-16 primitives:
 //
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 #if !defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(__IBMCPP__)
 template <class InputIterator>
@@ -341,18 +341,18 @@ inline u32regex make_u32regex(InputIterator i,
                               InputIterator j, 
                               boost::regex_constants::syntax_option_type opt)
 {
-   return re_detail::do_make_u32regex(i, j, opt, static_cast<boost::mpl::int_<sizeof(*i)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_make_u32regex(i, j, opt, static_cast<boost::mpl::int_<sizeof(*i)> const*>(0));
 }
 //
 // construction from UTF-8 nul-terminated strings:
 //
 inline u32regex make_u32regex(const char* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
 {
-   return re_detail::do_make_u32regex(p, p + std::strlen(p), opt, static_cast<boost::mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::strlen(p), opt, static_cast<boost::mpl::int_<1> const*>(0));
 }
 inline u32regex make_u32regex(const unsigned char* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
 {
-   return re_detail::do_make_u32regex(p, p + std::strlen(reinterpret_cast<const char*>(p)), opt, static_cast<boost::mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::strlen(reinterpret_cast<const char*>(p)), opt, static_cast<boost::mpl::int_<1> const*>(0));
 }
 //
 // construction from UTF-16 nul-terminated strings:
@@ -360,13 +360,13 @@ inline u32regex make_u32regex(const unsigned char* p, boost::regex_constants::sy
 #ifndef BOOST_NO_WREGEX
 inline u32regex make_u32regex(const wchar_t* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
 {
-   return re_detail::do_make_u32regex(p, p + std::wcslen(p), opt, static_cast<boost::mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::wcslen(p), opt, static_cast<boost::mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
 inline u32regex make_u32regex(const UChar* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
 {
-   return re_detail::do_make_u32regex(p, p + u_strlen(p), opt, static_cast<boost::mpl::int_<2> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + u_strlen(p), opt, static_cast<boost::mpl::int_<2> const*>(0));
 }
 #endif
 //
@@ -375,20 +375,20 @@ inline u32regex make_u32regex(const UChar* p, boost::regex_constants::syntax_opt
 template<class C, class T, class A>
 inline u32regex make_u32regex(const std::basic_string<C, T, A>& s, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
 {
-   return re_detail::do_make_u32regex(s.begin(), s.end(), opt, static_cast<boost::mpl::int_<sizeof(C)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_make_u32regex(s.begin(), s.end(), opt, static_cast<boost::mpl::int_<sizeof(C)> const*>(0));
 }
 //
 // Construction from ICU string type:
 //
 inline u32regex make_u32regex(const U_NAMESPACE_QUALIFIER UnicodeString& s, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
 {
-   return re_detail::do_make_u32regex(s.getBuffer(), s.getBuffer() + s.length(), opt, static_cast<boost::mpl::int_<2> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_make_u32regex(s.getBuffer(), s.getBuffer() + s.length(), opt, static_cast<boost::mpl::int_<2> const*>(0));
 }
 
 //
 // regex_match overloads that widen the character type as appropriate:
 //
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 template<class MR1, class MR2>
 void copy_results(MR1& out, MR2 const& in)
 {
@@ -446,7 +446,7 @@ bool do_regex_match(BidiIterator first, BidiIterator last,
    if(result) copy_results(m, what);
    return result;
 }
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 
 template <class BidiIterator, class Allocator>
 inline bool u32regex_match(BidiIterator first, BidiIterator last, 
@@ -454,14 +454,14 @@ inline bool u32regex_match(BidiIterator first, BidiIterator last,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_match(first, last, m, e, flags, static_cast<mpl::int_<sizeof(*first)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<mpl::int_<sizeof(*first)> const*>(0));
 }
 inline bool u32regex_match(const UChar* p, 
                  match_results<const UChar*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
 }
 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_match(const wchar_t* p, 
@@ -469,7 +469,7 @@ inline bool u32regex_match(const wchar_t* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
 inline bool u32regex_match(const char* p, 
@@ -477,21 +477,21 @@ inline bool u32regex_match(const char* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
 }
 inline bool u32regex_match(const unsigned char* p, 
                  match_results<const unsigned char*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
 }
 inline bool u32regex_match(const std::string& s, 
                         match_results<std::string::const_iterator>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<1> const*>(0));
 }
 #ifndef BOOST_NO_STD_WSTRING
 inline bool u32regex_match(const std::wstring& s, 
@@ -499,7 +499,7 @@ inline bool u32regex_match(const std::wstring& s,
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
 inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
@@ -507,7 +507,7 @@ inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 //
 // regex_match overloads that do not return what matched:
@@ -518,14 +518,14 @@ inline bool u32regex_match(BidiIterator first, BidiIterator last,
                  match_flag_type flags = match_default)
 {
    match_results<BidiIterator> m;
-   return re_detail::do_regex_match(first, last, m, e, flags, static_cast<mpl::int_<sizeof(*first)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<mpl::int_<sizeof(*first)> const*>(0));
 }
 inline bool u32regex_match(const UChar* p, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    match_results<const UChar*> m;
-   return re_detail::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
 }
 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_match(const wchar_t* p, 
@@ -533,7 +533,7 @@ inline bool u32regex_match(const wchar_t* p,
                  match_flag_type flags = match_default)
 {
    match_results<const wchar_t*> m;
-   return re_detail::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
 inline bool u32regex_match(const char* p, 
@@ -541,21 +541,21 @@ inline bool u32regex_match(const char* p,
                  match_flag_type flags = match_default)
 {
    match_results<const char*> m;
-   return re_detail::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
 }
 inline bool u32regex_match(const unsigned char* p, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    match_results<const unsigned char*> m;
-   return re_detail::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
 }
 inline bool u32regex_match(const std::string& s, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
    match_results<std::string::const_iterator> m;
-   return re_detail::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<1> const*>(0));
 }
 #ifndef BOOST_NO_STD_WSTRING
 inline bool u32regex_match(const std::wstring& s, 
@@ -563,7 +563,7 @@ inline bool u32regex_match(const std::wstring& s,
                         match_flag_type flags = match_default)
 {
    match_results<std::wstring::const_iterator> m;
-   return re_detail::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
 inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
@@ -571,13 +571,13 @@ inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
                         match_flag_type flags = match_default)
 {
    match_results<const UChar*> m;
-   return re_detail::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 
 //
 // regex_search overloads that widen the character type as appropriate:
 //
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 template <class BidiIterator, class Allocator>
 inline bool do_regex_search(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
@@ -630,7 +630,7 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_search(first, last, m, e, flags, first, static_cast<mpl::int_<sizeof(*first)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<mpl::int_<sizeof(*first)> const*>(0));
 }
 template <class BidiIterator, class Allocator>
 inline bool u32regex_search(BidiIterator first, BidiIterator last, 
@@ -639,14 +639,14 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
                  match_flag_type flags,
                  BidiIterator base)
 {
-   return re_detail::do_regex_search(first, last, m, e, flags, base, static_cast<mpl::int_<sizeof(*first)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, base, static_cast<mpl::int_<sizeof(*first)> const*>(0));
 }
 inline bool u32regex_search(const UChar* p, 
                  match_results<const UChar*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
 }
 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_search(const wchar_t* p, 
@@ -654,7 +654,7 @@ inline bool u32regex_search(const wchar_t* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
 inline bool u32regex_search(const char* p, 
@@ -662,21 +662,21 @@ inline bool u32regex_search(const char* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
 }
 inline bool u32regex_search(const unsigned char* p, 
                  match_results<const unsigned char*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
 }
 inline bool u32regex_search(const std::string& s, 
                         match_results<std::string::const_iterator>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<1> const*>(0));
 }
 #ifndef BOOST_NO_STD_WSTRING
 inline bool u32regex_search(const std::wstring& s, 
@@ -684,7 +684,7 @@ inline bool u32regex_search(const std::wstring& s,
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
 inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
@@ -692,7 +692,7 @@ inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
-   return re_detail::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 template <class BidiIterator>
 inline bool u32regex_search(BidiIterator first, BidiIterator last, 
@@ -700,14 +700,14 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
                  match_flag_type flags = match_default)
 {
    match_results<BidiIterator> m;
-   return re_detail::do_regex_search(first, last, m, e, flags, first, static_cast<mpl::int_<sizeof(*first)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<mpl::int_<sizeof(*first)> const*>(0));
 }
 inline bool u32regex_search(const UChar* p, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    match_results<const UChar*> m;
-   return re_detail::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
 }
 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_search(const wchar_t* p, 
@@ -715,7 +715,7 @@ inline bool u32regex_search(const wchar_t* p,
                  match_flag_type flags = match_default)
 {
    match_results<const wchar_t*> m;
-   return re_detail::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
 inline bool u32regex_search(const char* p, 
@@ -723,21 +723,21 @@ inline bool u32regex_search(const char* p,
                  match_flag_type flags = match_default)
 {
    match_results<const char*> m;
-   return re_detail::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
 }
 inline bool u32regex_search(const unsigned char* p, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    match_results<const unsigned char*> m;
-   return re_detail::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
 }
 inline bool u32regex_search(const std::string& s, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
    match_results<std::string::const_iterator> m;
-   return re_detail::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<1> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<1> const*>(0));
 }
 #ifndef BOOST_NO_STD_WSTRING
 inline bool u32regex_search(const std::wstring& s, 
@@ -745,7 +745,7 @@ inline bool u32regex_search(const std::wstring& s,
                         match_flag_type flags = match_default)
 {
    match_results<std::wstring::const_iterator> m;
-   return re_detail::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
 inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
@@ -753,13 +753,13 @@ inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
                         match_flag_type flags = match_default)
 {
    match_results<const UChar*> m;
-   return re_detail::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
+   return BOOST_REGEX_DETAIL_NS::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 
 //
 // overloads for regex_replace with utf-8 and utf-16 data types:
 //
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 template <class I>
 inline std::pair< boost::u8_to_u32_iterator<I>, boost::u8_to_u32_iterator<I> >
    make_utf32_seq(I i, I j, mpl::int_<1> const*)
@@ -838,7 +838,7 @@ OutputIterator do_regex_replace(OutputIterator out,
    if(i == j)
    {
       if(!(flags & regex_constants::format_no_copy))
-         out = re_detail::copy(in.first, in.second, out);
+         out = BOOST_REGEX_DETAIL_NS::copy(in.first, in.second, out);
    }
    else
    {
@@ -846,18 +846,18 @@ OutputIterator do_regex_replace(OutputIterator out,
       while(i != j)
       {
          if(!(flags & regex_constants::format_no_copy))
-            out = re_detail::copy(i->prefix().first, i->prefix().second, out); 
+            out = BOOST_REGEX_DETAIL_NS::copy(i->prefix().first, i->prefix().second, out); 
          if(f.size())
-            out = ::boost::re_detail::regex_format_imp(out, *i, &*f.begin(), &*f.begin() + f.size(), flags, e.get_traits());
+            out = ::boost::BOOST_REGEX_DETAIL_NS::regex_format_imp(out, *i, &*f.begin(), &*f.begin() + f.size(), flags, e.get_traits());
          else
-            out = ::boost::re_detail::regex_format_imp(out, *i, static_cast<UChar32 const*>(0), static_cast<UChar32 const*>(0), flags, e.get_traits());
+            out = ::boost::BOOST_REGEX_DETAIL_NS::regex_format_imp(out, *i, static_cast<UChar32 const*>(0), static_cast<UChar32 const*>(0), flags, e.get_traits());
          last_m = (*i)[0].second;
          if(flags & regex_constants::format_first_only)
             break;
          ++i;
       }
       if(!(flags & regex_constants::format_no_copy))
-         out = re_detail::copy(last_m, in.second, out);
+         out = BOOST_REGEX_DETAIL_NS::copy(last_m, in.second, out);
    }
    return out;
 }
@@ -876,7 +876,7 @@ inline BaseIterator extract_output_base(const utf16_output_iterator<BaseIterator
 {
    return b.base();
 }
-}  // re_detail
+}  // BOOST_REGEX_DETAIL_NS
 
 template <class OutputIterator, class BidirectionalIterator, class charT>
 inline OutputIterator u32regex_replace(OutputIterator out,
@@ -886,13 +886,13 @@ inline OutputIterator u32regex_replace(OutputIterator out,
                          const charT* fmt, 
                          match_flag_type flags = match_default)
 {
-   return re_detail::extract_output_base
+   return BOOST_REGEX_DETAIL_NS::extract_output_base
     (
-      re_detail::do_regex_replace(
-         re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
-         re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
+      BOOST_REGEX_DETAIL_NS::do_regex_replace(
+         BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
+         BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
          e,
-         re_detail::make_utf32_seq(fmt, static_cast<mpl::int_<sizeof(*fmt)> const*>(0)),
+         BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt, static_cast<mpl::int_<sizeof(*fmt)> const*>(0)),
          flags)
       );
 }
@@ -905,13 +905,13 @@ inline OutputIterator u32regex_replace(OutputIterator out,
                          const std::basic_string<charT>& fmt,
                          match_flag_type flags = match_default)
 {
-   return re_detail::extract_output_base
+   return BOOST_REGEX_DETAIL_NS::extract_output_base
     (
-      re_detail::do_regex_replace(
-         re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
-         re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
+      BOOST_REGEX_DETAIL_NS::do_regex_replace(
+         BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
+         BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
          e,
-         re_detail::make_utf32_seq(fmt.begin(), fmt.end(), static_cast<mpl::int_<sizeof(charT)> const*>(0)),
+         BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.begin(), fmt.end(), static_cast<mpl::int_<sizeof(charT)> const*>(0)),
          flags)
       );
 }
@@ -924,13 +924,13 @@ inline OutputIterator u32regex_replace(OutputIterator out,
                          const U_NAMESPACE_QUALIFIER UnicodeString& fmt,
                          match_flag_type flags = match_default)
 {
-   return re_detail::extract_output_base
+   return BOOST_REGEX_DETAIL_NS::extract_output_base
    (
-      re_detail::do_regex_replace(
-         re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
-         re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
+      BOOST_REGEX_DETAIL_NS::do_regex_replace(
+         BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
+         BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
          e,
-         re_detail::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),
+         BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),
          flags)
       );
 }
@@ -942,7 +942,7 @@ std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
                          match_flag_type flags = match_default)
 {
    std::basic_string<charT> result;
-   re_detail::string_out_iterator<std::basic_string<charT> > i(result);
+   BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<charT> > i(result);
    u32regex_replace(i, s.begin(), s.end(), e, fmt, flags);
    return result;
 }
@@ -954,12 +954,12 @@ std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
                          match_flag_type flags = match_default)
 {
    std::basic_string<charT> result;
-   re_detail::string_out_iterator<std::basic_string<charT> > i(result);
+   BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<charT> > i(result);
    u32regex_replace(i, s.begin(), s.end(), e, fmt.c_str(), flags);
    return result;
 }
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 class unicode_string_out_iterator
 {
@@ -989,7 +989,7 @@ inline U_NAMESPACE_QUALIFIER UnicodeString u32regex_replace(const U_NAMESPACE_QU
                          match_flag_type flags = match_default)
 {
    U_NAMESPACE_QUALIFIER UnicodeString result;
-   re_detail::unicode_string_out_iterator i(result);
+   BOOST_REGEX_DETAIL_NS::unicode_string_out_iterator i(result);
    u32regex_replace(i, s.getBuffer(), s.getBuffer()+s.length(), e, fmt, flags);
    return result;
 }
@@ -1000,12 +1000,12 @@ inline U_NAMESPACE_QUALIFIER UnicodeString u32regex_replace(const U_NAMESPACE_QU
                          match_flag_type flags = match_default)
 {
    U_NAMESPACE_QUALIFIER UnicodeString result;
-   re_detail::unicode_string_out_iterator i(result);
-   re_detail::do_regex_replace(
-         re_detail::make_utf32_out(i, static_cast<mpl::int_<2> const*>(0)),
-         re_detail::make_utf32_seq(s.getBuffer(), s.getBuffer()+s.length(), static_cast<mpl::int_<2> const*>(0)),
+   BOOST_REGEX_DETAIL_NS::unicode_string_out_iterator i(result);
+   BOOST_REGEX_DETAIL_NS::do_regex_replace(
+         BOOST_REGEX_DETAIL_NS::make_utf32_out(i, static_cast<mpl::int_<2> const*>(0)),
+         BOOST_REGEX_DETAIL_NS::make_utf32_seq(s.getBuffer(), s.getBuffer()+s.length(), static_cast<mpl::int_<2> const*>(0)),
          e,
-         re_detail::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),
+         BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),
          flags);
    return result;
 }

3rdparty/boost/boost/regex/pattern_except.hpp

@@ -63,7 +63,7 @@ private:
 typedef regex_error bad_pattern;
 typedef regex_error bad_expression;
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 BOOST_REGEX_DECL void BOOST_REGEX_CALL raise_runtime_error(const std::runtime_error& ex);
 
@@ -72,7 +72,7 @@ void raise_error(const traits& t, regex_constants::error_type code)
 {
    (void)t;  // warning suppression
    std::runtime_error e(t.error_string(code));
-   ::boost::re_detail::raise_runtime_error(e);
+   ::boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(e);
 }
 
 }

3rdparty/boost/boost/regex/v4/basic_regex.hpp

@@ -42,7 +42,7 @@ namespace boost{
 #endif
 #endif
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 //
 // forward declaration, we will need this one later:
@@ -164,9 +164,9 @@ struct regex_data : public named_subexpressions
 
    regex_data(const ::boost::shared_ptr<
       ::boost::regex_traits_wrapper<traits> >& t) 
-      : m_ptraits(t), m_expression(0), m_expression_len(0) {}
+      : m_ptraits(t), m_expression(0), m_expression_len(0), m_disable_match_any(false) {}
    regex_data() 
-      : m_ptraits(new ::boost::regex_traits_wrapper<traits>()), m_expression(0), m_expression_len(0) {}
+      : m_ptraits(new ::boost::regex_traits_wrapper<traits>()), m_expression(0), m_expression_len(0), m_disable_match_any(false) {}
 
    ::boost::shared_ptr<
       ::boost::regex_traits_wrapper<traits>
@@ -176,16 +176,17 @@ struct regex_data : public named_subexpressions
    const charT*                m_expression;              // the original expression
    std::ptrdiff_t              m_expression_len;          // the length of the original expression
    size_type                   m_mark_count;              // the number of marked sub-expressions
-   re_detail::re_syntax_base*  m_first_state;             // the first state of the machine
+   BOOST_REGEX_DETAIL_NS::re_syntax_base*  m_first_state;             // the first state of the machine
    unsigned                    m_restart_type;            // search optimisation type
    unsigned char               m_startmap[1 << CHAR_BIT]; // which characters can start a match
    unsigned int                m_can_be_null;             // whether we can match a null string
-   re_detail::raw_storage      m_data;                    // the buffer in which our states are constructed
+   BOOST_REGEX_DETAIL_NS::raw_storage      m_data;                    // the buffer in which our states are constructed
    typename traits::char_class_type    m_word_mask;       // mask used to determine if a character is a word character
    std::vector<
       std::pair<
       std::size_t, std::size_t> > m_subs;                 // Position of sub-expressions within the *string*.
    bool                        m_has_recursions;          // whether we have recursive expressions;
+   bool                        m_disable_match_any;       // when set we need to disable the match_any flag as it causes different/buggy behaviour.
 };
 //
 // class basic_regex_implementation
@@ -266,7 +267,7 @@ public:
    {
       return this->m_mark_count - 1;
    }
-   const re_detail::re_syntax_base* get_first_state()const
+   const BOOST_REGEX_DETAIL_NS::re_syntax_base* get_first_state()const
    {
       return this->m_first_state;
    }
@@ -293,7 +294,7 @@ public:
    }
 };
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 //
 // class basic_regex:
 // represents the compiled
@@ -597,7 +598,7 @@ public:
    //
    // private access methods:
    //
-   const re_detail::re_syntax_base* get_first_state()const
+   const BOOST_REGEX_DETAIL_NS::re_syntax_base* get_first_state()const
    {
       BOOST_ASSERT(0 != m_pimpl.get());
       return m_pimpl->get_first_state();
@@ -622,18 +623,18 @@ public:
       BOOST_ASSERT(0 != m_pimpl.get());
       return m_pimpl->can_be_null();
    }
-   const re_detail::regex_data<charT, traits>& get_data()const
+   const BOOST_REGEX_DETAIL_NS::regex_data<charT, traits>& get_data()const
    {
       BOOST_ASSERT(0 != m_pimpl.get());
       return m_pimpl->get_data();
    }
-   boost::shared_ptr<re_detail::named_subexpressions > get_named_subs()const
+   boost::shared_ptr<BOOST_REGEX_DETAIL_NS::named_subexpressions > get_named_subs()const
    {
       return m_pimpl;
    }
 
 private:
-   shared_ptr<re_detail::basic_regex_implementation<charT, traits> > m_pimpl;
+   shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > m_pimpl;
 };
 
 //
@@ -647,14 +648,14 @@ basic_regex<charT, traits>& basic_regex<charT, traits>::do_assign(const charT* p
                         const charT* p2,
                         flag_type f)
 {
-   shared_ptr<re_detail::basic_regex_implementation<charT, traits> > temp;
+   shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > temp;
    if(!m_pimpl.get())
    {
-      temp = shared_ptr<re_detail::basic_regex_implementation<charT, traits> >(new re_detail::basic_regex_implementation<charT, traits>());
+      temp = shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>());
    }
    else
    {
-      temp = shared_ptr<re_detail::basic_regex_implementation<charT, traits> >(new re_detail::basic_regex_implementation<charT, traits>(m_pimpl->m_ptraits));
+      temp = shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>(m_pimpl->m_ptraits));
    }
    temp->assign(p1, p2, f);
    temp.swap(m_pimpl);
@@ -664,7 +665,7 @@ basic_regex<charT, traits>& basic_regex<charT, traits>::do_assign(const charT* p
 template <class charT, class traits>
 typename basic_regex<charT, traits>::locale_type BOOST_REGEX_CALL basic_regex<charT, traits>::imbue(locale_type l)
 { 
-   shared_ptr<re_detail::basic_regex_implementation<charT, traits> > temp(new re_detail::basic_regex_implementation<charT, traits>());
+   shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > temp(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>());
    locale_type result = temp->imbue(l);
    temp.swap(m_pimpl);
    return result;

3rdparty/boost/boost/regex/v4/basic_regex_creator.hpp

@@ -38,7 +38,7 @@
 
 namespace boost{
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 template <class charT>
 struct digraph : public std::pair<charT, charT>
@@ -371,9 +371,9 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set(
    //
    // fill in the basics:
    //
-   result->csingles = static_cast<unsigned int>(::boost::re_detail::distance(char_set.singles_begin(), char_set.singles_end()));
-   result->cranges = static_cast<unsigned int>(::boost::re_detail::distance(char_set.ranges_begin(), char_set.ranges_end())) / 2;
-   result->cequivalents = static_cast<unsigned int>(::boost::re_detail::distance(char_set.equivalents_begin(), char_set.equivalents_end()));
+   result->csingles = static_cast<unsigned int>(::boost::BOOST_REGEX_DETAIL_NS::distance(char_set.singles_begin(), char_set.singles_end()));
+   result->cranges = static_cast<unsigned int>(::boost::BOOST_REGEX_DETAIL_NS::distance(char_set.ranges_begin(), char_set.ranges_end())) / 2;
+   result->cequivalents = static_cast<unsigned int>(::boost::BOOST_REGEX_DETAIL_NS::distance(char_set.equivalents_begin(), char_set.equivalents_end()));
    result->cclasses = char_set.classes();
    result->cnclasses = char_set.negated_classes();
    if(flags() & regbase::icase)
@@ -463,10 +463,10 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set(
          return 0;
       }
       charT* p = static_cast<charT*>(this->m_pdata->m_data.extend(sizeof(charT) * (s1.size() + s2.size() + 2) ) );
-      re_detail::copy(s1.begin(), s1.end(), p);
+      BOOST_REGEX_DETAIL_NS::copy(s1.begin(), s1.end(), p);
       p[s1.size()] = charT(0);
       p += s1.size() + 1;
-      re_detail::copy(s2.begin(), s2.end(), p);
+      BOOST_REGEX_DETAIL_NS::copy(s2.begin(), s2.end(), p);
       p[s2.size()] = charT(0);
    }
    //
@@ -487,7 +487,7 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set(
       if(s.empty())
          return 0;  // invalid or unsupported equivalence class
       charT* p = static_cast<charT*>(this->m_pdata->m_data.extend(sizeof(charT) * (s.size()+1) ) );
-      re_detail::copy(s.begin(), s.end(), p);
+      BOOST_REGEX_DETAIL_NS::copy(s.begin(), s.end(), p);
       p[s.size()] = charT(0);
       ++first;
    }
@@ -664,7 +664,7 @@ void basic_regex_creator<charT, traits>::finalize(const charT* p1, const charT*
    m_pdata->m_expression_len = len;
    charT* ps = static_cast<charT*>(m_pdata->m_data.extend(sizeof(charT) * (1 + (p2 - p1))));
    m_pdata->m_expression = ps;
-   re_detail::copy(p1, p2, ps);
+   BOOST_REGEX_DETAIL_NS::copy(p1, p2, ps);
    ps[p2 - p1] = 0;
    // fill in our other data...
    // successful parsing implies a zero status:
@@ -1149,6 +1149,7 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
          set_all_masks(l_map, mask);
          return;
       }
+      case syntax_element_accept:
       case syntax_element_match:
       {
          // must be null, any character can match:
@@ -1335,6 +1336,11 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
          state = state->next.p;
          break;
 
+      case syntax_element_commit:
+         set_all_masks(l_map, mask);
+         // Continue scanning so we can figure out whether we can be null:
+         state = state->next.p;
+         break;
       case syntax_element_startmark:
          // need to handle independent subs as a special case:
          if(static_cast<re_brace*>(state)->index == -3)
@@ -1456,15 +1462,15 @@ syntax_element_type basic_regex_creator<charT, traits>::get_repeat_type(re_synta
       {
          switch(state->next.p->type)
          {
-         case re_detail::syntax_element_wild:
-            return re_detail::syntax_element_dot_rep;
-         case re_detail::syntax_element_literal:
-            return re_detail::syntax_element_char_rep;
-         case re_detail::syntax_element_set:
-            return re_detail::syntax_element_short_set_rep;
-         case re_detail::syntax_element_long_set:
-            if(static_cast<re_detail::re_set_long<m_type>*>(state->next.p)->singleton)
-               return re_detail::syntax_element_long_set_rep;
+         case BOOST_REGEX_DETAIL_NS::syntax_element_wild:
+            return BOOST_REGEX_DETAIL_NS::syntax_element_dot_rep;
+         case BOOST_REGEX_DETAIL_NS::syntax_element_literal:
+            return BOOST_REGEX_DETAIL_NS::syntax_element_char_rep;
+         case BOOST_REGEX_DETAIL_NS::syntax_element_set:
+            return BOOST_REGEX_DETAIL_NS::syntax_element_short_set_rep;
+         case BOOST_REGEX_DETAIL_NS::syntax_element_long_set:
+            if(static_cast<BOOST_REGEX_DETAIL_NS::re_set_long<m_type>*>(state->next.p)->singleton)
+               return BOOST_REGEX_DETAIL_NS::syntax_element_long_set_rep;
             break;
          default:
             break;
@@ -1529,7 +1535,7 @@ void basic_regex_creator<charT, traits>::probe_leading_repeat(re_syntax_base* st
 }
 
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 
 } // namespace boost
 

3rdparty/boost/boost/regex/v4/basic_regex_parser.hpp

@@ -31,7 +31,7 @@
 #endif
 
 namespace boost{
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
@@ -68,6 +68,8 @@ public:
    bool parse_inner_set(basic_char_set<charT, traits>& char_set);
    bool parse_QE();
    bool parse_perl_extension();
+   bool parse_perl_verb();
+   bool match_verb(const char*);
    bool add_emacs_code(bool negate);
    bool unwind_alts(std::ptrdiff_t last_paren_start);
    digraph<charT> get_next_set_literal(basic_char_set<charT, traits>& char_set);
@@ -165,7 +167,7 @@ void basic_regex_parser<charT, traits>::parse(const charT* p1, const charT* p2,
    // have had an unexpected ')' :
    if(!result)
    {
-      fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_position), "Found a closing ) with no corresponding openening parenthesis.");
+      fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_position), "Found a closing ) with no corresponding openening parenthesis.");
       return;
    }
    // if an error has been set then give up now:
@@ -421,6 +423,8 @@ bool basic_regex_parser<charT, traits>::parse_open_paren()
    {
       if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_question)
          return parse_perl_extension();
+      if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_star)
+         return parse_perl_verb();
    }
    //
    // update our mark count, and append the required state:
@@ -489,7 +493,7 @@ bool basic_regex_parser<charT, traits>::parse_open_paren()
    //
    if(m_position == m_end)
    {
-      this->fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_end));
+      this->fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_end));
       return false;
    }
    BOOST_ASSERT(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark);
@@ -924,9 +928,9 @@ bool basic_regex_parser<charT, traits>::parse_match_any()
    static_cast<re_dot*>(
       this->append_state(syntax_element_wild, sizeof(re_dot))
       )->mask = static_cast<unsigned char>(this->flags() & regbase::no_mod_s 
-      ? re_detail::force_not_newline 
+      ? BOOST_REGEX_DETAIL_NS::force_not_newline 
          : this->flags() & regbase::mod_s ?
-            re_detail::force_newline : re_detail::dont_care);
+            BOOST_REGEX_DETAIL_NS::force_newline : BOOST_REGEX_DETAIL_NS::dont_care);
    return true;
 }
 
@@ -963,7 +967,7 @@ bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_
    }
    if(0 == this->m_last_state)
    {
-      fail(regex_constants::error_badrepeat, ::boost::re_detail::distance(m_base, m_position), "Nothing to repeat.");
+      fail(regex_constants::error_badrepeat, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_position), "Nothing to repeat.");
       return false;
    }
    if(this->m_last_state->type == syntax_element_endmark)
@@ -1235,7 +1239,7 @@ bool basic_regex_parser<charT, traits>::parse_alt()
    //
    // we need to append a trailing jump: 
    //
-   re_syntax_base* pj = this->append_state(re_detail::syntax_element_jump, sizeof(re_jump));
+   re_syntax_base* pj = this->append_state(BOOST_REGEX_DETAIL_NS::syntax_element_jump, sizeof(re_jump));
    std::ptrdiff_t jump_offset = this->getoffset(pj);
    //
    // now insert the alternative:
@@ -1784,7 +1788,7 @@ charT basic_regex_parser<charT, traits>::unescape_character()
       {
       // an octal escape sequence, the first character must be a zero
       // followed by up to 3 octal digits:
-      std::ptrdiff_t len = (std::min)(::boost::re_detail::distance(m_position, m_end), static_cast<std::ptrdiff_t>(4));
+      std::ptrdiff_t len = (std::min)(::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end), static_cast<std::ptrdiff_t>(4));
       const charT* bp = m_position;
       int val = this->m_traits.toi(bp, bp + 1, 8);
       if(val != 0)
@@ -2521,7 +2525,7 @@ option_group_jump:
       // Rewind to start of (? sequence:
       --m_position;
       while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
-      this->fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_end));
+      this->fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_end));
       return false;
    }
    BOOST_ASSERT(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark);
@@ -2652,6 +2656,194 @@ option_group_jump:
    return true;
 }
 
+template <class charT, class traits>
+bool basic_regex_parser<charT, traits>::match_verb(const char* verb)
+{
+   while(*verb)
+   {
+      if(static_cast<charT>(*verb) != *m_position)
+      {
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(++m_position == m_end)
+      {
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      ++verb;
+   }
+   return true;
+}
+
+template <class charT, class traits>
+bool basic_regex_parser<charT, traits>::parse_perl_verb()
+{
+   if(++m_position == m_end)
+   {
+      // Rewind to start of (* sequence:
+      --m_position;
+      while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+      fail(regex_constants::error_perl_extension, m_position - m_base);
+      return false;
+   }
+   switch(*m_position)
+   {
+   case 'F':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if((this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark) || match_verb("AIL"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         this->append_state(syntax_element_fail);
+         return true;
+      }
+      break;
+   case 'A':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(match_verb("CCEPT"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         this->append_state(syntax_element_accept);
+         return true;
+      }
+      break;
+   case 'C':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(match_verb("OMMIT"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         static_cast<re_commit*>(this->append_state(syntax_element_commit, sizeof(re_commit)))->action = commit_commit;
+         this->m_pdata->m_disable_match_any = true;
+         return true;
+      }
+      break;
+   case 'P':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(match_verb("RUNE"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         static_cast<re_commit*>(this->append_state(syntax_element_commit, sizeof(re_commit)))->action = commit_prune;
+         this->m_pdata->m_disable_match_any = true;
+         return true;
+      }
+      break;
+   case 'S':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(match_verb("KIP"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         static_cast<re_commit*>(this->append_state(syntax_element_commit, sizeof(re_commit)))->action = commit_skip;
+         this->m_pdata->m_disable_match_any = true;
+         return true;
+      }
+      break;
+   case 'T':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(match_verb("HEN"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         this->append_state(syntax_element_then);
+         this->m_pdata->m_disable_match_any = true;
+         return true;
+      }
+      break;
+   }
+   return false;
+}
+
 template <class charT, class traits>
 bool basic_regex_parser<charT, traits>::add_emacs_code(bool negate)
 {
@@ -2862,7 +3054,7 @@ bool basic_regex_parser<charT, traits>::unwind_alts(std::ptrdiff_t last_paren_st
 #pragma warning(pop)
 #endif
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 } // namespace boost
 
 #ifdef BOOST_MSVC

3rdparty/boost/boost/regex/v4/cpp_regex_traits.hpp

@@ -69,7 +69,7 @@ namespace boost{
 template <class charT>
 class cpp_regex_traits;
    
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 //
 // class parser_buf:
@@ -290,7 +290,7 @@ void cpp_regex_traits_char_layer<charT>::init()
       {
          std::string m("Unable to open message catalog: ");
          std::runtime_error err(m + cat_name);
-         boost::re_detail::raise_runtime_error(err);
+         boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err);
       }
    }
    //
@@ -417,6 +417,7 @@ class cpp_regex_traits_implementation : public cpp_regex_traits_char_layer<charT
 public:
    typedef typename cpp_regex_traits<charT>::char_class_type      char_class_type;
    typedef typename std::ctype<charT>::mask                       native_mask_type;
+   typedef typename boost::make_unsigned<native_mask_type>::type  unsigned_native_mask_type;
 #ifndef BOOST_REGEX_BUGGY_CTYPE_FACET
    BOOST_STATIC_CONSTANT(char_class_type, mask_blank = 1u << 24);
    BOOST_STATIC_CONSTANT(char_class_type, mask_word = 1u << 25);
@@ -717,7 +718,7 @@ void cpp_regex_traits_implementation<charT>::init()
       {
          std::string m("Unable to open message catalog: ");
          std::runtime_error err(m + cat_name);
-         boost::re_detail::raise_runtime_error(err);
+         boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err);
       }
    }
    //
@@ -753,19 +754,19 @@ void cpp_regex_traits_implementation<charT>::init()
 #ifndef BOOST_REGEX_BUGGY_CTYPE_FACET
       static const char_class_type masks[16] = 
       {
-         std::ctype<charT>::alnum,
-         std::ctype<charT>::alpha,
-         std::ctype<charT>::cntrl,
-         std::ctype<charT>::digit,
-         std::ctype<charT>::graph,
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::alnum),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::alpha),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::cntrl),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::digit),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::graph),
          cpp_regex_traits_implementation<charT>::mask_horizontal,
-         std::ctype<charT>::lower,
-         std::ctype<charT>::print,
-         std::ctype<charT>::punct,
-         std::ctype<charT>::space,
-         std::ctype<charT>::upper,
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::lower),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::print),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::punct),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::space),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::upper),
          cpp_regex_traits_implementation<charT>::mask_vertical,
-         std::ctype<charT>::xdigit,
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::xdigit),
          cpp_regex_traits_implementation<charT>::mask_blank,
          cpp_regex_traits_implementation<charT>::mask_word,
          cpp_regex_traits_implementation<charT>::mask_unicode,
@@ -773,22 +774,22 @@ void cpp_regex_traits_implementation<charT>::init()
 #else
       static const char_class_type masks[16] = 
       {
-         ::boost::re_detail::char_class_alnum,
-         ::boost::re_detail::char_class_alpha,
-         ::boost::re_detail::char_class_cntrl,
-         ::boost::re_detail::char_class_digit,
-         ::boost::re_detail::char_class_graph,
-         ::boost::re_detail::char_class_horizontal_space,
-         ::boost::re_detail::char_class_lower,
-         ::boost::re_detail::char_class_print,
-         ::boost::re_detail::char_class_punct,
-         ::boost::re_detail::char_class_space,
-         ::boost::re_detail::char_class_upper,
-         ::boost::re_detail::char_class_vertical_space,
-         ::boost::re_detail::char_class_xdigit,
-         ::boost::re_detail::char_class_blank,
-         ::boost::re_detail::char_class_word,
-         ::boost::re_detail::char_class_unicode,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_alpha,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_cntrl,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_digit,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_graph,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_horizontal_space,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_lower,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_print,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_punct,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_space,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_upper,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_vertical_space,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_xdigit,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_blank,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_word,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_unicode,
       };
 #endif
       static const string_type null_string;
@@ -803,7 +804,7 @@ void cpp_regex_traits_implementation<charT>::init()
    //
    // get the collation format used by m_pcollate:
    //
-   m_collate_type = re_detail::find_sort_syntax(this, &m_collate_delim);
+   m_collate_type = BOOST_REGEX_DETAIL_NS::find_sort_syntax(this, &m_collate_delim);
 }
 
 template <class charT>
@@ -814,53 +815,53 @@ typename cpp_regex_traits_implementation<charT>::char_class_type
    static const char_class_type masks[22] = 
    {
       0,
-      std::ctype<char>::alnum, 
-      std::ctype<char>::alpha,
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::alnum),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::alpha),
       cpp_regex_traits_implementation<charT>::mask_blank,
-      std::ctype<char>::cntrl,
-      std::ctype<char>::digit,
-      std::ctype<char>::digit,
-      std::ctype<char>::graph,
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::cntrl),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::digit),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::digit),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::graph),
       cpp_regex_traits_implementation<charT>::mask_horizontal,
-      std::ctype<char>::lower,
-      std::ctype<char>::lower,
-      std::ctype<char>::print,
-      std::ctype<char>::punct,
-      std::ctype<char>::space,
-      std::ctype<char>::space,
-      std::ctype<char>::upper,
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::lower),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::lower),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::print),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::punct),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::space),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::space),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::upper),
       cpp_regex_traits_implementation<charT>::mask_unicode,
-      std::ctype<char>::upper,
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::upper),
       cpp_regex_traits_implementation<charT>::mask_vertical,
-      std::ctype<char>::alnum | cpp_regex_traits_implementation<charT>::mask_word, 
-      std::ctype<char>::alnum | cpp_regex_traits_implementation<charT>::mask_word, 
-      std::ctype<char>::xdigit,
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::alnum) | cpp_regex_traits_implementation<charT>::mask_word, 
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::alnum) | cpp_regex_traits_implementation<charT>::mask_word, 
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::xdigit),
    };
 #else
    static const char_class_type masks[22] = 
    {
       0,
-      ::boost::re_detail::char_class_alnum, 
-      ::boost::re_detail::char_class_alpha,
-      ::boost::re_detail::char_class_blank,
-      ::boost::re_detail::char_class_cntrl,
-      ::boost::re_detail::char_class_digit,
-      ::boost::re_detail::char_class_digit,
-      ::boost::re_detail::char_class_graph,
-      ::boost::re_detail::char_class_horizontal_space,
-      ::boost::re_detail::char_class_lower,
-      ::boost::re_detail::char_class_lower,
-      ::boost::re_detail::char_class_print,
-      ::boost::re_detail::char_class_punct,
-      ::boost::re_detail::char_class_space,
-      ::boost::re_detail::char_class_space,
-      ::boost::re_detail::char_class_upper,
-      ::boost::re_detail::char_class_unicode,
-      ::boost::re_detail::char_class_upper,
-      ::boost::re_detail::char_class_vertical_space,
-      ::boost::re_detail::char_class_alnum | ::boost::re_detail::char_class_word, 
-      ::boost::re_detail::char_class_alnum | ::boost::re_detail::char_class_word, 
-      ::boost::re_detail::char_class_xdigit,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum, 
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_alpha,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_blank,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_cntrl,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_digit,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_digit,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_graph,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_horizontal_space,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_lower,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_lower,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_print,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_punct,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_space,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_space,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_upper,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_unicode,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_upper,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_vertical_space,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum | ::boost::BOOST_REGEX_DETAIL_NS::char_class_word, 
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum | ::boost::BOOST_REGEX_DETAIL_NS::char_class_word, 
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_xdigit,
    };
 #endif
    if(m_custom_class_names.size())
@@ -870,7 +871,7 @@ typename cpp_regex_traits_implementation<charT>::char_class_type
       if(pos != m_custom_class_names.end())
          return pos->second;
    }
-   std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
+   std::size_t state_id = 1 + BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
    BOOST_ASSERT(state_id < sizeof(masks) / sizeof(masks[0]));
    return masks[state_id];
 }
@@ -880,20 +881,20 @@ template <class charT>
 bool cpp_regex_traits_implementation<charT>::isctype(const charT c, char_class_type mask) const
 {
    return
-      ((mask & ::boost::re_detail::char_class_space) && (this->m_pctype->is(std::ctype<charT>::space, c)))
-      || ((mask & ::boost::re_detail::char_class_print) && (this->m_pctype->is(std::ctype<charT>::print, c)))
-      || ((mask & ::boost::re_detail::char_class_cntrl) && (this->m_pctype->is(std::ctype<charT>::cntrl, c)))
-      || ((mask & ::boost::re_detail::char_class_upper) && (this->m_pctype->is(std::ctype<charT>::upper, c)))
-      || ((mask & ::boost::re_detail::char_class_lower) && (this->m_pctype->is(std::ctype<charT>::lower, c)))
-      || ((mask & ::boost::re_detail::char_class_alpha) && (this->m_pctype->is(std::ctype<charT>::alpha, c)))
-      || ((mask & ::boost::re_detail::char_class_digit) && (this->m_pctype->is(std::ctype<charT>::digit, c)))
-      || ((mask & ::boost::re_detail::char_class_punct) && (this->m_pctype->is(std::ctype<charT>::punct, c)))
-      || ((mask & ::boost::re_detail::char_class_xdigit) && (this->m_pctype->is(std::ctype<charT>::xdigit, c)))
-      || ((mask & ::boost::re_detail::char_class_blank) && (this->m_pctype->is(std::ctype<charT>::space, c)) && !::boost::re_detail::is_separator(c))
-      || ((mask & ::boost::re_detail::char_class_word) && (c == '_'))
-      || ((mask & ::boost::re_detail::char_class_unicode) && ::boost::re_detail::is_extended(c))
-      || ((mask & ::boost::re_detail::char_class_vertical_space) && (is_separator(c) || (c == '\v')))
-      || ((mask & ::boost::re_detail::char_class_horizontal_space) && this->m_pctype->is(std::ctype<charT>::space, c) && !(is_separator(c) || (c == '\v')));
+      ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_space) && (this->m_pctype->is(std::ctype<charT>::space, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_print) && (this->m_pctype->is(std::ctype<charT>::print, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_cntrl) && (this->m_pctype->is(std::ctype<charT>::cntrl, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_upper) && (this->m_pctype->is(std::ctype<charT>::upper, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_lower) && (this->m_pctype->is(std::ctype<charT>::lower, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_alpha) && (this->m_pctype->is(std::ctype<charT>::alpha, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_digit) && (this->m_pctype->is(std::ctype<charT>::digit, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_punct) && (this->m_pctype->is(std::ctype<charT>::punct, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_xdigit) && (this->m_pctype->is(std::ctype<charT>::xdigit, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_blank) && (this->m_pctype->is(std::ctype<charT>::space, c)) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_word) && (c == '_'))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_unicode) && ::boost::BOOST_REGEX_DETAIL_NS::is_extended(c))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_vertical_space) && (is_separator(c) || (c == '\v')))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_horizontal_space) && this->m_pctype->is(std::ctype<charT>::space, c) && !(is_separator(c) || (c == '\v')));
 }
 #endif
 
@@ -905,7 +906,7 @@ inline boost::shared_ptr<const cpp_regex_traits_implementation<charT> > create_c
    return ::boost::object_cache<cpp_regex_traits_base<charT>, cpp_regex_traits_implementation<charT> >::get(key, 5);
 }
 
-} // re_detail
+} // BOOST_REGEX_DETAIL_NS
 
 template <class charT>
 class cpp_regex_traits
@@ -922,7 +923,7 @@ public:
    struct boost_extensions_tag{};
 
    cpp_regex_traits()
-      : m_pimpl(re_detail::create_cpp_regex_traits<charT>(std::locale()))
+      : m_pimpl(BOOST_REGEX_DETAIL_NS::create_cpp_regex_traits<charT>(std::locale()))
    { }
    static size_type length(const char_type* p)
    {
@@ -995,20 +996,32 @@ public:
          && (m_pimpl->m_pctype->is(
             static_cast<ctype_mask>(f & mask_base), c)))
          return true;
-      else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_unicode) && re_detail::is_extended(c))
+      else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_unicode) && BOOST_REGEX_DETAIL_NS::is_extended(c))
          return true;
-      else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_word) && (c == '_'))
+      else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_word) && (c == '_'))
          return true;
-      else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_blank) 
+      else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_blank) 
          && m_pimpl->m_pctype->is(std::ctype<charT>::space, c)
-         && !re_detail::is_separator(c))
+         && !BOOST_REGEX_DETAIL_NS::is_separator(c))
          return true;
-      else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_vertical) 
-         && (::boost::re_detail::is_separator(c) || (c == '\v')))
+      else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_vertical) 
+         && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == '\v')))
          return true;
-      else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_horizontal) 
-         && this->isctype(c, std::ctype<charT>::space) && !this->isctype(c, re_detail::cpp_regex_traits_implementation<charT>::mask_vertical))
+      else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_horizontal) 
+         && this->isctype(c, std::ctype<charT>::space) && !this->isctype(c, BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_vertical))
          return true;
+#ifdef __CYGWIN__
+      //
+      // Cygwin has a buggy ctype facet, see https://www.cygwin.com/ml/cygwin/2012-08/msg00178.html:
+      //
+      else if((f & std::ctype<charT>::xdigit) == std::ctype<charT>::xdigit)
+      {
+         if((c >= 'a') && (c <= 'f'))
+            return true;
+         if((c >= 'A') && (c <= 'F'))
+            return true;
+      }
+#endif
       return false;
 #else
       return m_pimpl->isctype(c, f);
@@ -1023,7 +1036,7 @@ public:
    locale_type imbue(locale_type l)
    {
       std::locale result(getloc());
-      m_pimpl = re_detail::create_cpp_regex_traits<charT>(l);
+      m_pimpl = BOOST_REGEX_DETAIL_NS::create_cpp_regex_traits<charT>(l);
       return result;
    }
    locale_type getloc()const
@@ -1043,7 +1056,7 @@ public:
    static std::string get_catalog_name();
 
 private:
-   boost::shared_ptr<const re_detail::cpp_regex_traits_implementation<charT> > m_pimpl;
+   boost::shared_ptr<const BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT> > m_pimpl;
    //
    // catalog name handler:
    //
@@ -1058,7 +1071,7 @@ private:
 template <class charT>
 int cpp_regex_traits<charT>::toi(const charT*& first, const charT* last, int radix)const
 {
-   re_detail::parser_buf<charT>   sbuf;            // buffer for parsing numbers.
+   BOOST_REGEX_DETAIL_NS::parser_buf<charT>   sbuf;            // buffer for parsing numbers.
    std::basic_istream<charT>      is(&sbuf);       // stream for parsing numbers.
 
    // we do NOT want to parse any thousands separators inside the stream:

3rdparty/boost/boost/regex/v4/cregex.hpp

@@ -221,7 +221,7 @@ namespace boost{
 
 class RegEx;
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 class RegExData;
 struct pred1;
@@ -229,7 +229,7 @@ struct pred2;
 struct pred3;
 struct pred4;
 
-}  /* namespace re_detail */
+}  /* namespace BOOST_REGEX_DETAIL_NS */
 
 #if (defined(BOOST_MSVC) || defined(__BORLANDC__)) && !defined(BOOST_DISABLE_WIN32)
 typedef bool (__cdecl *GrepCallback)(const RegEx& expression);
@@ -244,7 +244,7 @@ typedef bool (*FindFilesCallback)(const char* file);
 class BOOST_REGEX_DECL RegEx
 {
 private:
-   re_detail::RegExData* pdata;
+   BOOST_REGEX_DETAIL_NS::RegExData* pdata;
 public:
    RegEx();
    RegEx(const RegEx& o);
@@ -296,10 +296,10 @@ public:
 
    static const std::size_t npos;
 
-   friend struct re_detail::pred1;
-   friend struct re_detail::pred2;
-   friend struct re_detail::pred3;
-   friend struct re_detail::pred4;
+   friend struct BOOST_REGEX_DETAIL_NS::pred1;
+   friend struct BOOST_REGEX_DETAIL_NS::pred2;
+   friend struct BOOST_REGEX_DETAIL_NS::pred3;
+   friend struct BOOST_REGEX_DETAIL_NS::pred4;
 };
 
 #ifdef BOOST_MSVC

3rdparty/boost/boost/regex/v4/fileiter.hpp

@@ -49,7 +49,7 @@
 #include <cstddef>
 
 namespace boost{
-   namespace re_detail{
+   namespace BOOST_REGEX_DETAIL_NS{
 
 #ifndef BOOST_NO_ANSI_APIS
 typedef WIN32_FIND_DATAA _fi_find_data;
@@ -58,7 +58,7 @@ typedef WIN32_FIND_DATAW _fi_find_data;
 #endif
 typedef HANDLE _fi_find_handle;
 
-   } // namespace re_detail
+   } // namespace BOOST_REGEX_DETAIL_NS
 
 } // namespace boost
 
@@ -84,7 +84,7 @@ using std::list;
 #endif
 
 namespace boost{
-   namespace re_detail{
+   namespace BOOST_REGEX_DETAIL_NS{
 
 #ifdef BOOST_HAS_ABI_HEADERS
 #  include BOOST_ABI_PREFIX
@@ -110,7 +110,7 @@ bool _fi_FindClose(_fi_find_handle hFindFile);
 #  include BOOST_ABI_SUFFIX
 #endif
 
-   } // namespace re_detail
+   } // namespace BOOST_REGEX_DETAIL_NS
 } // namespace boost
 
 #ifdef FindFirstFile
@@ -130,7 +130,7 @@ bool _fi_FindClose(_fi_find_handle hFindFile);
 #endif
 
 namespace boost{
-   namespace re_detail{
+   namespace BOOST_REGEX_DETAIL_NS{
 
 #ifdef BOOST_HAS_ABI_HEADERS
 #  include BOOST_ABI_PREFIX
@@ -427,10 +427,10 @@ inline bool operator < (const directory_iterator&, const directory_iterator&)
 #endif
 
 
-} // namespace re_detail
-using boost::re_detail::directory_iterator;
-using boost::re_detail::file_iterator;
-using boost::re_detail::mapfile;
+} // namespace BOOST_REGEX_DETAIL_NS
+using boost::BOOST_REGEX_DETAIL_NS::directory_iterator;
+using boost::BOOST_REGEX_DETAIL_NS::file_iterator;
+using boost::BOOST_REGEX_DETAIL_NS::mapfile;
 } // namespace boost
 
 #endif     // BOOST_REGEX_NO_FILEITER

3rdparty/boost/boost/regex/v4/instances.hpp

@@ -54,7 +54,7 @@ namespace boost{
 template class BOOST_REGEX_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >;
 template class BOOST_REGEX_DECL match_results< const BOOST_REGEX_CHAR_T* >;
 #ifndef BOOST_NO_STD_ALLOCATOR
-template class BOOST_REGEX_DECL ::boost::re_detail::perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >;
+template class BOOST_REGEX_DECL ::boost::BOOST_REGEX_DETAIL_NS::perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >;
 #endif
 
 #  ifndef BOOST_REGEX_INSTANTIATE
@@ -94,7 +94,7 @@ template class BOOST_REGEX_TEMPLATE_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_R
 
 template class BOOST_REGEX_TEMPLATE_DECL match_results< const BOOST_REGEX_CHAR_T* >;
 #ifndef BOOST_NO_STD_ALLOCATOR
-template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >;
+template class BOOST_REGEX_TEMPLATE_DECL ::boost::BOOST_REGEX_DETAIL_NS::perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >;
 #endif
 #if !(defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB <= 1))\
    && !(defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION <= 800))\
@@ -102,7 +102,7 @@ template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher<BOOST_
    && !defined(BOOST_REGEX_ICU_INSTANCES)
 template class BOOST_REGEX_TEMPLATE_DECL match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >;
 #ifndef BOOST_NO_STD_ALLOCATOR
-template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator, match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >::allocator_type, boost::regex_traits<BOOST_REGEX_CHAR_T > >;
+template class BOOST_REGEX_TEMPLATE_DECL ::boost::BOOST_REGEX_DETAIL_NS::perl_matcher< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator, match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >::allocator_type, boost::regex_traits<BOOST_REGEX_CHAR_T > >;
 #endif
 #endif
 
@@ -119,6 +119,11 @@ template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher< std::
 
 #elif (defined(__GNUC__) && (__GNUC__ >= 3)) || !defined(BOOST_NO_CXX11_EXTERN_TEMPLATE)
 
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wkeyword-macro"
+#endif
+
 #  ifndef BOOST_REGEX_INSTANTIATE
 #     ifdef __GNUC__
 #        define template __extension__ extern template
@@ -128,7 +133,7 @@ template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher< std::
 #  endif
 
 #if !defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_REGEX_ICU_INSTANCES)
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 template BOOST_REGEX_DECL
 std::locale cpp_regex_traits_base<BOOST_REGEX_CHAR_T>::imbue(const std::locale& l);
 
@@ -177,7 +182,7 @@ template BOOST_REGEX_DECL void BOOST_REGEX_CALL
    match_results<const BOOST_REGEX_CHAR_T*>::maybe_assign(
       const match_results<const BOOST_REGEX_CHAR_T*>& m);
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 template BOOST_REGEX_DECL void perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >::construct_init(
       const basic_regex<BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >& e, match_flag_type f);
 template BOOST_REGEX_DECL bool perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >::match();
@@ -193,7 +198,7 @@ template BOOST_REGEX_DECL void BOOST_REGEX_CALL
    match_results<std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator>::maybe_assign(
       const match_results<std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator>& m);
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 template BOOST_REGEX_DECL void perl_matcher<std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator, match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >::allocator_type, boost::regex_traits<BOOST_REGEX_CHAR_T > >::construct_init(
       const basic_regex<BOOST_REGEX_CHAR_T>& e, match_flag_type f);
 template BOOST_REGEX_DECL bool perl_matcher<std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator, match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >::allocator_type, boost::regex_traits<BOOST_REGEX_CHAR_T > >::match();
@@ -205,7 +210,9 @@ template BOOST_REGEX_DECL bool perl_matcher<std::basic_string<BOOST_REGEX_CHAR_T
 #     undef template
 #  endif
 
-
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
 #endif
 
 } // namespace boost

3rdparty/boost/boost/regex/v4/iterator_traits.hpp

@@ -31,7 +31,7 @@
 #endif
 
 namespace boost{
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 #if defined(BOOST_NO_STD_ITERATOR_TRAITS)
 
@@ -117,7 +117,7 @@ struct regex_iterator_traits : public std::iterator_traits<T> {};
 
 #endif
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 } // namespace boost
 
 #ifdef BOOST_MSVC

3rdparty/boost/boost/regex/v4/match_results.hpp

@@ -39,7 +39,7 @@ namespace boost{
 #  endif
 #endif
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 class named_subexpressions;
 
@@ -64,14 +64,14 @@ public:
    typedef          const_reference                                         reference;
    typedef typename vector_type::const_iterator                             const_iterator;
    typedef          const_iterator                                          iterator;
-   typedef typename re_detail::regex_iterator_traits<
+   typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<
                                     BidiIterator>::difference_type          difference_type;
    typedef typename Allocator::size_type                                    size_type;
    typedef          Allocator                                               allocator_type;
-   typedef typename re_detail::regex_iterator_traits<
+   typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<
                                     BidiIterator>::value_type               char_type;
    typedef          std::basic_string<char_type>                            string_type;
-   typedef          re_detail::named_subexpressions                         named_sub_type;
+   typedef          BOOST_REGEX_DETAIL_NS::named_subexpressions                         named_sub_type;
 
    // construct/copy/destroy:
    explicit match_results(const Allocator& a = Allocator())
@@ -158,7 +158,7 @@ public:
          const sub_match<BidiIterator>& s = m_subs[sub];
          if(s.matched || (sub == 2))
          {
-            return ::boost::re_detail::distance((BidiIterator)(m_base), (BidiIterator)(s.first));
+            return ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)(m_base), (BidiIterator)(s.first));
          }
       }
       return ~static_cast<difference_type>(0);
@@ -237,7 +237,7 @@ public:
       //
       if(m_is_singular)
          raise_logic_error();
-      re_detail::named_subexpressions::range_type r = m_named_subs->equal_range(i, j);
+      BOOST_REGEX_DETAIL_NS::named_subexpressions::range_type r = m_named_subs->equal_range(i, j);
       while((r.first != r.second) && ((*this)[r.first->index].matched == false))
          ++r.first;
       return r.first != r.second ? (*this)[r.first->index] : m_null;
@@ -262,7 +262,7 @@ public:
       //
       if(m_is_singular)
          raise_logic_error();
-      re_detail::named_subexpressions::range_type s, r;
+      BOOST_REGEX_DETAIL_NS::named_subexpressions::range_type s, r;
       s = r = m_named_subs->equal_range(i, j);
       while((r.first != r.second) && ((*this)[r.first->index].matched == false))
          ++r.first;
@@ -345,7 +345,7 @@ public:
    {
       if(m_is_singular)
          raise_logic_error();
-      typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator>::type F;
+      typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator>::type F;
       F func(fmt);
       return func(*this, out, flags);
    }
@@ -355,9 +355,9 @@ public:
       if(m_is_singular)
          raise_logic_error();
       std::basic_string<char_type> result;
-      re_detail::string_out_iterator<std::basic_string<char_type> > i(result);
+      BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> > i(result);
 
-      typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, re_detail::string_out_iterator<std::basic_string<char_type> > >::type F;
+      typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> > >::type F;
       F func(fmt);
 
       func(*this, i, flags);
@@ -373,7 +373,7 @@ public:
       if(m_is_singular)
          raise_logic_error();
       typedef ::boost::regex_traits_wrapper<typename RegexT::traits_type> traits_type;
-      typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator, traits_type>::type F;
+      typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator, traits_type>::type F;
       F func(fmt);
       return func(*this, out, flags, re.get_traits());
    }
@@ -386,9 +386,9 @@ public:
          raise_logic_error();
       typedef ::boost::regex_traits_wrapper<typename RegexT::traits_type> traits_type;
       std::basic_string<char_type> result;
-      re_detail::string_out_iterator<std::basic_string<char_type> > i(result);
+      BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> > i(result);
 
-      typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, re_detail::string_out_iterator<std::basic_string<char_type> >, traits_type >::type F;
+      typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> >, traits_type >::type F;
       F func(fmt);
 
       func(*this, i, flags, re.get_traits());
@@ -639,15 +639,15 @@ void BOOST_REGEX_CALL match_results<BidiIterator, Allocator>::maybe_assign(const
          // p1 better than p2, and no need to calculate distances:
          return;
       }
-      base1 = ::boost::re_detail::distance(l_base, p1->first);
-      base2 = ::boost::re_detail::distance(l_base, p2->first);
+      base1 = ::boost::BOOST_REGEX_DETAIL_NS::distance(l_base, p1->first);
+      base2 = ::boost::BOOST_REGEX_DETAIL_NS::distance(l_base, p2->first);
       BOOST_ASSERT(base1 >= 0);
       BOOST_ASSERT(base2 >= 0);
       if(base1 < base2) return;
       if(base2 < base1) break;
 
-      len1 = ::boost::re_detail::distance((BidiIterator)p1->first, (BidiIterator)p1->second);
-      len2 = ::boost::re_detail::distance((BidiIterator)p2->first, (BidiIterator)p2->second);
+      len1 = ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)p1->first, (BidiIterator)p1->second);
+      len2 = ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)p2->first, (BidiIterator)p2->second);
       BOOST_ASSERT(len1 >= 0);
       BOOST_ASSERT(len2 >= 0);
       if((len1 != len2) || ((p1->matched == false) && (p2->matched == true)))

3rdparty/boost/boost/regex/v4/mem_block_cache.hpp

@@ -28,7 +28,7 @@
 #endif
 
 namespace boost{
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 struct mem_block_node
 {

3rdparty/boost/boost/regex/v4/perl_matcher.hpp

@@ -31,7 +31,7 @@
 #endif
 
 namespace boost{
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 //
 // error checking API:
@@ -253,23 +253,40 @@ class repeater_count
    int state_id;
    std::size_t count;        // the number of iterations so far
    BidiIterator start_pos;   // where the last repeat started
+
+   repeater_count* unwind_until(int n, repeater_count* p, int current_recursion_id)
+   { 
+      while(p && (p->state_id != n))
+      {
+         if(-2 - current_recursion_id == p->state_id)
+            return 0;
+         p = p->next;
+         if(p && (p->state_id < 0))
+         {
+            p = unwind_until(p->state_id, p, current_recursion_id);
+            if(!p)
+               return p;
+            p = p->next;
+         }
+      }
+      return p;
+   }
 public:
    repeater_count(repeater_count** s) : stack(s), next(0), state_id(-1), count(0), start_pos() {}
    
-   repeater_count(int i, repeater_count** s, BidiIterator start)
+   repeater_count(int i, repeater_count** s, BidiIterator start, int current_recursion_id)
       : start_pos(start)
    {
       state_id = i;
       stack = s;
       next = *stack;
       *stack = this;
-      if(state_id > next->state_id)
+      if((state_id > next->state_id) && (next->state_id >= 0))
          count = 0;
       else
       {
          repeater_count* p = next;
-         while(p && (p->state_id != state_id))
-            p = p->next;
+         p = unwind_until(state_id, p, current_recursion_id);
          if(p)
          {
             count = p->count;
@@ -426,6 +443,11 @@ private:
    bool backtrack_till_match(std::size_t count);
 #endif
    bool match_recursion();
+   bool match_fail();
+   bool match_accept();
+   bool match_commit();
+   bool match_then();
+   bool skip_until_paren(int index, bool match = true);
 
    // find procs stored in s_find_vtable:
    bool find_restart_any();
@@ -483,7 +505,12 @@ private:
    unsigned char match_any_mask;
    // recursion information:
    std::vector<recursion_info<results_type> > recursion_stack;
-
+#ifdef BOOST_REGEX_RECURSIVE
+   // Set to false by a (*COMMIT):
+   bool m_can_backtrack;
+   bool m_have_accept;
+   bool m_have_then;
+#endif
 #ifdef BOOST_REGEX_NON_RECURSIVE
    //
    // additional members for non-recursive version:
@@ -508,6 +535,8 @@ private:
    bool unwind_non_greedy_repeat(bool);
    bool unwind_recursion(bool);
    bool unwind_recursion_pop(bool);
+   bool unwind_commit(bool);
+   bool unwind_then(bool);
    void destroy_single_repeat();
    void push_matched_paren(int index, const sub_match<BidiIterator>& sub);
    void push_recursion_stopper();
@@ -523,11 +552,17 @@ private:
    saved_state* m_stack_base;
    // pointer to current stack position:
    saved_state* m_backup_state;
+   // how many memory blocks have we used up?:
+   unsigned used_block_count;
    // determines what value to return when unwinding from recursion,
    // allows for mixed recursive/non-recursive algorithm:
    bool m_recursive_result;
-   // how many memory blocks have we used up?:
-   unsigned used_block_count;
+   // We have unwound to a lookahead/lookbehind, used by COMMIT/PRUNE/SKIP:
+   bool m_unwound_lookahead;
+   // We have unwound to an alternative, used by THEN:
+   bool m_unwound_alt;
+   // We are unwinding a commit - used by independent subs to determine whether to stop there or carry on unwinding:
+   //bool m_unwind_commit;
 #endif
 
    // these operations aren't allowed, so are declared private,
@@ -544,7 +579,7 @@ private:
 #pragma warning(pop)
 #endif
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 
 #ifdef BOOST_MSVC
 #pragma warning(push)

3rdparty/boost/boost/regex/v4/perl_matcher_common.hpp

@@ -40,7 +40,7 @@
 #endif
 
 namespace boost{
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 template <class BidiIterator, class Allocator, class traits>
 void perl_matcher<BidiIterator, Allocator, traits>::construct_init(const basic_regex<char_type, traits>& e, match_flag_type f)
@@ -80,11 +80,17 @@ void perl_matcher<BidiIterator, Allocator, traits>::construct_init(const basic_r
 #ifdef BOOST_REGEX_NON_RECURSIVE
    m_stack_base = 0;
    m_backup_state = 0;
+#elif defined(BOOST_REGEX_RECURSIVE)
+   m_can_backtrack = true;
+   m_have_accept = false;
 #endif
    // find the value to use for matching word boundaries:
    m_word_mask = re.get_data().m_word_mask; 
    // find bitmask to use for matching '.':
-   match_any_mask = static_cast<unsigned char>((f & match_not_dot_newline) ? re_detail::test_not_newline : re_detail::test_newline);
+   match_any_mask = static_cast<unsigned char>((f & match_not_dot_newline) ? BOOST_REGEX_DETAIL_NS::test_not_newline : BOOST_REGEX_DETAIL_NS::test_newline);
+   // Disable match_any if requested in the state machine:
+   if(e.get_data().m_disable_match_any)
+      m_match_flags &= ~regex_constants::match_any;
 }
 
 template <class BidiIterator, class Allocator, class traits>
@@ -101,7 +107,7 @@ void perl_matcher<BidiIterator, Allocator, traits>::estimate_max_state_count(std
    // Calculate NS^2 first:
    //
    static const std::ptrdiff_t k = 100000;
-   std::ptrdiff_t dist = boost::re_detail::distance(base, last);
+   std::ptrdiff_t dist = boost::BOOST_REGEX_DETAIL_NS::distance(base, last);
    if(dist == 0)
       dist = 1;
    std::ptrdiff_t states = re.size();
@@ -165,7 +171,7 @@ template <class BidiIterator, class Allocator, class traits>
 inline bool perl_matcher<BidiIterator, Allocator, traits>::protected_call(
    protected_proc_type proc)
 {
-   ::boost::re_detail::concrete_protected_call
+   ::boost::BOOST_REGEX_DETAIL_NS::concrete_protected_call
       <perl_matcher<BidiIterator, Allocator, traits> >
       obj(this, proc);
    return obj.execute();
@@ -348,6 +354,9 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_prefix()
 #endif
    if(!m_has_found_match)
       position = restart; // reset search postion
+#ifdef BOOST_REGEX_RECURSIVE
+   m_can_backtrack = true; // reset for further searches
+#endif
    return m_has_found_match;
 }
 
@@ -703,7 +712,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_backstep()
 #endif
    if( ::boost::is_random_access_iterator<BidiIterator>::value)
    {
-      std::ptrdiff_t maxlen = ::boost::re_detail::distance(backstop, position);
+      std::ptrdiff_t maxlen = ::boost::BOOST_REGEX_DETAIL_NS::distance(backstop, position);
       if(maxlen < static_cast<const re_brace*>(pstate)->index)
          return false;
       std::advance(position, -static_cast<const re_brace*>(pstate)->index);
@@ -793,6 +802,25 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_toggle_case()
    return true;
 }
 
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::match_fail()
+{
+   // Just force a backtrack:
+   return false;
+}
+
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::match_accept()
+{
+   if(!recursion_stack.empty())
+   {
+      return skip_until_paren(recursion_stack.back().idx);
+   }
+   else
+   {
+      return skip_until_paren(INT_MAX);
+   }
+}
 
 template <class BidiIterator, class Allocator, class traits>
 bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_any()
@@ -966,7 +994,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_lit()
    return false;
 }
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 
 } // namespace boost
 

3rdparty/boost/boost/regex/v4/perl_matcher_non_recursive.hpp

@@ -34,11 +34,11 @@
 #endif
 #ifdef BOOST_MSVC
 #  pragma warning(push)
-#  pragma warning(disable: 4800)
+#  pragma warning(disable: 4800 4706)
 #endif
 
 namespace boost{
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 template <class T>
 inline void inplace_destroy(T* p)
@@ -87,8 +87,8 @@ template <class BidiIterator>
 struct saved_repeater : public saved_state
 {
    repeater_count<BidiIterator> count;
-   saved_repeater(int i, repeater_count<BidiIterator>** s, BidiIterator start) 
-      : saved_state(saved_state_repeater_count), count(i,s,start){}
+   saved_repeater(int i, repeater_count<BidiIterator>** s, BidiIterator start, int current_recursion_id)
+      : saved_state(saved_state_repeater_count), count(i, s, start, current_recursion_id){}
 };
 
 struct saved_extra_block : public saved_state
@@ -141,7 +141,7 @@ struct saved_recursion : public saved_state
 template <class BidiIterator, class Allocator, class traits>
 bool perl_matcher<BidiIterator, Allocator, traits>::match_all_states()
 {
-   static matcher_proc_type const s_match_vtable[30] = 
+   static matcher_proc_type const s_match_vtable[34] = 
    {
       (&perl_matcher<BidiIterator, Allocator, traits>::match_startmark),
       &perl_matcher<BidiIterator, Allocator, traits>::match_endmark,
@@ -177,6 +177,10 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_all_states()
       &perl_matcher<BidiIterator, Allocator, traits>::match_assert_backref,
       &perl_matcher<BidiIterator, Allocator, traits>::match_toggle_case,
       &perl_matcher<BidiIterator, Allocator, traits>::match_recursion,
+      &perl_matcher<BidiIterator, Allocator, traits>::match_fail,
+      &perl_matcher<BidiIterator, Allocator, traits>::match_accept,
+      &perl_matcher<BidiIterator, Allocator, traits>::match_commit,
+      &perl_matcher<BidiIterator, Allocator, traits>::match_then,
    };
 
    push_recursion_stopper();
@@ -309,7 +313,7 @@ inline void perl_matcher<BidiIterator, Allocator, traits>::push_repeater_count(i
       pmp = static_cast<saved_repeater<BidiIterator>*>(m_backup_state);
       --pmp;
    }
-   (void) new (pmp)saved_repeater<BidiIterator>(i, s, position);
+   (void) new (pmp)saved_repeater<BidiIterator>(i, s, position, this->recursion_stack.size() ? this->recursion_stack.back().idx : (INT_MIN + 3));
    m_backup_state = pmp;
 }
 
@@ -370,6 +374,13 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_startmark()
          const re_syntax_base* next_pstate = static_cast<const re_jump*>(pstate->next.p)->alt.p->next.p;
          pstate = pstate->next.p->next.p;
          bool r = match_all_states();
+         if(!r && !m_independent)
+         {
+            // Must be unwinding from a COMMIT/SKIP/PRUNE and the independent 
+            // sub failed, need to unwind everything else:
+            while(unwind(false));
+            return false;
+         }
          pstate = next_pstate;
          m_independent = old_independent;
 #ifdef BOOST_REGEX_MATCH_EXTRA
@@ -652,7 +663,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_fast()
 
    const re_repeat* rep = static_cast<const re_repeat*>(pstate);
    bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);   
-   unsigned count = static_cast<unsigned>((std::min)(static_cast<unsigned>(::boost::re_detail::distance(position, last)), static_cast<unsigned>(greedy ? rep->max : rep->min)));
+   unsigned count = static_cast<unsigned>((std::min)(static_cast<unsigned>(::boost::BOOST_REGEX_DETAIL_NS::distance(position, last)), static_cast<unsigned>(greedy ? rep->max : rep->min)));
    if(rep->min > count)
    {
       position = last;
@@ -705,7 +716,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat()
       BidiIterator end = position;
       // Move end forward by "desired", preferably without using distance or advance if we can
       // as these can be slow for some iterator types.
-      std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
+      std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::BOOST_REGEX_DETAIL_NS::distance(position, last);
       if(desired >= len)
          end = last;
       else
@@ -715,7 +726,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat()
       {
          ++position;
       }
-      count = (unsigned)::boost::re_detail::distance(origin, position);
+      count = (unsigned)::boost::BOOST_REGEX_DETAIL_NS::distance(origin, position);
    }
    else
    {
@@ -779,7 +790,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
       BidiIterator end = position;
       // Move end forward by "desired", preferably without using distance or advance if we can
       // as these can be slow for some iterator types.
-      std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
+      std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::BOOST_REGEX_DETAIL_NS::distance(position, last);
       if(desired >= len)
          end = last;
       else
@@ -789,7 +800,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
       {
          ++position;
       }
-      count = (unsigned)::boost::re_detail::distance(origin, position);
+      count = (unsigned)::boost::BOOST_REGEX_DETAIL_NS::distance(origin, position);
    }
    else
    {
@@ -854,7 +865,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
       BidiIterator end = position;
       // Move end forward by "desired", preferably without using distance or advance if we can
       // as these can be slow for some iterator types.
-      std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
+      std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::BOOST_REGEX_DETAIL_NS::distance(position, last);
       if(desired >= len)
          end = last;
       else
@@ -864,7 +875,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
       {
          ++position;
       }
-      count = (unsigned)::boost::re_detail::distance(origin, position);
+      count = (unsigned)::boost::BOOST_REGEX_DETAIL_NS::distance(origin, position);
    }
    else
    {
@@ -923,12 +934,12 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_recursion()
    recursion_stack.push_back(recursion_info<results_type>());
    recursion_stack.back().preturn_address = pstate->next.p;
    recursion_stack.back().results = *m_presult;
-   if(static_cast<const re_recurse*>(pstate)->state_id > 0)
-   {
-      push_repeater_count(static_cast<const re_recurse*>(pstate)->state_id, &next_count);
-   }
    pstate = static_cast<const re_jump*>(pstate)->alt.p;
    recursion_stack.back().idx = static_cast<const re_brace*>(pstate)->index;
+   //if(static_cast<const re_recurse*>(pstate)->state_id > 0)
+   {
+      push_repeater_count(-(2 + static_cast<const re_brace*>(pstate)->index), &next_count);
+   }
 
    return true;
 }
@@ -952,6 +963,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_endmark()
             *m_presult = recursion_stack.back().results;
             push_recursion(recursion_stack.back().idx, recursion_stack.back().preturn_address, &recursion_stack.back().results);
             recursion_stack.pop_back();
+            push_repeater_count(-(2 + index), &next_count);
          }
       }
    }
@@ -1003,6 +1015,103 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_match()
    return true;
 }
 
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::match_commit()
+{
+   // Ideally we would just junk all the states that are on the stack,
+   // however we might not unwind correctly in that case, so for now,
+   // just mark that we don't backtrack into whatever is left (or rather
+   // we'll unwind it unconditionally without pausing to try other matches).
+
+   switch(static_cast<const re_commit*>(pstate)->action)
+   {
+   case commit_commit:
+      restart = last;
+      break;
+   case commit_skip:
+      if(base != position)
+      {
+         restart = position;
+         // Have to decrement restart since it will get incremented again later:
+         --restart;
+      }
+      break;
+   case commit_prune:
+      break;
+   }
+
+   saved_state* pmp = m_backup_state;
+   --pmp;
+   if(pmp < m_stack_base)
+   {
+      extend_stack();
+      pmp = m_backup_state;
+      --pmp;
+   }
+   (void) new (pmp)saved_state(16);
+   m_backup_state = pmp;
+   pstate = pstate->next.p;
+   return true;
+}
+
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::match_then()
+{
+   // Just leave a mark that we need to skip to next alternative:
+   saved_state* pmp = m_backup_state;
+   --pmp;
+   if(pmp < m_stack_base)
+   {
+      extend_stack();
+      pmp = m_backup_state;
+      --pmp;
+   }
+   (void) new (pmp)saved_state(17);
+   m_backup_state = pmp;
+   pstate = pstate->next.p;
+   return true;
+}
+
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::skip_until_paren(int index, bool have_match)
+{
+   while(pstate)
+   {
+      if(pstate->type == syntax_element_endmark)
+      {
+         if(static_cast<const re_brace*>(pstate)->index == index)
+         {
+            if(have_match)
+               return this->match_endmark();
+            pstate = pstate->next.p;
+            return true;
+         }
+         else
+         {
+            // Unenclosed closing ), occurs when (*ACCEPT) is inside some other 
+            // parenthesis which may or may not have other side effects associated with it.
+            match_endmark();
+            if(!pstate)
+            {
+               unwind(true);
+            }
+         }
+         continue;
+      }
+      else if(pstate->type == syntax_element_match)
+         return true;
+      else if(pstate->type == syntax_element_startmark)
+      {
+         int idx = static_cast<const re_brace*>(pstate)->index;
+         pstate = pstate->next.p;
+         skip_until_paren(idx, false);
+         continue;
+      }
+      pstate = pstate->next.p;
+   }
+   return true;
+}
+
 /****************************************************************************
 
 Unwind and associated proceedures follow, these perform what normal stack
@@ -1013,7 +1122,7 @@ unwinding does in the recursive implementation.
 template <class BidiIterator, class Allocator, class traits>
 bool perl_matcher<BidiIterator, Allocator, traits>::unwind(bool have_match)
 {
-   static unwind_proc_type const s_unwind_table[18] = 
+   static unwind_proc_type const s_unwind_table[19] = 
    {
       &perl_matcher<BidiIterator, Allocator, traits>::unwind_end,
       &perl_matcher<BidiIterator, Allocator, traits>::unwind_paren,
@@ -1031,9 +1140,13 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind(bool have_match)
       &perl_matcher<BidiIterator, Allocator, traits>::unwind_non_greedy_repeat,
       &perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion,
       &perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_pop,
+      &perl_matcher<BidiIterator, Allocator, traits>::unwind_commit,
+      &perl_matcher<BidiIterator, Allocator, traits>::unwind_then,
    };
 
    m_recursive_result = have_match;
+   m_unwound_lookahead = false;
+   m_unwound_alt = false;
    unwind_proc_type unwinder;
    bool cont;
    //
@@ -1076,14 +1189,14 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_paren(bool have_match
 #endif
    // unwind stack:
    m_backup_state = pmp+1;
-   boost::re_detail::inplace_destroy(pmp);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp);
    return true; // keep looking
 }
 
 template <class BidiIterator, class Allocator, class traits>
 bool perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_stopper(bool)
 {
-   boost::re_detail::inplace_destroy(m_backup_state++);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(m_backup_state++);
    pstate = 0;   // nothing left to search
    return false; // end of stack nothing more to search
 }
@@ -1096,8 +1209,9 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_assertion(bool r)
    position = pmp->position;
    bool result = (r == pmp->positive);
    m_recursive_result = pmp->positive ? r : !r;
-   boost::re_detail::inplace_destroy(pmp++);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
    m_backup_state = pmp;
+   m_unwound_lookahead = true;
    return !result; // return false if the assertion was matched to stop search.
 }
 
@@ -1110,8 +1224,9 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_alt(bool r)
       pstate = pmp->pstate;
       position = pmp->position;
    }
-   boost::re_detail::inplace_destroy(pmp++);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
    m_backup_state = pmp;
+   m_unwound_alt = !r;
    return r; 
 }
 
@@ -1119,7 +1234,7 @@ template <class BidiIterator, class Allocator, class traits>
 bool perl_matcher<BidiIterator, Allocator, traits>::unwind_repeater_counter(bool)
 {
    saved_repeater<BidiIterator>* pmp = static_cast<saved_repeater<BidiIterator>*>(m_backup_state);
-   boost::re_detail::inplace_destroy(pmp++);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
    m_backup_state = pmp;
    return true; // keep looking
 }
@@ -1131,7 +1246,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_extra_block(bool)
    void* condemmed = m_stack_base;
    m_stack_base = pmp->base;
    m_backup_state = pmp->end;
-   boost::re_detail::inplace_destroy(pmp);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp);
    put_mem_block(condemmed);
    return true; // keep looking
 }
@@ -1140,7 +1255,7 @@ template <class BidiIterator, class Allocator, class traits>
 inline void perl_matcher<BidiIterator, Allocator, traits>::destroy_single_repeat()
 {
    saved_single_repeat<BidiIterator>* p = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
-   boost::re_detail::inplace_destroy(p++);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(p++);
    m_backup_state = p;
 }
 
@@ -1532,7 +1647,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_non_greedy_repeat(boo
       pstate = pmp->pstate;
       ++(*next_count);
    }
-   boost::re_detail::inplace_destroy(pmp++);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
    m_backup_state = pmp;
    return r;
 }
@@ -1548,7 +1663,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion(bool r)
       recursion_stack.back().preturn_address = pmp->preturn_address;
       recursion_stack.back().results = pmp->results;
    }
-   boost::re_detail::inplace_destroy(pmp++);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
    m_backup_state = pmp;
    return true;
 }
@@ -1561,7 +1676,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_pop(bool r)
    {
       recursion_stack.pop_back();
    }
-   boost::re_detail::inplace_destroy(pmp++);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
    m_backup_state = pmp;
    return true;
 }
@@ -1580,6 +1695,48 @@ void perl_matcher<BidiIterator, Allocator, traits>::push_recursion_pop()
    (void) new (pmp)saved_state(15);
    m_backup_state = pmp;
 }
+
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::unwind_commit(bool b)
+{
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(m_backup_state++);
+   while(unwind(b) && !m_unwound_lookahead){}
+   if(m_unwound_lookahead && pstate)
+   {
+      //
+      // If we stop because we just unwound an assertion, put the
+      // commit state back on the stack again:
+      //
+      saved_state* pmp = m_backup_state;
+      --pmp;
+      if(pmp < m_stack_base)
+      {
+         extend_stack();
+         pmp = m_backup_state;
+         --pmp;
+      }
+      (void) new (pmp)saved_state(16);
+      m_backup_state = pmp;
+   }
+   // This prevents us from stopping when we exit from an independent sub-expression:
+   m_independent = false;
+   return false;
+}
+
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::unwind_then(bool b)
+{
+   // Unwind everything till we hit an alternative:
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(m_backup_state++);
+   bool result = false;
+   while((result = unwind(b)) && !m_unwound_alt){}
+   // We're now pointing at the next alternative, need one more backtrack 
+   // since *all* the other alternatives must fail once we've reached a THEN clause:
+   if(result && m_unwound_alt)
+      unwind(b);
+   return false;
+}
+
 /*
 template <class BidiIterator, class Allocator, class traits>
 bool perl_matcher<BidiIterator, Allocator, traits>::unwind_parenthesis_pop(bool r)
@@ -1589,7 +1746,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_parenthesis_pop(bool
    {
       --parenthesis_stack_position;
    }
-   boost::re_detail::inplace_destroy(pmp++);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
    m_backup_state = pmp;
    return true;
 }
@@ -1617,7 +1774,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_parenthesis_push(bool
    {
       parenthesis_stack[parenthesis_stack_position++] = pmp->position;
    }
-   boost::re_detail::inplace_destroy(pmp++);
+   boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
    m_backup_state = pmp;
    return true;
 }
@@ -1637,7 +1794,7 @@ inline void perl_matcher<BidiIterator, Allocator, traits>::push_parenthesis_push
    m_backup_state = pmp;
 }
 */
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 } // namespace boost
 
 #ifdef BOOST_MSVC

3rdparty/boost/boost/regex/v4/perl_matcher_recursive.hpp

@@ -37,7 +37,7 @@
 #endif
 
 namespace boost{
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 template <class BidiIterator>
 class backup_subex
@@ -60,7 +60,7 @@ public:
 template <class BidiIterator, class Allocator, class traits>
 bool perl_matcher<BidiIterator, Allocator, traits>::match_all_states()
 {
-   static matcher_proc_type const s_match_vtable[30] = 
+   static matcher_proc_type const s_match_vtable[34] = 
    {
       (&perl_matcher<BidiIterator, Allocator, traits>::match_startmark),
       &perl_matcher<BidiIterator, Allocator, traits>::match_endmark,
@@ -96,6 +96,10 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_all_states()
       &perl_matcher<BidiIterator, Allocator, traits>::match_assert_backref,
       &perl_matcher<BidiIterator, Allocator, traits>::match_toggle_case,
       &perl_matcher<BidiIterator, Allocator, traits>::match_recursion,
+      &perl_matcher<BidiIterator, Allocator, traits>::match_fail,
+      &perl_matcher<BidiIterator, Allocator, traits>::match_accept,
+      &perl_matcher<BidiIterator, Allocator, traits>::match_commit,
+      &perl_matcher<BidiIterator, Allocator, traits>::match_then,
    };
 
    if(state_count > max_state_count)
@@ -139,6 +143,8 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_startmark()
             r = false;
          else
             r = true;
+         if(r && m_have_accept)
+            r = skip_until_paren(INT_MAX);
          break;
       }
    case -3:
@@ -148,7 +154,10 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_startmark()
          m_independent = true;
          const re_syntax_base* next_pstate = static_cast<const re_jump*>(pstate->next.p)->alt.p->next.p;
          pstate = pstate->next.p->next.p;
+         bool can_backtrack = m_can_backtrack;
          r = match_all_states();
+         if(r)
+            m_can_backtrack = can_backtrack;
          pstate = next_pstate;
          m_independent = old_independent;
 #ifdef BOOST_REGEX_MATCH_EXTRA
@@ -178,6 +187,8 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_startmark()
             }
          }
 #endif
+         if(r && m_have_accept)
+            r = skip_until_paren(INT_MAX);
          break;
       }
    case -4:
@@ -278,12 +289,20 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_alt()
          BidiIterator oldposition(position);
          const re_syntax_base* old_pstate = jmp->alt.p;
          pstate = pstate->next.p;
+         m_have_then = false;
          if(!match_all_states())
          {
             pstate = old_pstate;
             position = oldposition;
+            if(m_have_then)
+            {
+               m_can_backtrack = true;
+               m_have_then = false;
+               return false;
             }
-         return true;
+         }
+         m_have_then = false;
+         return m_can_backtrack;
       }
       pstate = pstate->next.p;
       return true;
@@ -308,7 +327,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_rep()
    // Always copy the repeat count, so that the state is restored
    // when we exit this scope:
    //
-   repeater_count<BidiIterator> r(rep->state_id, &next_count, position);
+   repeater_count<BidiIterator> r(rep->state_id, &next_count, position, this->recursion_stack.size() ? this->recursion_stack.back().idx : INT_MIN + 3);
    //
    // If we've had at least one repeat already, and the last one 
    // matched the NULL string then set the repeat count to
@@ -354,6 +373,8 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_rep()
          pstate = rep->next.p;
          if(match_all_states())
             return true;
+         if(!m_can_backtrack)
+            return false;
          // failed repeat, reset posistion and fall through for alternative:
          position = pos;
       }
@@ -374,6 +395,8 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_rep()
          pstate = rep->alt.p;
          if(match_all_states())
             return true;
+         if(!m_can_backtrack)
+            return false;
          // failed alternative, reset posistion and fall through for repeat:
          position = pos;
       }
@@ -438,7 +461,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_slow()
          ++state_count;
          if(match_all_states())
             return true;
-         if(count >= rep->max)
+         if((count >= rep->max) || !m_can_backtrack)
             return false;
          ++count;
          pstate = psingle;
@@ -472,7 +495,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_fast()
 #pragma warning(disable:4267)
 #endif
    bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);   
-   std::size_t count = (std::min)(static_cast<std::size_t>(::boost::re_detail::distance(position, last)), static_cast<std::size_t>(greedy ? rep->max : rep->min));
+   std::size_t count = (std::min)(static_cast<std::size_t>(::boost::BOOST_REGEX_DETAIL_NS::distance(position, last)), static_cast<std::size_t>(greedy ? rep->max : rep->min));
    if(rep->min > count)
    {
       position = last;
@@ -503,7 +526,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_fast()
       ++state_count;
       if(match_all_states())
          return true;
-      if(count >= rep->max)
+      if((count >= rep->max) || !m_can_backtrack)
          return false;
       if(save_pos == last)
          return false;
@@ -539,7 +562,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat()
       desired = 
          (std::min)(
             (std::size_t)(greedy ? rep->max : rep->min),
-            (std::size_t)::boost::re_detail::distance(position, last));
+            (std::size_t)::boost::BOOST_REGEX_DETAIL_NS::distance(position, last));
       count = desired;
       ++desired;
       if(icase)
@@ -597,7 +620,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat()
       ++state_count;
       if(match_all_states())
          return true;
-      if(count >= rep->max)
+      if((count >= rep->max) || !m_can_backtrack)
          return false;
       position = save_pos;
       if(position == last)
@@ -643,7 +666,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
       BidiIterator end = position;
       // Move end forward by "desired", preferably without using distance or advance if we can
       // as these can be slow for some iterator types.
-      std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
+      std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::BOOST_REGEX_DETAIL_NS::distance(position, last);
       if(desired >= len)
          end = last;
       else
@@ -653,7 +676,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
       {
          ++position;
       }
-      count = (unsigned)::boost::re_detail::distance(origin, position);
+      count = (unsigned)::boost::BOOST_REGEX_DETAIL_NS::distance(origin, position);
    }
    else
    {
@@ -692,7 +715,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
       ++state_count;
       if(match_all_states())
          return true;
-      if(count >= rep->max)
+      if((count >= rep->max) || !m_can_backtrack)
          return false;
       position = save_pos;
       if(position == last)
@@ -739,7 +762,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
       BidiIterator end = position;
       // Move end forward by "desired", preferably without using distance or advance if we can
       // as these can be slow for some iterator types.
-      std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
+      std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::BOOST_REGEX_DETAIL_NS::distance(position, last);
       if(desired >= len)
          end = last;
       else
@@ -749,7 +772,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
       {
          ++position;
       }
-      count = (unsigned)::boost::re_detail::distance(origin, position);
+      count = (unsigned)::boost::BOOST_REGEX_DETAIL_NS::distance(origin, position);
    }
    else
    {
@@ -788,7 +811,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
       ++state_count;
       if(match_all_states())
          return true;
-      if(count >= rep->max)
+      if((count >= rep->max) || !m_can_backtrack)
          return false;
       position = save_pos;
       if(position == last)
@@ -818,6 +841,8 @@ bool perl_matcher<BidiIterator, Allocator, traits>::backtrack_till_match(std::si
 #pragma warning(push)
 #pragma warning(disable:4127)
 #endif
+   if(!m_can_backtrack)
+      return false;
    if((m_match_flags & match_partial) && (position == last))
       m_has_partial_match = true;
 
@@ -883,7 +908,9 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_recursion()
    repeater_count<BidiIterator>* saved = next_count;
    repeater_count<BidiIterator> r(&next_count); // resets all repeat counts since we're recursing and starting fresh on those
    next_count = &r;
+   bool can_backtrack = m_can_backtrack;
    bool result = match_all_states();
+   m_can_backtrack = can_backtrack;
    next_count = saved;
 
    if(!result)
@@ -980,9 +1007,76 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_match()
    return true;
 }
 
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::match_commit()
+{
+   m_can_backtrack = false;
+   int action = static_cast<const re_commit*>(pstate)->action;
+   switch(action)
+   {
+   case commit_commit:
+      restart = last;
+      break;
+   case commit_skip:
+      restart = position;
+      break;
+   }
+   pstate = pstate->next.p;
+   return true;
+}
+
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::match_then()
+{
+   pstate = pstate->next.p;
+   if(match_all_states())
+      return true;
+   m_can_backtrack = false;
+   m_have_then = true;
+   return false;
+}
+
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::skip_until_paren(int index, bool have_match)
+{
+   while(pstate)
+   {
+      if(pstate->type == syntax_element_endmark)
+      {
+         if(static_cast<const re_brace*>(pstate)->index == index)
+         {
+            if(have_match)
+               return this->match_endmark();
+            pstate = pstate->next.p;
+            return true;
+         }
+         else
+         {
+            // Unenclosed closing ), occurs when (*ACCEPT) is inside some other 
+            // parenthesis which may or may not have other side effects associated with it.
+            bool r = match_endmark();
+            m_have_accept = true;
+            if(!pstate)
+               return r;
+         }
+         continue;
+      }
+      else if(pstate->type == syntax_element_match)
+         return true;
+      else if(pstate->type == syntax_element_startmark)
+      {
+         int idx = static_cast<const re_brace*>(pstate)->index;
+         pstate = pstate->next.p;
+         skip_until_paren(idx, false);
+         continue;
+      }
+      pstate = pstate->next.p;
+   }
+   return true;
+}
 
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 } // namespace boost
 #ifdef BOOST_MSVC
 #pragma warning(pop)

3rdparty/boost/boost/regex/v4/primary_transform.hpp

@@ -32,7 +32,7 @@
 #endif
 
 namespace boost{
-   namespace re_detail{
+   namespace BOOST_REGEX_DETAIL_NS{
 
 
 enum{
@@ -122,7 +122,7 @@ unsigned find_sort_syntax(const traits* pt, charT* delim)
 }
 
 
-   } // namespace re_detail
+   } // namespace BOOST_REGEX_DETAIL_NS
 } // namespace boost
 
 #ifdef BOOST_MSVC

3rdparty/boost/boost/regex/v4/protected_call.hpp

@@ -32,7 +32,7 @@
 #endif
 
 namespace boost{
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 class BOOST_REGEX_DECL abstract_protected_call
 {

3rdparty/boost/boost/regex/v4/regex_format.hpp

@@ -55,7 +55,7 @@ namespace boost{
    template <class BidiIterator, class Allocator = BOOST_DEDUCED_TYPENAME std::vector<sub_match<BidiIterator> >::allocator_type >
 class match_results;
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 //
 // struct trivial_format_traits:
@@ -73,11 +73,11 @@ struct trivial_format_traits
    }
    static charT tolower(charT c)
    {
-      return ::boost::re_detail::global_lower(c);
+      return ::boost::BOOST_REGEX_DETAIL_NS::global_lower(c);
    }
    static charT toupper(charT c)
    {
-      return ::boost::re_detail::global_upper(c);
+      return ::boost::BOOST_REGEX_DETAIL_NS::global_upper(c);
    }
    static int value(const charT c, int radix)
    {
@@ -359,7 +359,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
    default:
       // see if we have a number:
       {
-         std::ptrdiff_t len = ::boost::re_detail::distance(m_position, m_end);
+         std::ptrdiff_t len = ::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end);
          //len = (std::min)(static_cast<std::ptrdiff_t>(2), len);
          int v = this->toi(m_position, m_position + len, 10);
          if((v < 0) || (have_brace && ((m_position == m_end) || (*m_position != '}'))))
@@ -570,7 +570,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
       }
       else
       {
-         std::ptrdiff_t len = ::boost::re_detail::distance(m_position, m_end);
+         std::ptrdiff_t len = ::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end);
          len = (std::min)(static_cast<std::ptrdiff_t>(2), len);
          int val = this->toi(m_position, m_position + len, 16);
          if(val < 0)
@@ -634,7 +634,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
             break;
       }
       // see if we have a \n sed style backreference:
-      std::ptrdiff_t len = ::boost::re_detail::distance(m_position, m_end);
+      std::ptrdiff_t len = ::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end);
       len = (std::min)(static_cast<std::ptrdiff_t>(1), len);
       int v = this->toi(m_position, m_position+len, 10);
       if((v > 0) || ((v == 0) && (m_flags & ::boost::regex_constants::format_sed)))
@@ -646,7 +646,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
       {
          // octal ecape sequence:
          --m_position;
-         len = ::boost::re_detail::distance(m_position, m_end);
+         len = ::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end);
          len = (std::min)(static_cast<std::ptrdiff_t>(4), len);
          v = this->toi(m_position, m_position + len, 8);
          BOOST_ASSERT(v >= 0);
@@ -693,7 +693,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
    }
    else
    {
-      std::ptrdiff_t len = ::boost::re_detail::distance(m_position, m_end);
+      std::ptrdiff_t len = ::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end);
       len = (std::min)(static_cast<std::ptrdiff_t>(2), len);
       v = this->toi(m_position, m_position + len, 10);
    }
@@ -835,10 +835,10 @@ OutputIterator regex_format_imp(OutputIterator out,
 {
    if(flags & regex_constants::format_literal)
    {
-      return re_detail::copy(p1, p2, out);
+      return BOOST_REGEX_DETAIL_NS::copy(p1, p2, out);
    }
 
-   re_detail::basic_regex_formatter<
+   BOOST_REGEX_DETAIL_NS::basic_regex_formatter<
       OutputIterator, 
       match_results<Iterator, Alloc>, 
       traits, ForwardIter> f(out, m, t);
@@ -1028,7 +1028,7 @@ struct format_functor1
    template <class S, class OutputIter>
    OutputIter do_format_string(const S& s, OutputIter i)
    {
-      return re_detail::copy(s.begin(), s.end(), i);
+      return BOOST_REGEX_DETAIL_NS::copy(s.begin(), s.end(), i);
    }
    template <class S, class OutputIter>
    inline OutputIter do_format_string(const S* s, OutputIter i)
@@ -1085,7 +1085,7 @@ struct format_functor_container
    OutputIter operator()(const Match& m, OutputIter i, boost::regex_constants::match_flag_type f, const Traits& t = Traits())
    {
       //typedef typename Match::char_type char_type;
-      return re_detail::regex_format_imp(i, m, func.begin(), func.end(), f, t);
+      return BOOST_REGEX_DETAIL_NS::regex_format_imp(i, m, func.begin(), func.end(), f, t);
    }
 private:
    const Container& func;
@@ -1093,7 +1093,7 @@ private:
    format_functor_container& operator=(const format_functor_container&);
 };
 
-template <class Func, class Match, class OutputIterator, class Traits = re_detail::trivial_format_traits<typename Match::char_type> >
+template <class Func, class Match, class OutputIterator, class Traits = BOOST_REGEX_DETAIL_NS::trivial_format_traits<typename Match::char_type> >
 struct compute_functor_type
 {
    typedef typename format_traits<Func, Match, OutputIterator>::type tag;
@@ -1114,7 +1114,7 @@ struct compute_functor_type
    >::type type;
 };
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 
 template <class OutputIterator, class Iterator, class Allocator, class Functor>
 inline OutputIterator regex_format(OutputIterator out,

3rdparty/boost/boost/regex/v4/regex_grep.hpp

@@ -50,7 +50,7 @@ inline unsigned int regex_grep(Predicate foo,
    typedef typename match_results<BidiIterator>::allocator_type match_allocator_type;
 
    match_results<BidiIterator> m;
-   re_detail::perl_matcher<BidiIterator, match_allocator_type, traits> matcher(first, last, m, e, flags, first);
+   BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, match_allocator_type, traits> matcher(first, last, m, e, flags, first);
    unsigned int count = 0;
    while(matcher.find())
    {

3rdparty/boost/boost/regex/v4/regex_iterator.hpp

@@ -82,14 +82,14 @@ private:
 };
 
 template <class BidirectionalIterator, 
-          class charT = BOOST_DEDUCED_TYPENAME re_detail::regex_iterator_traits<BidirectionalIterator>::value_type,
+          class charT = BOOST_DEDUCED_TYPENAME BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::value_type,
           class traits = regex_traits<charT> >
 class regex_iterator 
 #ifndef BOOST_NO_STD_ITERATOR
    : public std::iterator<
          std::forward_iterator_tag, 
          match_results<BidirectionalIterator>,
-         typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type,
+         typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type,
          const match_results<BidirectionalIterator>*,
          const match_results<BidirectionalIterator>& >         
 #endif
@@ -100,7 +100,7 @@ private:
 public:
    typedef          basic_regex<charT, traits>                   regex_type;
    typedef          match_results<BidirectionalIterator>                    value_type;
-   typedef typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type 
+   typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type 
                                                                             difference_type;
    typedef          const value_type*                                       pointer;
    typedef          const value_type&                                       reference; 

3rdparty/boost/boost/regex/v4/regex_match.hpp

@@ -46,7 +46,7 @@ bool regex_match(BidiIterator first, BidiIterator last,
                  const basic_regex<charT, traits>& e, 
                  match_flag_type flags = match_default)
 {
-   re_detail::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, first);
+   BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, first);
    return matcher.match();
 }
 template <class iterator, class charT, class traits>

3rdparty/boost/boost/regex/v4/regex_raw_buffer.hpp

@@ -29,7 +29,7 @@
 #include <cstddef>
 
 namespace boost{
-   namespace re_detail{
+   namespace BOOST_REGEX_DETAIL_NS{
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
@@ -198,7 +198,7 @@ inline raw_storage::raw_storage(size_type n)
 #pragma warning(pop)
 #endif
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 } // namespace boost
 
 #endif

3rdparty/boost/boost/regex/v4/regex_replace.hpp

@@ -48,7 +48,7 @@ OutputIterator regex_replace(OutputIterator out,
    if(i == j)
    {
       if(!(flags & regex_constants::format_no_copy))
-         out = re_detail::copy(first, last, out);
+         out = BOOST_REGEX_DETAIL_NS::copy(first, last, out);
    }
    else
    {
@@ -56,7 +56,7 @@ OutputIterator regex_replace(OutputIterator out,
       while(i != j)
       {
          if(!(flags & regex_constants::format_no_copy))
-            out = re_detail::copy(i->prefix().first, i->prefix().second, out); 
+            out = BOOST_REGEX_DETAIL_NS::copy(i->prefix().first, i->prefix().second, out); 
          out = i->format(out, fmt, flags, e);
          last_m = (*i)[0].second;
          if(flags & regex_constants::format_first_only)
@@ -64,7 +64,7 @@ OutputIterator regex_replace(OutputIterator out,
          ++i;
       }
       if(!(flags & regex_constants::format_no_copy))
-         out = re_detail::copy(last_m, last, out);
+         out = BOOST_REGEX_DETAIL_NS::copy(last_m, last, out);
    }
    return out;
 }
@@ -76,7 +76,7 @@ std::basic_string<charT> regex_replace(const std::basic_string<charT>& s,
                          match_flag_type flags = match_default)
 {
    std::basic_string<charT> result;
-   re_detail::string_out_iterator<std::basic_string<charT> > i(result);
+   BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<charT> > i(result);
    regex_replace(i, s.begin(), s.end(), e, fmt, flags);
    return result;
 }

3rdparty/boost/boost/regex/v4/regex_search.hpp

@@ -52,7 +52,7 @@ bool regex_search(BidiIterator first, BidiIterator last,
    if(e.flags() & regex_constants::failbit)
       return false;
 
-   re_detail::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, base);
+   BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, base);
    return matcher.find();
 }
 
@@ -141,7 +141,7 @@ bool regex_search(BidiIterator first, BidiIterator last,
 
    match_results<BidiIterator> m;
    typedef typename match_results<BidiIterator>::allocator_type match_alloc_type;
-   re_detail::perl_matcher<BidiIterator, match_alloc_type, traits> matcher(first, last, m, e, flags | regex_constants::match_any, first);
+   BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, match_alloc_type, traits> matcher(first, last, m, e, flags | regex_constants::match_any, first);
    return matcher.find();
 }
 

3rdparty/boost/boost/regex/v4/regex_split.hpp

@@ -39,7 +39,7 @@ namespace boost{
 #  pragma warning(disable: 4800)
 #endif
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 template <class charT>
 const basic_regex<charT>& get_default_expression(charT)
@@ -97,7 +97,7 @@ bool split_pred<OutputIterator, charT, Traits1, Alloc1>::operator()
    return true;
 }
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 
 template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
 std::size_t regex_split(OutputIterator out,
@@ -110,7 +110,7 @@ std::size_t regex_split(OutputIterator out,
    //typedef typename match_results<ci_t>::allocator_type                        match_allocator;
    ci_t last = s.begin();
    std::size_t init_size = max_split;
-   re_detail::split_pred<OutputIterator, charT, Traits1, Alloc1> pred(&last, &out, &max_split);
+   BOOST_REGEX_DETAIL_NS::split_pred<OutputIterator, charT, Traits1, Alloc1> pred(&last, &out, &max_split);
    ci_t i, j;
    i = s.begin();
    j = s.end();
@@ -147,7 +147,7 @@ template <class OutputIterator, class charT, class Traits1, class Alloc1>
 inline std::size_t regex_split(OutputIterator out,
                    std::basic_string<charT, Traits1, Alloc1>& s)
 {
-   return regex_split(out, s, re_detail::get_default_expression(charT(0)), match_default, UINT_MAX);
+   return regex_split(out, s, BOOST_REGEX_DETAIL_NS::get_default_expression(charT(0)), match_default, UINT_MAX);
 }
 
 #ifdef BOOST_MSVC