passenger 6.0.20 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/ratio/detail/gcd_lcm.hpp

@@ -0,0 +1,53 @@
+#ifndef BOOST_RATIO_DETAIL_GCD_LCM_HPP
+#define BOOST_RATIO_DETAIL_GCD_LCM_HPP
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <type_traits>
+#include <cstdint>
+
+namespace boost
+{
+namespace ratio_detail
+{
+
+template<std::intmax_t A> struct abs_: std::integral_constant<std::intmax_t, A < 0? -A: A>
+{
+};
+
+template<> struct abs_<INTMAX_MIN>: std::integral_constant<std::intmax_t, INTMAX_MIN>
+{
+};
+
+template<std::intmax_t A, std::intmax_t B> struct gcd_: public gcd_<B, A % B>
+{
+};
+
+template<std::intmax_t A> struct gcd_<A, 0>: std::integral_constant<std::intmax_t, A>
+{
+};
+
+template<std::intmax_t A, std::intmax_t B> struct lcm_: std::integral_constant<std::intmax_t, (A / gcd_<A, B>::value) * B>
+{
+};
+
+template<> struct lcm_<0, 0>: std::integral_constant<std::intmax_t, 0>
+{
+};
+
+//
+
+template<std::intmax_t A, std::intmax_t B> struct gcd: abs_< gcd_<A, B>::value >
+{
+};
+
+template<std::intmax_t A, std::intmax_t B> struct lcm: abs_< lcm_<A, B>::value >
+{
+};
+
+} // namespace ratio_detail
+} // namespace boost
+
+#endif // BOOST_RATIO_DETAIL_GCD_LCM_HPP

data/src/cxx_supportlib/vendor-modified/boost/ratio/detail/is_evenly_divisible_by.hpp

@@ -0,0 +1,32 @@
+#ifndef BOOST_RATIO_DETAIL_IS_EVENLY_DIVISIBLE_BY_HPP
+#define BOOST_RATIO_DETAIL_IS_EVENLY_DIVISIBLE_BY_HPP
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <type_traits>
+#include <cstdint>
+
+namespace boost
+{
+namespace ratio_detail
+{
+
+template<std::intmax_t A, std::intmax_t B> struct is_evenly_divisible_by_: std::integral_constant<bool, A % B == 0>
+{
+};
+
+template<std::intmax_t A> struct is_evenly_divisible_by_<A, 0>: std::false_type
+{
+};
+
+template<class R1, class R2> struct is_evenly_divisible_by: std::integral_constant<bool,
+    is_evenly_divisible_by_<R1::num, R2::num>::value && is_evenly_divisible_by_<R2::den, R1::den>::value>
+{
+};
+
+} // namespace ratio_detail
+} // namespace boost
+
+#endif // BOOST_RATIO_DETAIL_IS_EVENLY_DIVISIBLE_BY_HPP

data/src/cxx_supportlib/vendor-modified/boost/ratio/detail/is_ratio.hpp

@@ -0,0 +1,28 @@
+#ifndef BOOST_RATIO_DETAIL_IS_RATIO_HPP
+#define BOOST_RATIO_DETAIL_IS_RATIO_HPP
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio_fwd.hpp>
+#include <type_traits>
+#include <cstdint>
+
+namespace boost
+{
+namespace ratio_detail
+{
+
+template<class T> struct is_ratio: std::false_type
+{
+};
+
+template<std::intmax_t A, std::intmax_t B> struct is_ratio< boost::ratio<A, B> >: std::true_type
+{
+};
+
+} // namespace ratio_detail
+} // namespace boost
+
+#endif // BOOST_RATIO_DETAIL_IS_RATIO_HPP

data/src/cxx_supportlib/vendor-modified/boost/ratio/include.hpp

@@ -10,7 +10,5 @@
 
 #include <boost/ratio/ratio.hpp>
 #include <boost/ratio/ratio_io.hpp>
-#ifdef BOOST_RATIO_EXTENSIONS
-#include <boost/ratio/mpl/rational_constant.hpp>
-#endif
+
 #endif  // BOOST_RATIO_INCLUDE_HPP

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

@@ -32,262 +32,18 @@ time2_demo contained this comment:
 #ifndef BOOST_RATIO_RATIO_HPP
 #define BOOST_RATIO_RATIO_HPP
 
-#include <boost/ratio/config.hpp>
-#include <boost/ratio/detail/mpl/abs.hpp>
-#include <boost/ratio/detail/mpl/sign.hpp>
-#include <boost/ratio/detail/mpl/gcd.hpp>
-#include <boost/ratio/detail/mpl/lcm.hpp>
-#include <cstdlib>
-#include <climits>
-#include <limits>
-#include <boost/cstdint.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/integer_traits.hpp>
 #include <boost/ratio/ratio_fwd.hpp>
-#include <boost/ratio/detail/overflow_helpers.hpp>
-#ifdef BOOST_RATIO_EXTENSIONS
-#include <boost/rational.hpp>
-#include <boost/ratio/mpl/rational_c_tag.hpp>
-#endif
-
-//
-// We simply cannot include this header on gcc without getting copious warnings of the kind:
-//
-// boost/integer.hpp:77:30: warning: use of C99 long long integer constant
-//
-// And yet there is no other reasonable implementation, so we declare this a system header
-// to suppress these warnings.
-//
-#if defined(__GNUC__) && (__GNUC__ >= 4)
-#pragma GCC system_header
-#endif
+#include <boost/ratio/detail/gcd_lcm.hpp>
 
 namespace boost
 {
 
+// extension used by Chrono
 
-//----------------------------------------------------------------------------//
-//                                                                            //
-//                20.6.1 Class template ratio [ratio.ratio]                   //
-//                                                                            //
-//----------------------------------------------------------------------------//
-
-template <boost::intmax_t N, boost::intmax_t D>
-class ratio
-{
-    static const boost::intmax_t ABS_N = mpl::abs_c<boost::intmax_t, N>::value;
-    static const boost::intmax_t ABS_D = mpl::abs_c<boost::intmax_t, D>::value;
-    BOOST_RATIO_STATIC_ASSERT(ABS_N >= 0, BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE, ());
-    BOOST_RATIO_STATIC_ASSERT(ABS_D > 0, BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE, ());
-    BOOST_RATIO_STATIC_ASSERT(D != 0, BOOST_RATIO_DIVIDE_BY_0 , ());
-    static const boost::intmax_t SIGN_N = mpl::sign_c<boost::intmax_t,N>::value
-      * mpl::sign_c<boost::intmax_t,D>::value;
-    static const boost::intmax_t GCD = mpl::gcd_c<boost::intmax_t, ABS_N, ABS_D>::value;
-public:
-    BOOST_STATIC_CONSTEXPR boost::intmax_t num = SIGN_N * ABS_N / GCD;
-    BOOST_STATIC_CONSTEXPR boost::intmax_t den = ABS_D / GCD;
-
-#ifdef BOOST_RATIO_EXTENSIONS
-    typedef mpl::rational_c_tag tag;
-    typedef boost::rational<boost::intmax_t> value_type;
-    typedef boost::intmax_t num_type;
-    typedef boost::intmax_t den_type;
-    ratio()
-    {}
-    template <boost::intmax_t _N2, boost::intmax_t _D2>
-    ratio(const ratio<_N2, _D2>&,
-        typename enable_if_c
-            <
-                (ratio<_N2, _D2>::num == num &&
-                ratio<_N2, _D2>::den == den)
-            >::type* = 0)
-    {}
-
-    template <boost::intmax_t _N2, boost::intmax_t _D2>
-        typename enable_if_c
-        <
-            (ratio<_N2, _D2>::num == num &&
-            ratio<_N2, _D2>::den == den),
-            ratio&
-        >::type
-    operator=(const ratio<_N2, _D2>&) {return *this;}
-
-    static value_type value() {return value_type(num,den);}
-    value_type operator()() const {return value();}
-#endif
-    typedef ratio<num, den> type;
-};
-
-#if defined(BOOST_NO_CXX11_CONSTEXPR)
-template <boost::intmax_t N, boost::intmax_t D>
-const    boost::intmax_t ratio<N, D>::num;
-template <boost::intmax_t N, boost::intmax_t D>
-const    boost::intmax_t ratio<N, D>::den;
-#endif
-
-//----------------------------------------------------------------------------//
-//                                                                            //
-//                20.6.2 Arithmetic on ratio types [ratio.arithmetic]         //
-//                                                                            //
-//----------------------------------------------------------------------------//
-
-template <class R1, class R2>
-struct ratio_add
-: boost::ratio_detail::ratio_add<R1, R2>::type
-{
-};
-
-template <class R1, class R2>
-struct ratio_subtract
-: boost::ratio_detail::ratio_subtract<R1, R2>::type
-{
-};
-
-template <class R1, class R2>
-struct ratio_multiply
-: boost::ratio_detail::ratio_multiply<R1, R2>::type
-{
-};
-
-template <class R1, class R2>
-struct ratio_divide
-: boost::ratio_detail::ratio_divide<R1, R2>::type
-{
-};
-
-//----------------------------------------------------------------------------//
-//                                                                            //
-//                20.6.3 Comparision of ratio types [ratio.comparison]        //
-//                                                                            //
-//----------------------------------------------------------------------------//
-
-// ratio_equal
-
-template <class R1, class R2>
-struct ratio_equal
-    : public boost::integral_constant<bool,
-                               (R1::num == R2::num && R1::den == R2::den)>
-{};
-
-template <class R1, class R2>
-struct ratio_not_equal
-    : public boost::integral_constant<bool, !ratio_equal<R1, R2>::value>
-{};
-
-// ratio_less
-
-template <class R1, class R2>
-struct ratio_less
-    : boost::integral_constant<bool, boost::ratio_detail::ratio_less<R1, R2>::value>
-{};
-
-template <class R1, class R2>
-struct ratio_less_equal
-    : boost::integral_constant<bool, !ratio_less<R2, R1>::value>
-{};
-
-template <class R1, class R2>
-struct ratio_greater
-    : boost::integral_constant<bool, ratio_less<R2, R1>::value>
-{};
-
-template <class R1, class R2>
-struct ratio_greater_equal
-    : boost::integral_constant<bool, !ratio_less<R1, R2>::value>
-{};
-
-template <class R1, class R2>
-struct ratio_gcd :
-    ratio<mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value,
-        mpl::lcm_c<boost::intmax_t, R1::den, R2::den>::value>::type
-{
-};
-
-    //----------------------------------------------------------------------------//
-    //                                                                            //
-    //                More arithmetic on ratio types [ratio.arithmetic]           //
-    //                                                                            //
-    //----------------------------------------------------------------------------//
-
-#ifdef BOOST_RATIO_EXTENSIONS
-template <class R>
-struct ratio_negate
-    : ratio<-R::num, R::den>::type
-{
-};
-template <class R>
-struct ratio_abs
-    : ratio<mpl::abs_c<boost::intmax_t, R::num>::value, R::den>::type
-{
-};
-template <class R>
-struct ratio_sign
-    : mpl::sign_c<boost::intmax_t, R::num>
-{
-};
+template <class R1, class R2> using ratio_gcd = typename ratio<
+    ratio_detail::gcd<R1::num, R2::num>::value,
+    ratio_detail::lcm<R1::den, R2::den>::value>::type;
 
-template <class R>
-struct ratio_inverse
-    : ratio<R::den, R::num>::type
-{
-};
-
-
-template <class R1, class R2>
-struct ratio_lcm :
-    ratio<mpl::lcm_c<boost::intmax_t, R1::num, R2::num>::value,
-        mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value>::type
-{
-};
-
-template <class R1, class R2>
-struct ratio_modulo :
-    ratio<(R1::num * R2::den) % (R2::num * R1::den), R1::den * R2::den>::type
-{
-};
-
-namespace detail {
-  template <class R1, class R2, bool r1ltr2>
-  struct ratio_min : R1 {};
-  template <class R1, class R2>
-  struct ratio_min<R1,R2,false> : R2 {};
-
-  template <class R1, class R2, bool r1ltr2>
-  struct ratio_max : R2 {};
-  template <class R1, class R2>
-  struct ratio_max<R1,R2,false> : R1 {};
-}
-
-template <class R1, class R2>
-struct ratio_min : detail::ratio_min<R1, R2, ratio_less<R1,R2>::value>::type
-{
-};
-
-template <class R1, class R2>
-struct ratio_max : detail::ratio_max<R1, R2, ratio_less<R1,R2>::value>::type
-{
-};
-
-template<typename R, int p>
-struct ratio_power :
-  ratio_multiply<
-    typename ratio_power<R, p%2>::type,
-    typename ratio_power<typename ratio_multiply<R, R>::type, p/2>::type
-  >::type
-{};
-
-template<typename R>
-struct ratio_power<R, 0> : ratio<1>::type {};
-
-template<typename R>
-struct ratio_power<R, 1> : R {};
-
-template<typename R>
-struct ratio_power<R, -1> : ratio_divide<ratio<1>, R>::type {};
-
-#endif
 }  // namespace boost
 
-
 #endif  // BOOST_RATIO_RATIO_HPP

data/src/cxx_supportlib/vendor-modified/boost/ratio/ratio_fwd.hpp

@@ -32,11 +32,7 @@ time2_demo contained this comment:
 #ifndef BOOST_RATIO_RATIO_FWD_HPP
 #define BOOST_RATIO_RATIO_FWD_HPP
 
-#include <boost/ratio/config.hpp>
-
-#if defined(__GNUC__) && (__GNUC__ >= 4)
-#pragma GCC system_header
-#endif
+#include <ratio>
 
 namespace boost
 {
@@ -48,62 +44,40 @@ namespace boost
 //----------------------------------------------------------------------------//
 
 // ratio
-template <boost::intmax_t N, boost::intmax_t D = 1> class ratio;
+using std::ratio;
 
 // ratio arithmetic
-template <class R1, class R2> struct ratio_add;
-template <class R1, class R2> struct ratio_subtract;
-template <class R1, class R2> struct ratio_multiply;
-template <class R1, class R2> struct ratio_divide;
-#ifdef BOOST_RATIO_EXTENSIONS
-template <class R1, class R2> struct ratio_gcd;
-template <class R1, class R2> struct ratio_lcm;
-template <class R> struct ratio_negate;
-template <class R> struct ratio_abs;
-template <class R> struct ratio_sign;
-template <class R, int P> struct ratio_power;
-#endif
+using std::ratio_add;
+using std::ratio_subtract;
+using std::ratio_multiply;
+using std::ratio_divide;
 
 // ratio comparison
-template <class R1, class R2> struct ratio_equal;
-template <class R1, class R2> struct ratio_not_equal;
-template <class R1, class R2> struct ratio_less;
-template <class R1, class R2> struct ratio_less_equal;
-template <class R1, class R2> struct ratio_greater;
-template <class R1, class R2> struct ratio_greater_equal;
+using std::ratio_equal;
+using std::ratio_not_equal;
+using std::ratio_less;
+using std::ratio_less_equal;
+using std::ratio_greater;
+using std::ratio_greater_equal;
 
 // convenience SI typedefs
-typedef ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(1000000000000000000)> atto;
-typedef ratio<BOOST_RATIO_INTMAX_C(1),    BOOST_RATIO_INTMAX_C(1000000000000000)> femto;
-typedef ratio<BOOST_RATIO_INTMAX_C(1),       BOOST_RATIO_INTMAX_C(1000000000000)> pico;
-typedef ratio<BOOST_RATIO_INTMAX_C(1),          BOOST_RATIO_INTMAX_C(1000000000)> nano;
-typedef ratio<BOOST_RATIO_INTMAX_C(1),             BOOST_RATIO_INTMAX_C(1000000)> micro;
-typedef ratio<BOOST_RATIO_INTMAX_C(1),                BOOST_RATIO_INTMAX_C(1000)> milli;
-typedef ratio<BOOST_RATIO_INTMAX_C(1),                 BOOST_RATIO_INTMAX_C(100)> centi;
-typedef ratio<BOOST_RATIO_INTMAX_C(1),                  BOOST_RATIO_INTMAX_C(10)> deci;
-typedef ratio<                 BOOST_RATIO_INTMAX_C(10), BOOST_RATIO_INTMAX_C(1)> deca;
-typedef ratio<                BOOST_RATIO_INTMAX_C(100), BOOST_RATIO_INTMAX_C(1)> hecto;
-typedef ratio<               BOOST_RATIO_INTMAX_C(1000), BOOST_RATIO_INTMAX_C(1)> kilo;
-typedef ratio<            BOOST_RATIO_INTMAX_C(1000000), BOOST_RATIO_INTMAX_C(1)> mega;
-typedef ratio<         BOOST_RATIO_INTMAX_C(1000000000), BOOST_RATIO_INTMAX_C(1)> giga;
-typedef ratio<      BOOST_RATIO_INTMAX_C(1000000000000), BOOST_RATIO_INTMAX_C(1)> tera;
-typedef ratio<   BOOST_RATIO_INTMAX_C(1000000000000000), BOOST_RATIO_INTMAX_C(1)> peta;
-typedef ratio<BOOST_RATIO_INTMAX_C(1000000000000000000), BOOST_RATIO_INTMAX_C(1)> exa;
-
-#ifdef BOOST_RATIO_EXTENSIONS
-
-#define BOOST_RATIO_1024 BOOST_RATIO_INTMAX_C(1024)
-
-// convenience IEC typedefs
-typedef ratio<                                                                                     BOOST_RATIO_1024> kibi;
-typedef ratio<                                                                    BOOST_RATIO_1024*BOOST_RATIO_1024> mebi;
-typedef ratio<                                                   BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> gibi;
-typedef ratio<                                  BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> tebi;
-typedef ratio<                 BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> pebi;
-typedef ratio<BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> exbi;
-
-#endif
-}  // namespace boost
+using std::atto;
+using std::femto;
+using std::pico;
+using std::nano;
+using std::micro;
+using std::milli;
+using std::centi;
+using std::deci;
+using std::deca;
+using std::hecto;
+using std::kilo;
+using std::mega;
+using std::giga;
+using std::tera;
+using std::peta;
+using std::exa;
 
+}  // namespace boost
 
-#endif  // BOOST_RATIO_HPP
+#endif  // BOOST_RATIO_RATIO_FWD_HPP