passenger 6.0.20 → 6.0.22

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/converter_numeric.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2023.
+// Copyright Antony Polukhin, 2011-2024.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -23,120 +23,128 @@
 #   pragma once
 #endif
 
+#include <boost/core/cmath.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/limits.hpp>
 #include <boost/type_traits/type_identity.hpp>
 #include <boost/type_traits/conditional.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
 #include <boost/type_traits/is_signed.hpp>
-#include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/is_base_of.hpp>
 #include <boost/type_traits/is_float.hpp>
-#include <boost/type_traits/remove_volatile.hpp>
-
-#include <boost/numeric/conversion/cast.hpp>
 
 namespace boost { namespace detail {
 
-template <class Source >
-struct detect_precision_loss
-{
-    typedef Source source_type;
-    typedef boost::numeric::Trunc<Source> Rounder;
-    typedef BOOST_DEDUCED_TYPENAME conditional<
-        boost::is_arithmetic<Source>::value, Source, Source const&
-    >::type argument_type ;
-
-    static inline source_type nearbyint(argument_type s, bool& is_ok) BOOST_NOEXCEPT {
-        const source_type near_int = Rounder::nearbyint(s);
-        if (near_int && is_ok) {
-            const source_type orig_div_round = s / near_int;
-            const source_type eps = std::numeric_limits<source_type>::epsilon();
-
-            is_ok = !((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps);
-        }
+template <class Source, class Target>
+bool ios_numeric_comparer_float(Source x, Source y) noexcept {
+    return x == y
+        || (boost::core::isnan(x) && boost::core::isnan(y))
+        || (x < (std::numeric_limits<Target>::min)())
+    ;
+}
+
+template <class RangeType, class T>
+constexpr bool is_out_of_range_for(T value) noexcept {
+    return value > static_cast<T>((std::numeric_limits<RangeType>::max)())
+        || value < static_cast<T>((std::numeric_limits<RangeType>::min)());
+}
+
 
-        return s;
+// integral -> integral
+template <typename Target, typename Source>
+typename boost::enable_if_c<
+    !boost::is_floating_point<Source>::value && !boost::is_floating_point<Target>::value, bool
+>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
+    const Target target_tmp = static_cast<Target>(arg);
+    const Source arg_restored = static_cast<Source>(target_tmp);
+    if (arg == arg_restored) {
+        result = target_tmp;
+        return true;
     }
+    return false;
+}
 
-    typedef typename Rounder::round_style round_style;
-};
+// integral -> floating point
+template <typename Target, typename Source>
+typename boost::enable_if_c<
+    !boost::is_floating_point<Source>::value && boost::is_floating_point<Target>::value, bool
+>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
+    const Target target_tmp = static_cast<Target>(arg);
+    result = target_tmp;
+    return true;
+}
 
-template <typename Base, class Source>
-struct fake_precision_loss: public Base
-{
-    typedef Source source_type ;
-    typedef BOOST_DEDUCED_TYPENAME conditional<
-        boost::is_arithmetic<Source>::value, Source, Source const&
-    >::type argument_type ;
 
-    static inline source_type nearbyint(argument_type s, bool& /*is_ok*/) BOOST_NOEXCEPT {
-        return s;
+// floating point -> floating point
+template <typename Target, typename Source>
+typename boost::enable_if_c<
+    boost::is_floating_point<Source>::value && boost::is_floating_point<Target>::value, bool
+>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
+    const Target target_tmp = static_cast<Target>(arg);
+    const Source arg_restored = static_cast<Source>(target_tmp);
+    if (detail::ios_numeric_comparer_float<Source, Target>(arg, arg_restored)) {
+        result = target_tmp;
+        return true;
     }
-};
 
-struct nothrow_overflow_handler
-{
-    inline bool operator() ( boost::numeric::range_check_result r ) const BOOST_NOEXCEPT {
-        return (r == boost::numeric::cInRange);
-    }
-};
+    return false;
+}
 
+// floating point -> integral
 template <typename Target, typename Source>
-inline bool noexcept_numeric_convert(const Source& arg, Target& result) BOOST_NOEXCEPT {
-    typedef boost::numeric::converter<
-            Target,
-            Source,
-            boost::numeric::conversion_traits<Target, Source >,
-            nothrow_overflow_handler,
-            detect_precision_loss<Source >
-    > converter_orig_t;
-
-    typedef BOOST_DEDUCED_TYPENAME boost::conditional<
-        boost::is_base_of< detect_precision_loss<Source >, converter_orig_t >::value,
-        converter_orig_t,
-        fake_precision_loss<converter_orig_t, Source>
-    >::type converter_t;
-
-    bool res = nothrow_overflow_handler()(converter_t::out_of_range(arg));
-    if (res) {
-        result = converter_t::low_level_convert(converter_t::nearbyint(arg, res));
+typename boost::enable_if_c<
+    boost::is_floating_point<Source>::value && !boost::is_floating_point<Target>::value, bool
+>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
+    if (detail::is_out_of_range_for<Target>(arg)) {
+        return false;
     }
 
-    return res;
+    const Target target_tmp = static_cast<Target>(arg);
+    const Source arg_restored = static_cast<Source>(target_tmp);
+    if (detail::ios_numeric_comparer_float<Source, Target>(arg, arg_restored)) {
+        result = target_tmp;
+        return true;
+    }
+
+    return false;
 }
 
-template <typename Target, typename Source>
 struct lexical_cast_dynamic_num_not_ignoring_minus
 {
-    static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
-        return noexcept_numeric_convert<Target, Source >(arg, result);
+    template <typename Target, typename Source>
+    static inline bool try_convert(Source arg, Target& result) noexcept {
+        return boost::detail::noexcept_numeric_convert<Target, Source >(arg, result);
     }
 };
 
-template <typename Target, typename Source>
 struct lexical_cast_dynamic_num_ignoring_minus
 {
-    static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
-        typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+    template <typename Target, typename Source>
+#if defined(__clang__) && (__clang_major__ > 3 || __clang_minor__ > 6)
+    __attribute__((no_sanitize("unsigned-integer-overflow")))
+#endif
+    static inline bool try_convert(Source arg, Target& result) noexcept {
+        typedef typename boost::conditional<
                 boost::is_float<Source>::value,
                 boost::type_identity<Source>,
                 boost::make_unsigned<Source>
         >::type usource_lazy_t;
-        typedef BOOST_DEDUCED_TYPENAME usource_lazy_t::type usource_t;
+        typedef typename usource_lazy_t::type usource_t;
 
         if (arg < 0) {
-            const bool res = noexcept_numeric_convert<Target, usource_t>(0u - arg, result);
+            const bool res = boost::detail::noexcept_numeric_convert<Target, usource_t>(
+                static_cast<usource_t>(0u - static_cast<usource_t>(arg)), result
+            );
             result = static_cast<Target>(0u - result);
             return res;
         } else {
-            return noexcept_numeric_convert<Target, usource_t>(arg, result);
+            return boost::detail::noexcept_numeric_convert<Target, usource_t>(arg, result);
         }
     }
 };
 
 /*
- * lexical_cast_dynamic_num follows the rules:
+ * dynamic_num_converter_impl follows the rules:
  * 1) If Source can be converted to Target without precision loss and
  * without overflows, then assign Source to Target and return
  *
@@ -156,16 +164,14 @@ struct lexical_cast_dynamic_num_ignoring_minus
 template <typename Target, typename Source>
 struct dynamic_num_converter_impl
 {
-    typedef BOOST_DEDUCED_TYPENAME boost::remove_volatile<Source>::type source_type;
-
-    static inline bool try_convert(source_type arg, Target& result) BOOST_NOEXCEPT {
-        typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+    static inline bool try_convert(Source arg, Target& result) noexcept {
+        typedef typename boost::conditional<
             boost::is_unsigned<Target>::value &&
-            (boost::is_signed<source_type>::value || boost::is_float<source_type>::value) &&
-            !(boost::is_same<source_type, bool>::value) &&
+            (boost::is_signed<Source>::value || boost::is_float<Source>::value) &&
+            !(boost::is_same<Source, bool>::value) &&
             !(boost::is_same<Target, bool>::value),
-            lexical_cast_dynamic_num_ignoring_minus<Target, source_type>,
-            lexical_cast_dynamic_num_not_ignoring_minus<Target, source_type>
+            lexical_cast_dynamic_num_ignoring_minus,
+            lexical_cast_dynamic_num_not_ignoring_minus
         >::type caster_type;
 
         return caster_type::try_convert(arg, result);

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/inf_nan.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2023.
+// Copyright Antony Polukhin, 2011-2024.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -39,7 +39,7 @@ namespace boost {
     namespace detail
     {
         template <class CharT>
-        bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) BOOST_NOEXCEPT {
+        bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) noexcept {
             for( unsigned int i=0; i < len; ++i ) {
                 if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
             }
@@ -52,7 +52,7 @@ namespace boost {
         inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
             , const CharT* lc_NAN, const CharT* lc_nan
             , const CharT* lc_INFINITY, const CharT* lc_infinity
-            , const CharT opening_brace, const CharT closing_brace) BOOST_NOEXCEPT
+            , const CharT opening_brace, const CharT closing_brace) noexcept
         {
             if (begin == end) return false;
             const CharT minus = lcast_char_constants<CharT>::minus;
@@ -100,38 +100,31 @@ namespace boost {
         }
 
         template <class CharT, class T>
-        bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
+        const CharT* get_inf_nan_impl(T value
                          , const CharT* lc_nan
-                         , const CharT* lc_infinity) BOOST_NOEXCEPT
+                         , const CharT* lc_minus_nan
+                         , const CharT* lc_infinity
+                         , const CharT* lc_minus_infinity) noexcept
         {
-            const CharT minus = lcast_char_constants<CharT>::minus;
             if (boost::core::isnan(value)) {
                 if (boost::core::signbit(value)) {
-                    *begin = minus;
-                    ++ begin;
+                    return lc_minus_nan;
                 }
-
-                std::memcpy(begin, lc_nan, 3 * sizeof(CharT));
-                end = begin + 3;
-                return true;
+                return lc_nan;
             } else if (boost::core::isinf(value)) {
                 if (boost::core::signbit(value)) {
-                    *begin = minus;
-                    ++ begin;
+                    return lc_minus_infinity;
                 }
-
-                std::memcpy(begin, lc_infinity, 3 * sizeof(CharT));
-                end = begin + 3;
-                return true;
+                return lc_infinity;
             }
 
-            return false;
+            return nullptr;
         }
 
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
         template <class T>
-        bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT {
+        bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) noexcept {
             return parse_inf_nan_impl(begin, end, value
                                , L"NAN", L"nan"
                                , L"INFINITY", L"infinity"
@@ -139,14 +132,14 @@ namespace boost {
         }
 
         template <class T>
-        bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT {
-            return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
+        const wchar_t* get_inf_nan(T value, wchar_t) noexcept {
+            return detail::get_inf_nan_impl(value, L"nan", L"-nan", L"inf", L"-inf");
         }
 
 #endif
 #if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
         template <class T>
-        bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT {
+        bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) noexcept {
             return parse_inf_nan_impl(begin, end, value
                                , u"NAN", u"nan"
                                , u"INFINITY", u"infinity"
@@ -154,13 +147,13 @@ namespace boost {
         }
 
         template <class T>
-        bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT {
-            return put_inf_nan_impl(begin, end, value, u"nan", u"infinity");
+        const char16_t* get_inf_nan(T value, char16_t) noexcept {
+            return detail::get_inf_nan_impl(value, u"nan", u"-nan", u"inf", u"-inf");
         }
 #endif
 #if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
         template <class T>
-        bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT {
+        bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) noexcept {
             return parse_inf_nan_impl(begin, end, value
                                , U"NAN", U"nan"
                                , U"INFINITY", U"infinity"
@@ -168,22 +161,22 @@ namespace boost {
         }
 
         template <class T>
-        bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT {
-            return put_inf_nan_impl(begin, end, value, U"nan", U"infinity");
+        const char32_t* get_inf_nan(T value, char32_t) noexcept {
+            return detail::get_inf_nan_impl(value, U"nan", U"-nan", U"inf", U"-inf");
         }
 #endif
 
         template <class CharT, class T>
-        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT {
+        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) noexcept {
             return parse_inf_nan_impl(begin, end, value
                                , "NAN", "nan"
                                , "INFINITY", "infinity"
                                , '(', ')');
         }
 
-        template <class CharT, class T>
-        bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT {
-            return put_inf_nan_impl(begin, end, value, "nan", "infinity");
+        template <class T>
+        const char* get_inf_nan(T value, char) noexcept {
+            return detail::get_inf_nan_impl(value, "nan", "-nan", "inf", "-inf");
         }
     }
 } // namespace boost

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/is_character.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2023.
+// Copyright Antony Polukhin, 2011-2024.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -26,34 +26,27 @@
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/is_same.hpp>
 
-namespace boost {
-
-    namespace detail // is_character<...>
-    {
-        // returns true, if T is one of the character types
-        template < typename T >
-        struct is_character
-        {
-            typedef BOOST_DEDUCED_TYPENAME boost::integral_constant<
-                bool,
-                boost::is_same< T, char >::value ||
-                    #if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
-                        boost::is_same< T, wchar_t >::value ||
-                    #endif
-                    #ifndef BOOST_NO_CXX11_CHAR16_T
-                        boost::is_same< T, char16_t >::value ||
-                    #endif
-                    #ifndef BOOST_NO_CXX11_CHAR32_T
-                        boost::is_same< T, char32_t >::value ||
-                    #endif
-                        boost::is_same< T, unsigned char >::value ||
-                        boost::is_same< T, signed char >::value
-            > type;
-
-            BOOST_STATIC_CONSTANT(bool, value = (type::value) );
-        };
-    }
-}
+namespace boost { namespace detail {
+
+// returns true, if T is one of the character types
+template < typename T >
+using is_character = boost::integral_constant<
+    bool,
+    boost::is_same< T, char >::value ||
+#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
+    boost::is_same< T, wchar_t >::value ||
+#endif
+#ifndef BOOST_NO_CXX11_CHAR16_T
+    boost::is_same< T, char16_t >::value ||
+#endif
+#ifndef BOOST_NO_CXX11_CHAR32_T
+    boost::is_same< T, char32_t >::value ||
+#endif
+    boost::is_same< T, unsigned char >::value ||
+    boost::is_same< T, signed char >::value
+>;
+
+}}
 
 #endif // BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP
 

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/lcast_basic_unlockedbuf.hpp

@@ -0,0 +1,73 @@
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2024.
+//
+// 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_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_BASIC_UNLOCKEDBUF_HPP
+#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_BASIC_UNLOCKEDBUF_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#   pragma once
+#endif
+
+
+#ifdef BOOST_NO_STRINGSTREAM
+#include <strstream>
+#else
+#include <sstream>
+#endif
+
+#include <boost/detail/basic_pointerbuf.hpp>
+#ifndef BOOST_NO_CWCHAR
+#   include <cwchar>
+#endif
+
+namespace boost { namespace detail { namespace lcast {
+
+    // acts as a stream buffer which wraps around a pair of pointers
+    // and gives acces to internals
+    template <class BufferType, class CharT>
+    class basic_unlockedbuf : public basic_pointerbuf<CharT, BufferType> {
+    public:
+        typedef basic_pointerbuf<CharT, BufferType> base_type;
+        typedef typename base_type::streamsize streamsize;
+
+        using base_type::pptr;
+        using base_type::pbase;
+        using base_type::setbuf;
+    };
+
+#if defined(BOOST_NO_STRINGSTREAM)
+    template <class CharT, class Traits>
+    using out_stream_t = std::ostream;
+
+    template <class CharT, class Traits>
+    using stringbuffer_t = basic_unlockedbuf<std::strstreambuf, char>;
+#elif defined(BOOST_NO_STD_LOCALE)
+    template <class CharT, class Traits>
+    using out_stream_t = std::ostream;
+
+    template <class CharT, class Traits>
+    using stringbuffer_t = basic_unlockedbuf<std::stringbuf, char>;
+
+    template <class CharT, class Traits>
+    using buffer_t = basic_unlockedbuf<std::streambuf, char>;
+#else
+    template <class CharT, class Traits>
+    using out_stream_t = std::basic_ostream<CharT, Traits>;
+
+    template <class CharT, class Traits>
+    using stringbuffer_t = basic_unlockedbuf<std::basic_stringbuf<CharT, Traits>, CharT>;
+
+    template <class CharT, class Traits>
+    using buffer_t = basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT>;
+#endif
+
+}}} // namespace boost::detail::lcast
+
+#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_BASIC_UNLOCKEDBUF_HPP
+

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/lcast_char_constants.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2023.
+// Copyright Antony Polukhin, 2011-2024.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/lcast_unsigned_converters.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2023.
+// Copyright Antony Polukhin, 2011-2024.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -30,7 +30,6 @@
 #include <cstdio>
 #include <boost/limits.hpp>
 #include <boost/type_traits/conditional.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/detail/workaround.hpp>
 
 
@@ -57,9 +56,12 @@ namespace boost
     namespace detail // lcast_to_unsigned
     {
         template<class T>
+#if defined(__clang__) && (__clang_major__ > 3 || __clang_minor__ > 6)
+       __attribute__((no_sanitize("unsigned-integer-overflow")))
+#endif
         inline
-        BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type lcast_to_unsigned(const T value) BOOST_NOEXCEPT {
-            typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type result_type;
+        typename boost::make_unsigned<T>::type lcast_to_unsigned(const T value) noexcept {
+            typedef typename boost::make_unsigned<T>::type result_type;
             return value < 0
                 ? static_cast<result_type>(0u - static_cast<result_type>(value))
                 : static_cast<result_type>(value);
@@ -70,8 +72,8 @@ namespace boost
     {
         template <class Traits, class T, class CharT>
         class lcast_put_unsigned: boost::noncopyable {
-            typedef BOOST_DEDUCED_TYPENAME Traits::int_type int_type;
-            BOOST_DEDUCED_TYPENAME boost::conditional<
+            typedef typename Traits::int_type int_type;
+            typename boost::conditional<
                     (sizeof(unsigned) > sizeof(T))
                     , unsigned
                     , T
@@ -81,12 +83,12 @@ namespace boost
             int_type const  m_zero;
 
         public:
-            lcast_put_unsigned(const T n_param, CharT* finish) BOOST_NOEXCEPT
+            lcast_put_unsigned(const T n_param, CharT* finish) noexcept
                 : m_value(n_param), m_finish(finish)
                 , m_czero(lcast_char_constants<CharT>::zero), m_zero(Traits::to_int_type(m_czero))
             {
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-                BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
+                static_assert(!std::numeric_limits<T>::is_signed, "");
 #endif
             }
 
@@ -108,7 +110,7 @@ namespace boost
 
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
                 // Check that ulimited group is unreachable:
-                BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX);
+                static_assert(std::numeric_limits<T>::digits10 < CHAR_MAX, "");
 #endif
                 CharT const thousands_sep = np.thousands_sep();
                 std::string::size_type group = 0; // current group number
@@ -138,7 +140,7 @@ namespace boost
             }
 
         private:
-            inline bool main_convert_iteration() BOOST_NOEXCEPT {
+            inline bool main_convert_iteration() noexcept {
                 --m_finish;
                 int_type const digit = static_cast<int_type>(m_value % 10U);
                 Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit));
@@ -146,7 +148,7 @@ namespace boost
                 return !!m_value; // suppressing warnings
             }
 
-            inline CharT* main_convert_loop() BOOST_NOEXCEPT {
+            inline CharT* main_convert_loop() noexcept {
                 while (main_convert_iteration());
                 return m_finish;
             }
@@ -164,18 +166,18 @@ namespace boost
             const CharT* m_end;
 
         public:
-            lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) BOOST_NOEXCEPT
+            lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) noexcept
                 : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end)
             {
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-                BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
+                static_assert(!std::numeric_limits<T>::is_signed, "");
 
                 // GCC when used with flag -std=c++0x may not have std::numeric_limits
                 // specializations for __int128 and unsigned __int128 types.
                 // Try compilation with -std=gnu++0x or -std=gnu++11.
                 //
                 // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856
-                BOOST_STATIC_ASSERT_MSG(std::numeric_limits<T>::is_specialized,
+                static_assert(std::numeric_limits<T>::is_specialized,
                     "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast"
                 );
 #endif
@@ -252,7 +254,10 @@ namespace boost
         private:
             // Iteration that does not care about grouping/separators and assumes that all
             // input characters are digits
-            inline bool main_convert_iteration() BOOST_NOEXCEPT {
+#if defined(__clang__) && (__clang_major__ > 3 || __clang_minor__ > 6)
+            __attribute__((no_sanitize("unsigned-integer-overflow")))
+#endif
+            inline bool main_convert_iteration() noexcept {
                 CharT const czero = lcast_char_constants<CharT>::zero;
                 T const maxv = (std::numeric_limits<T>::max)();
 
@@ -277,7 +282,7 @@ namespace boost
                 return true;
             }
 
-            bool main_convert_loop() BOOST_NOEXCEPT {
+            bool main_convert_loop() noexcept {
                 for ( ; m_end >= m_begin; --m_end) {
                     if (!main_convert_iteration()) {
                         return false;