anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-22 05:16:21 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

update boost to 1.60

Browse Source
This commit is contained in:
Peter Kümmel 2015-12-20 14:04:54 +01:00
parent e1c893127f
commit bd74a15ebd
285 changed files with 6646 additions and 5770 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
3rdparty/boost/boost/align/align.hpp vendored
View File

@ -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.

12
3rdparty/boost/boost/align/detail/address.hpp vendored
View File

@ -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

8
3rdparty/boost/boost/align/detail/align.hpp vendored
View File

@ -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

6
3rdparty/boost/boost/align/detail/align_cxx11.hpp vendored
View File

@ -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

8
3rdparty/boost/boost/align/detail/is_alignment.hpp vendored
View File

@ -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

143
3rdparty/boost/boost/aligned_storage.hpp vendored
View File

@ -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

9
3rdparty/boost/boost/assert.hpp vendored
View File

@ -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

19
3rdparty/boost/boost/bind.hpp vendored
View File

@ -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

6
3rdparty/boost/boost/bind/arg.hpp vendored
View File

@ -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;
}

483
3rdparty/boost/boost/bind/bind.hpp vendored
View File

@ -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 );
}

65
3rdparty/boost/boost/bind/placeholders.hpp vendored
View File

@ -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

17
3rdparty/boost/boost/concept_check.hpp vendored
View File

@ -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;
};
//===========================================================================

22
3rdparty/boost/boost/config/compiler/clang.hpp vendored
View File

@ -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

20
3rdparty/boost/boost/config/compiler/gcc.hpp vendored
View File

@ -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

6
3rdparty/boost/boost/config/compiler/intel.hpp vendored
View File

@ -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

10
3rdparty/boost/boost/config/compiler/sunpro_cc.hpp vendored
View File

@ -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

1
3rdparty/boost/boost/config/compiler/visualc.hpp vendored
View File

@ -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

18
3rdparty/boost/boost/config/platform/cloudabi.hpp vendored Normal file
View File

@ -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

2
3rdparty/boost/boost/config/platform/macos.hpp vendored
View File

@ -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

8
3rdparty/boost/boost/config/platform/win32.hpp vendored
View File

@ -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

4
3rdparty/boost/boost/config/select_platform_config.hpp vendored
View File

@ -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) \

11
3rdparty/boost/boost/config/stdlib/dinkumware.hpp vendored
View File

@ -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

4
3rdparty/boost/boost/config/stdlib/libstdcpp3.hpp vendored
View File

@ -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))

20
3rdparty/boost/boost/config/suffix.hpp vendored
View File

@ -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
# define BOOST_UNREACHABLE_RETURN(x) return x;
#else
# define BOOST_UNREACHABLE_RETURN(x)
#ifndef BOOST_UNREACHABLE_RETURN
# ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION
# define BOOST_UNREACHABLE_RETURN(x) return x;
# 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 --------------------------//

40
3rdparty/boost/boost/container/container_fwd.hpp vendored
View File

@ -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

30
3rdparty/boost/boost/container/detail/std_fwd.hpp vendored
View File

@ -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

11
3rdparty/boost/boost/core/demangle.hpp vendored
View File

@ -27,8 +27,15 @@
#if defined( BOOST_CORE_HAS_CXXABI_H )
# include <cxxabi.h>
# include <cstdlib>
# include <cstddef>
// 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

9
3rdparty/boost/boost/core/enable_if.hpp vendored
View File

@ -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>
{ };

2
3rdparty/boost/boost/cstdint.hpp vendored
View File

@ -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.

10
3rdparty/boost/boost/exception/exception.hpp vendored
View File

@ -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

4
3rdparty/boost/boost/format/feed_args.hpp vendored
View File

@ -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 :

2
3rdparty/boost/boost/functional/hash/hash.hpp vendored
View File

@ -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.

7
3rdparty/boost/boost/lexical_cast.hpp vendored
View File

@ -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>

7
3rdparty/boost/boost/lexical_cast/detail/converter_lexical.hpp vendored
View File

@ -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>

13
3rdparty/boost/boost/lexical_cast/try_lexical_convert.hpp vendored
View File

@ -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

108
3rdparty/boost/boost/math/policies/policy.hpp vendored
View File

@ -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

22
3rdparty/boost/boost/math/special_functions/fpclassify.hpp vendored
View File

@ -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

25
3rdparty/boost/boost/math/special_functions/math_fwd.hpp vendored
View File

@ -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()); }\

69
3rdparty/boost/boost/math/tools/config.hpp vendored
View File

@ -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)
{
}

21
3rdparty/boost/boost/math/tools/promotion.hpp vendored
View File

@ -86,13 +86,20 @@ 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?
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
>::type,
#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;
}; // promote_arg2

4
3rdparty/boost/boost/math/tools/real_cast.hpp vendored
View File

@ -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);
}

4
3rdparty/boost/boost/move/core.hpp vendored
View File

@ -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>

5
3rdparty/boost/boost/move/detail/meta_utils.hpp vendored
View File

@ -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>

30
3rdparty/boost/boost/move/detail/std_ns_begin.hpp vendored Normal file
View File

@ -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

14
3rdparty/boost/boost/move/detail/std_ns_end.hpp vendored Normal file
View File

@ -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

4
3rdparty/boost/boost/move/detail/type_traits.hpp vendored
View File

@ -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;

2
3rdparty/boost/boost/move/utility_core.hpp vendored
View File

@ -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)

2
3rdparty/boost/boost/mpl/string.hpp vendored
View File

@ -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))))

12
3rdparty/boost/boost/none.hpp vendored
View File

@ -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

18
3rdparty/boost/boost/none_t.hpp vendored
View File

@ -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

14
3rdparty/boost/boost/operators.hpp vendored
View File

@ -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) {

1
3rdparty/boost/boost/predef.h vendored
View File

@ -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>

2
3rdparty/boost/boost/predef/detail/_cassert.h vendored
View File

@ -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>

2
3rdparty/boost/boost/predef/detail/_exception.h vendored
View File

@ -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

16
3rdparty/boost/boost/predef/hardware.h vendored Normal file
View File

@ -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

107
3rdparty/boost/boost/predef/hardware/simd.h vendored Normal file
View File

@ -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)

57
3rdparty/boost/boost/predef/hardware/simd/arm.h vendored Normal file
View File

@ -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)

32
3rdparty/boost/boost/predef/hardware/simd/arm/versions.h vendored Normal file
View File

@ -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

69
3rdparty/boost/boost/predef/hardware/simd/ppc.h vendored Normal file
View File

@ -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)

51
3rdparty/boost/boost/predef/hardware/simd/ppc/versions.h vendored Normal file
View File

@ -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

123
3rdparty/boost/boost/predef/hardware/simd/x86.h vendored Normal file
View File

@ -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)

129
3rdparty/boost/boost/predef/hardware/simd/x86/versions.h vendored Normal file
View File

@ -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

87
3rdparty/boost/boost/predef/hardware/simd/x86_amd.h vendored Normal file
View File

@ -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)

51
3rdparty/boost/boost/predef/hardware/simd/x86_amd/versions.h vendored Normal file
View File

@ -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

2
3rdparty/boost/boost/predef/platform/windows_desktop.h vendored
View File

@ -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

2
3rdparty/boost/boost/predef/platform/windows_phone.h vendored
View File

@ -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

2
3rdparty/boost/boost/predef/platform/windows_runtime.h vendored
View File

@ -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

2
3rdparty/boost/boost/predef/platform/windows_store.h vendored
View File

@ -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

2
3rdparty/boost/boost/predef/version.h vendored
View File

@ -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

4
3rdparty/boost/boost/preprocessor/facilities/identity.hpp vendored
View File

@ -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

40
3rdparty/boost/boost/preprocessor/list/append.hpp vendored
View File

@ -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

49
3rdparty/boost/boost/preprocessor/list/transform.hpp vendored
View File

@ -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

11
3rdparty/boost/boost/preprocessor/tuple/eat.hpp vendored
View File

@ -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)

58
3rdparty/boost/boost/regex/config.hpp vendored
View File

@ -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))
# define BOOST_REGEX_NO_FILEITER
#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*);

166
3rdparty/boost/boost/regex/icu.hpp vendored
View File

@ -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;
}

4
3rdparty/boost/boost/regex/pattern_except.hpp vendored
View File

@ -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);
}
}

31
3rdparty/boost/boost/regex/v4/basic_regex.hpp vendored
View File

@ -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;

42
3rdparty/boost/boost/regex/v4/basic_regex_creator.hpp vendored
View File

@ -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

212
3rdparty/boost/boost/regex/v4/basic_regex_parser.hpp vendored
View File

@ -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

211
3rdparty/boost/boost/regex/v4/cpp_regex_traits.hpp vendored
View File

@ -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);
}
}
//
@ -415,8 +415,9 @@ template <class charT>
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 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:

14
3rdparty/boost/boost/regex/v4/cregex.hpp vendored
View File

@ -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

18
3rdparty/boost/boost/regex/v4/fileiter.hpp vendored
View File

@ -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

21
3rdparty/boost/boost/regex/v4/instances.hpp vendored
View File

@ -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

4
3rdparty/boost/boost/regex/v4/iterator_traits.hpp vendored
View File

@ -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

34
3rdparty/boost/boost/regex/v4/match_results.hpp vendored
View File

@ -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)))

2
3rdparty/boost/boost/regex/v4/mem_block_cache.hpp vendored
View File

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

55
3rdparty/boost/boost/regex/v4/perl_matcher.hpp vendored
View File

@ -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)

40
3rdparty/boost/boost/regex/v4/perl_matcher_common.hpp vendored
View File

@ -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

219
3rdparty/boost/boost/regex/v4/perl_matcher_non_recursive.hpp vendored
View File

@ -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

126
3rdparty/boost/boost/regex/v4/perl_matcher_recursive.hpp vendored
View File

@ -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)

4
3rdparty/boost/boost/regex/v4/primary_transform.hpp vendored
View File

@ -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

2
3rdparty/boost/boost/regex/v4/protected_call.hpp vendored
View File

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

28
3rdparty/boost/boost/regex/v4/regex_format.hpp vendored
View File

@ -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,

2
3rdparty/boost/boost/regex/v4/regex_grep.hpp vendored
View File

@ -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())
{

6
3rdparty/boost/boost/regex/v4/regex_iterator.hpp vendored
View File

@ -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;

2
3rdparty/boost/boost/regex/v4/regex_match.hpp vendored
View File

@ -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>

4
3rdparty/boost/boost/regex/v4/regex_raw_buffer.hpp vendored
View File

@ -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

8
3rdparty/boost/boost/regex/v4/regex_replace.hpp vendored
View File

@ -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;
}

4
3rdparty/boost/boost/regex/v4/regex_search.hpp vendored
View File

@ -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();
}

8
3rdparty/boost/boost/regex/v4/regex_split.hpp vendored
View File

@ -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

Some files were not shown because too many files have changed in this diff Show More