passenger 6.0.18 → 6.0.20

data/src/cxx_supportlib/vendor-modified/boost/mp11/list.hpp

@@ -1,7 +1,7 @@
 #ifndef BOOST_MP11_LIST_HPP_INCLUDED
 #define BOOST_MP11_LIST_HPP_INCLUDED
 
-//  Copyright 2015-2017 Peter Dimov.
+//  Copyright 2015-2023 Peter Dimov.
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //
@@ -10,10 +10,12 @@
 
 #include <boost/mp11/integral.hpp>
 #include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_list_v.hpp>
 #include <boost/mp11/detail/mp_is_list.hpp>
-#include <boost/mp11/detail/mp_append.hpp>
+#include <boost/mp11/detail/mp_is_value_list.hpp>
 #include <boost/mp11/detail/mp_front.hpp>
 #include <boost/mp11/detail/mp_rename.hpp>
+#include <boost/mp11/detail/mp_append.hpp>
 #include <boost/mp11/detail/config.hpp>
 #include <type_traits>
 
@@ -22,12 +24,21 @@ namespace boost
 namespace mp11
 {
 
+// mp_list<T...>
+//   in detail/mp_list.hpp
+
 // mp_list_c<T, I...>
 template<class T, T... I> using mp_list_c = mp_list<std::integral_constant<T, I>...>;
 
+// mp_list_v<A...>
+//   in detail/mp_list_v.hpp
+
 // mp_is_list<L>
 //   in detail/mp_is_list.hpp
 
+// mp_is_value_list<L>
+//   in detail/mp_is_value_list.hpp
+
 // mp_size<L>
 namespace detail
 {
@@ -42,6 +53,15 @@ template<template<class...> class L, class... T> struct mp_size_impl<L<T...>>
     using type = mp_size_t<sizeof...(T)>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto... A> struct mp_size_impl<L<A...>>
+{
+    using type = mp_size_t<sizeof...(A)>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L> using mp_size = typename detail::mp_size_impl<L>::type;
@@ -53,13 +73,35 @@ template<class L> using mp_empty = mp_bool< mp_size<L>::value == 0 >;
 namespace detail
 {
 
-template<class L1, class L2> struct mp_assign_impl;
+template<class L1, class L2> struct mp_assign_impl
+{
+// An error "no type named 'type'" here means that the arguments to mp_assign aren't lists
+};
 
 template<template<class...> class L1, class... T, template<class...> class L2, class... U> struct mp_assign_impl<L1<T...>, L2<U...>>
 {
     using type = L1<U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L1, auto... A, template<class...> class L2, class... U> struct mp_assign_impl<L1<A...>, L2<U...>>
+{
+    using type = L1<U::value...>;
+};
+
+template<template<class...> class L1, class... T, template<auto...> class L2, auto... B> struct mp_assign_impl<L1<T...>, L2<B...>>
+{
+    using type = L1<mp_value<B>...>;
+};
+
+template<template<auto...> class L1, auto... A, template<auto...> class L2, auto... B> struct mp_assign_impl<L1<A...>, L2<B...>>
+{
+    using type = L1<B...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L1, class L2> using mp_assign = typename detail::mp_assign_impl<L1, L2>::type;
@@ -85,6 +127,15 @@ template<template<class...> class L, class T1, class... T> struct mp_pop_front_i
     using type = L<T...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto... A> struct mp_pop_front_impl<L<A1, A...>>
+{
+    using type = L<A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L> using mp_pop_front = typename detail::mp_pop_front_impl<L>::type;
@@ -110,6 +161,15 @@ template<template<class...> class L, class T1, class T2, class... T> struct mp_s
     using type = T2;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto... A> struct mp_second_impl<L<A1, A2, A...>>
+{
+    using type = mp_value<A2>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L> using mp_second = typename detail::mp_second_impl<L>::type;
@@ -129,6 +189,15 @@ template<template<class...> class L, class T1, class T2, class T3, class... T> s
     using type = T3;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto A3, auto... A> struct mp_third_impl<L<A1, A2, A3, A...>>
+{
+    using type = mp_value<A3>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L> using mp_third = typename detail::mp_third_impl<L>::type;
@@ -147,6 +216,15 @@ template<template<class...> class L, class... U, class... T> struct mp_push_fron
     using type = L<T..., U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto... A, class... T> struct mp_push_front_impl<L<A...>, T...>
+{
+    using type = L<T::value..., A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, class... T> using mp_push_front = typename detail::mp_push_front_impl<L, T...>::type;
@@ -165,6 +243,15 @@ template<template<class...> class L, class... U, class... T> struct mp_push_back
     using type = L<U..., T...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto... A, class... T> struct mp_push_back_impl<L<A...>, T...>
+{
+    using type = L<A..., T::value...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, class... T> using mp_push_back = typename detail::mp_push_back_impl<L, T...>::type;
@@ -174,6 +261,33 @@ template<class L, class... T> using mp_push_back = typename detail::mp_push_back
 // mp_apply_q<Q, L>
 //   in detail/mp_rename.hpp
 
+// mp_rename_v<L, B>
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+namespace detail
+{
+
+template<class L, template<auto...> class B> struct mp_rename_v_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_rename_v is not a list
+};
+
+template<template<class...> class L, class... T, template<auto...> class B> struct mp_rename_v_impl<L<T...>, B>
+{
+    using type = B<T::value...>;
+};
+
+template<template<auto...> class L, auto... A, template<auto...> class B> struct mp_rename_v_impl<L<A...>, B>
+{
+    using type = B<A...>;
+};
+
+} // namespace detail
+
+template<class L, template<auto...> class B> using mp_rename_v = typename detail::mp_rename_v_impl<L, B>::type;
+
+#endif
+
 // mp_replace_front<L, T>
 namespace detail
 {
@@ -189,6 +303,15 @@ template<template<class...> class L, class U1, class... U, class T> struct mp_re
     using type = L<T, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto... A, class T> struct mp_replace_front_impl<L<A1, A...>, T>
+{
+    using type = L<T::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, class T> using mp_replace_front = typename detail::mp_replace_front_impl<L, T>::type;
@@ -211,6 +334,15 @@ template<template<class...> class L, class U1, class U2, class... U, class T> st
     using type = L<U1, T, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto... A, class T> struct mp_replace_second_impl<L<A1, A2, A...>, T>
+{
+    using type = L<A1, T::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, class T> using mp_replace_second = typename detail::mp_replace_second_impl<L, T>::type;
@@ -230,6 +362,15 @@ template<template<class...> class L, class U1, class U2, class U3, class... U, c
     using type = L<U1, U2, T, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto A3, auto... A, class T> struct mp_replace_third_impl<L<A1, A2, A3, A...>, T>
+{
+    using type = L<A1, A2, T::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, class T> using mp_replace_third = typename detail::mp_replace_third_impl<L, T>::type;
@@ -249,6 +390,15 @@ template<template<class...> class L, class U1, class... U, template<class...> cl
     using type = L<F<U1>, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto... A, template<class...> class F> struct mp_transform_front_impl<L<A1, A...>, F>
+{
+    using type = L<F<mp_value<A1>>::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, template<class...> class F> using mp_transform_front = typename detail::mp_transform_front_impl<L, F>::type;
@@ -273,6 +423,15 @@ template<template<class...> class L, class U1, class U2, class... U, template<cl
     using type = L<U1, F<U2>, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto... A, template<class...> class F> struct mp_transform_second_impl<L<A1, A2, A...>, F>
+{
+    using type = L<A1, F<mp_value<A2>>::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, template<class...> class F> using mp_transform_second = typename detail::mp_transform_second_impl<L, F>::type;
@@ -293,6 +452,15 @@ template<template<class...> class L, class U1, class U2, class U3, class... U, t
     using type = L<U1, U2, F<U3>, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto A3, auto... A, template<class...> class F> struct mp_transform_third_impl<L<A1, A2, A3, A...>, F>
+{
+    using type = L<A1, A2, F<mp_value<A3>>::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, template<class...> class F> using mp_transform_third = typename detail::mp_transform_third_impl<L, F>::type;

data/src/cxx_supportlib/vendor-modified/boost/mp11/utility.hpp

@@ -13,6 +13,7 @@
 #include <boost/mp11/detail/mp_fold.hpp>
 #include <boost/mp11/detail/mp_front.hpp>
 #include <boost/mp11/detail/mp_rename.hpp>
+#include <boost/mp11/detail/mp_defer.hpp>
 #include <boost/mp11/detail/config.hpp>
 
 namespace boost
@@ -33,104 +34,9 @@ template<class T> using mp_identity_t = typename mp_identity<T>::type;
 template<class... T> struct mp_inherit: T... {};
 
 // mp_if, mp_if_c
-namespace detail
-{
-
-template<bool C, class T, class... E> struct mp_if_c_impl
-{
-};
-
-template<class T, class... E> struct mp_if_c_impl<true, T, E...>
-{
-    using type = T;
-};
-
-template<class T, class E> struct mp_if_c_impl<false, T, E>
-{
-    using type = E;
-};
-
-} // namespace detail
-
-template<bool C, class T, class... E> using mp_if_c = typename detail::mp_if_c_impl<C, T, E...>::type;
-template<class C, class T, class... E> using mp_if = typename detail::mp_if_c_impl<static_cast<bool>(C::value), T, E...>::type;
-
 // mp_valid
-
-#if BOOST_MP11_WORKAROUND( BOOST_MP11_INTEL, != 0 ) // tested at 1800
-
-// contributed by Roland Schulz in https://github.com/boostorg/mp11/issues/17
-
-namespace detail
-{
-
-template<class...> using void_t = void;
-
-template<class, template<class...> class F, class... T>
-struct mp_valid_impl: mp_false {};
-
-template<template<class...> class F, class... T>
-struct mp_valid_impl<void_t<F<T...>>, F, T...>: mp_true {};
-
-} // namespace detail
-
-template<template<class...> class F, class... T> using mp_valid = typename detail::mp_valid_impl<void, F, T...>;
-
-#else
-
-// implementation by Bruno Dutra (by the name is_evaluable)
-namespace detail
-{
-
-template<template<class...> class F, class... T> struct mp_valid_impl
-{
-    template<template<class...> class G, class = G<T...>> static mp_true check(int);
-    template<template<class...> class> static mp_false check(...);
-
-    using type = decltype(check<F>(0));
-};
-
-} // namespace detail
-
-template<template<class...> class F, class... T> using mp_valid = typename detail::mp_valid_impl<F, T...>::type;
-
-#endif
-
-template<class Q, class... T> using mp_valid_q = mp_valid<Q::template fn, T...>;
-
 // mp_defer
-namespace detail
-{
-
-template<template<class...> class F, class... T> struct mp_defer_impl
-{
-    using type = F<T...>;
-};
-
-struct mp_no_type
-{
-};
-
-#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
-
-template<template<class...> class F, class... T> struct mp_defer_cuda_workaround
-{
-    using type = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;
-};
-
-#endif
-
-} // namespace detail
-
-#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
-
-template<template<class...> class F, class... T> using mp_defer = typename detail::mp_defer_cuda_workaround< F, T...>::type;
-
-#else
-
-template<template<class...> class F, class... T> using mp_defer = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;
-
-#endif
+//   moved to detail/mp_defer.hpp
 
 // mp_eval_if, mp_eval_if_c
 namespace detail

data/src/cxx_supportlib/vendor-modified/boost/mp11/version.hpp

@@ -11,6 +11,6 @@
 // Same format as BOOST_VERSION:
 //   major * 100000 + minor * 100 + patch
 
-#define BOOST_MP11_VERSION 108100
+#define BOOST_MP11_VERSION 108300
 
 #endif // #ifndef BOOST_MP11_VERSION_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/mpl/assert.hpp

@@ -297,7 +297,7 @@ BOOST_MPL_AUX_ASSERT_CONSTANT( \
       std::size_t \
     , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \
           boost::mpl::assertion_failed<false>( \
-              boost::mpl::assert_arg( (void (*) pred)0, 1 ) \
+              boost::mpl::assert_arg( (void (*) pred)BOOST_NULLPTR, 1 ) \
             ) \
         ) \
     ) \
@@ -310,7 +310,7 @@ BOOST_MPL_AUX_ASSERT_CONSTANT( \
 enum { \
       BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \
           boost::mpl::assertion<false>::failed( \
-              boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) \
+              boost::mpl::assert_not_arg( (void (*) pred)BOOST_NULLPTR, 1 ) \
             ) \
         ) \
 }\
@@ -321,7 +321,7 @@ BOOST_MPL_AUX_ASSERT_CONSTANT( \
       std::size_t \
     , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \
           boost::mpl::assertion_failed<false>( \
-              boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) \
+              boost::mpl::assert_not_arg( (void (*) pred)BOOST_NULLPTR, 1 ) \
             ) \
         ) \
    ) \

data/src/cxx_supportlib/vendor-modified/boost/next_prior.hpp

@@ -15,13 +15,12 @@
 #ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
 #define BOOST_NEXT_PRIOR_HPP_INCLUDED
 
-#include <iterator>
 #include <boost/config.hpp>
-#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/has_plus.hpp>
 #include <boost/type_traits/has_plus_assign.hpp>
 #include <boost/type_traits/has_minus.hpp>
 #include <boost/type_traits/has_minus_assign.hpp>
+#include <boost/iterator/is_iterator.hpp>
 #include <boost/iterator/advance.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
 
@@ -39,46 +38,6 @@ namespace boost {
 
 namespace next_prior_detail {
 
-// The trait attempts to detect if the T type is an iterator. Class-type iterators are assumed
-// to have the nested type iterator_category. Strictly speaking, this is not required to be the
-// case (e.g. a user can specialize iterator_traits for T without defining T::iterator_category).
-// Still, this is a good heuristic in practice, and we can't do anything better anyway.
-// Since C++17 we can test for iterator_traits<T>::iterator_category presence instead as it is
-// required to be only present for iterators.
-template< typename T, typename Void = void >
-struct is_iterator_class
-{
-    static BOOST_CONSTEXPR_OR_CONST bool value = false;
-};
-
-template< typename T >
-struct is_iterator_class<
-    T,
-    typename enable_if_has_type<
-#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
-        typename std::iterator_traits< T >::iterator_category
-#else
-        typename T::iterator_category
-#endif
-    >::type
->
-{
-    static BOOST_CONSTEXPR_OR_CONST bool value = true;
-};
-
-template< typename T >
-struct is_iterator :
-    public is_iterator_class< T >
-{
-};
-
-template< typename T >
-struct is_iterator< T* >
-{
-    static BOOST_CONSTEXPR_OR_CONST bool value = true;
-};
-
-
 template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
 struct next_plus_impl;
 
@@ -107,7 +66,7 @@ struct next_plus_assign_impl< T, Distance, true >
     }
 };
 
-template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
+template< typename T, typename Distance, bool IsIterator = boost::iterators::is_iterator< T >::value >
 struct next_advance_impl :
     public next_plus_assign_impl< T, Distance >
 {
@@ -152,7 +111,7 @@ struct prior_minus_assign_impl< T, Distance, true >
     }
 };
 
-template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
+template< typename T, typename Distance, bool IsIterator = boost::iterators::is_iterator< T >::value >
 struct prior_advance_impl :
     public prior_minus_assign_impl< T, Distance >
 {

data/src/cxx_supportlib/vendor-modified/boost/nondet_random.hpp

@@ -0,0 +1,22 @@
+/* boost nondet_random.hpp header file
+ *
+ * Copyright Jens Maurer 2000
+ * 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)
+ *
+ * $Id$
+ *
+ * Revision history
+ *  2000-02-18  Portability fixes (thanks to Beman Dawes)
+ */
+
+//  See http://www.boost.org/libs/random for documentation.
+
+
+#ifndef BOOST_NONDET_RANDOM_HPP
+#define BOOST_NONDET_RANDOM_HPP
+
+#include <boost/random/random_device.hpp>
+
+#endif /* BOOST_NONDET_RANDOM_HPP */

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/old_optional_implementation.hpp

@@ -336,7 +336,7 @@ class optional_base : public optional_tag
     // No-throw (assuming T::~T() doesn't)
     void reset() BOOST_NOEXCEPT { destroy(); }
 
-    // **DEPPRECATED** Replaces the current value -if any- with 'val'
+    // **DEPRECATED** Replaces the current value -if any- with 'val'
     void reset ( argument_type val ) { assign(val); }
 
     // Returns a pointer to the value if this is initialized, otherwise,
@@ -542,7 +542,7 @@ class optional_base : public optional_tag
     //   Thus, the following overload is needed to properly handle the case when the 'lhs'
     //   is another optional.
     //
-    // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error
+    // For VC<=70 compilers this workaround doesn't work because the compiler issues and error
     // instead of choosing the wrong overload
     //
 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
@@ -629,7 +629,7 @@ class optional_base : public optional_tag
 
     // If T is of reference type, trying to get a pointer to the held value must result in a compile-time error.
     // Decent compilers should disallow conversions from reference_content<T>* to T*, but just in case,
-    // the following olverloads are used to filter out the case and guarantee an error in case of T being a reference.
+    // the following overloads are used to filter out the case and guarantee an error in case of T being a reference.
     pointer_const_type cast_ptr( internal_type const* p, is_not_reference_tag ) const { return p ; }
     pointer_type       cast_ptr( internal_type *      p, is_not_reference_tag )       { return p ; }
     pointer_const_type cast_ptr( internal_type const* p, is_reference_tag     ) const { return &p->get() ; }

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_config.hpp

@@ -53,7 +53,7 @@
 #endif
 
 #if (defined(_MSC_VER) && _MSC_VER <= 1800)
-// on MSCV 2013 and earlier an unwanted temporary is created when you assign from
+// on MSVC 2013 and earlier an unwanted temporary is created when you assign from
 // a const lvalue of integral type. Thus we bind not to the original address but
 // to a temporary. 
 # define BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT
@@ -114,9 +114,9 @@
 #endif
 
 
-// Detect suport for defaulting move operations
+// Detect support for defaulting move operations
 // (some older compilers implement rvalue references,
-// defaulted funcitons but move operations are not special members and cannot be defaulted)
+// defaulted functions but move operations are not special members and cannot be defaulted)
 
 #ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
 # define BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_reference_spec.hpp

@@ -66,7 +66,7 @@ void prevent_assignment_from_false_const_integral()
 {
 #ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES
 #ifdef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT
-    // MSVC compiler without rvalue refernces: we need to disable the asignment from
+    // MSVC compiler without rvalue references: we need to disable the assignment from
     // const integral lvalue reference, as it may be an invalid temporary
     BOOST_STATIC_ASSERT_MSG(!is_const_integral<From>::value, 
                             "binding const lvalue references to integral types is disabled in this compiler");
@@ -130,7 +130,7 @@ public:
         explicit optional(const optional<U&>& rhs) BOOST_NOEXCEPT : ptr_(rhs.get_ptr()) {}
     optional(const optional& rhs) BOOST_NOEXCEPT : ptr_(rhs.get_ptr()) {}
     
-    // the following two implement a 'conditionally explicit' constructor: condition is a hack for buggy compilers with srewed conversion construction from const int
+    // the following two implement a 'conditionally explicit' constructor: condition is a hack for buggy compilers with screwed conversion construction from const int
     template <class U>
       explicit optional(U& rhs, BOOST_DEDUCED_TYPENAME boost::enable_if_c<detail::is_same_decayed<T, U>::value && detail::is_const_integral_bad_for_conversion<U>::value, bool>::type = true) BOOST_NOEXCEPT
       : ptr_(boost::addressof(rhs)) {}

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_relops.hpp

@@ -16,7 +16,7 @@
 namespace boost {
 
 // optional's relational operators ( ==, !=, <, >, <=, >= ) have deep-semantics (compare values).
-// WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointess() in generic code instead.
+// WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointees() in generic code instead.
 
 
 //

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_trivially_copyable_base.hpp

@@ -9,7 +9,7 @@
 // You are welcome to contact the author at:
 //  akrzemi1@gmail.com
 
-// trivilally-copyable version of the storage
+// trivially-copyable version of the storage
 
 template<class T>
 class tc_optional_base : public optional_tag
@@ -142,7 +142,7 @@ class tc_optional_base : public optional_tag
     // No-throw (assuming T::~T() doesn't)
     void reset() BOOST_NOEXCEPT { destroy(); }
 
-    // **DEPPRECATED** Replaces the current value -if any- with 'val'
+    // **DEPRECATED** Replaces the current value -if any- with 'val'
     void reset ( argument_type val ) BOOST_NOEXCEPT { assign(val); }
 
     // Returns a pointer to the value if this is initialized, otherwise,
@@ -455,7 +455,7 @@ class tc_optional_base : public optional_tag
     //   Thus, the following overload is needed to properly handle the case when the 'lhs'
     //   is another optional.
     //
-    // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error
+    // For VC<=70 compilers this workaround doesn't work because the compiler issues and error
     // instead of choosing the wrong overload
     //
 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES

data/src/cxx_supportlib/vendor-modified/boost/optional/optional.hpp

@@ -392,7 +392,7 @@ class optional_base : public optional_tag
     // No-throw (assuming T::~T() doesn't)
     void reset() BOOST_NOEXCEPT { destroy(); }
 
-    // **DEPPRECATED** Replaces the current value -if any- with 'val'
+    // **DEPRECATED** Replaces the current value -if any- with 'val'
     void reset ( argument_type val ) { assign(val); }
 
     // Returns a pointer to the value if this is initialized, otherwise,
@@ -722,7 +722,7 @@ class optional_base : public optional_tag
     //   Thus, the following overload is needed to properly handle the case when the 'lhs'
     //   is another optional.
     //
-    // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error
+    // For VC<=70 compilers this workaround doesn't work because the compiler issues and error
     // instead of choosing the wrong overload
     //
 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES