passenger 6.0.3 → 6.0.8

data/src/cxx_supportlib/vendor-modified/boost/core/use_default.hpp

@@ -0,0 +1,17 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_USE_DEFAULT_HPP
+#define BOOST_CORE_USE_DEFAULT_HPP
+
+namespace boost {
+
+struct use_default { };
+
+} /* boost */
+
+#endif

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

@@ -52,9 +52,9 @@
 // so we disable use of stdint.h when GLIBC does not define __GLIBC_HAVE_LONG_LONG.
 // See https://svn.boost.org/trac/boost/ticket/3548 and http://sources.redhat.com/bugzilla/show_bug.cgi?id=10990
 //
-#if defined(BOOST_HAS_STDINT_H)					\
-  && (!defined(__GLIBC__)					\
-      || defined(__GLIBC_HAVE_LONG_LONG)			\
+#if defined(BOOST_HAS_STDINT_H)            \
+  && (!defined(__GLIBC__)                  \
+      || defined(__GLIBC_HAVE_LONG_LONG)   \
       || (defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 17)))))
 
 // The following #include is an implementation artifact; not part of interface.
@@ -306,7 +306,7 @@ namespace boost
 //  64-bit types + intmax_t and uintmax_t  ----------------------------------//
 
 # if defined(BOOST_HAS_LONG_LONG) && \
-   !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \
+   !defined(BOOST_MSVC) && !defined(BOOST_BORLANDC) && \
    (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
    (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
 #    if defined(__hpux)
@@ -451,7 +451,7 @@ INT#_C macros if they're not already defined (John Maddock).
 #ifndef INT64_C
 #  define INT64_C(value)    value##i64
 #endif
-#  ifdef __BORLANDC__
+#  ifdef BOOST_BORLANDC
     // Borland bug: appending ui8 makes the type a signed char
 #   define UINT8_C(value)    static_cast<unsigned char>(value##u)
 #  else

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

@@ -10,13 +10,13 @@
 //
 //  boost/current_function.hpp - BOOST_CURRENT_FUNCTION
 //
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright 2002-2018 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
 //
-//  http://www.boost.org/libs/assert/current_function.html
+//  http://www.boost.org/libs/assert
 //
 
 namespace boost
@@ -32,7 +32,7 @@ inline void current_function_helper()
 
 # define BOOST_CURRENT_FUNCTION "(unknown)"
 
-#elif defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__)
+#elif defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__) || defined(__clang__)
 
 # define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
 

data/src/cxx_supportlib/vendor-modified/boost/date_time/c_time.hpp

@@ -90,10 +90,13 @@ namespace date_time {
       }
 #else // BOOST_DATE_TIME_HAS_REENTRANT_STD_FUNCTIONS
 
-#if (defined(_MSC_VER) && (_MSC_VER >= 1400))
+#if defined(__clang__) // Clang has to be checked before MSVC
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#elif (defined(_MSC_VER) && (_MSC_VER >= 1400))
 #pragma warning(push) // preserve warning settings
 #pragma warning(disable : 4996) // disable depricated localtime/gmtime warning on vc8
-#endif // _MSC_VER >= 1400
+#endif
       //! requires a pointer to a user created std::tm struct
       inline
       static std::tm* localtime(const std::time_t* t, std::tm* result)
@@ -112,9 +115,11 @@ namespace date_time {
           boost::throw_exception(std::runtime_error("could not convert calendar time to UTC time"));
         return result;
       }
-#if (defined(_MSC_VER) && (_MSC_VER >= 1400))
+#if defined(__clang__) // Clang has to be checked before MSVC
+#pragma clang diagnostic pop
+#elif (defined(_MSC_VER) && (_MSC_VER >= 1400))
 #pragma warning(pop) // restore warnings to previous state
-#endif // _MSC_VER >= 1400
+#endif
 
 #endif // BOOST_DATE_TIME_HAS_REENTRANT_STD_FUNCTIONS
   };

data/src/cxx_supportlib/vendor-modified/boost/date_time/compiler_config.hpp

@@ -12,19 +12,6 @@
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 
-// With boost release 1.33, date_time will be using a different,
-// more flexible, IO system. This new system is not compatible with
-// old compilers. The original date_time IO system remains for those
-// compilers. They must define this macro to use the legacy IO.
-//     (defined(__BORLANDC__) && (__BORLANDC__ <= 0x0581) ) )   &&
- #if(  BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) ) \
-    || BOOST_WORKAROUND( __GNUC__, < 3)                         \
-    || (BOOST_WORKAROUND( _MSC_VER, <= 1300) )                  \
-    )                                                           \
-    && !defined(USE_DATE_TIME_PRE_1_33_FACET_IO)
-# define USE_DATE_TIME_PRE_1_33_FACET_IO
-#endif
-
 
 // This file performs some local compiler configurations
 
@@ -46,7 +33,7 @@
 #undef BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES
 #endif
 
-#if (defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) || BOOST_WORKAROUND( __BORLANDC__,  BOOST_TESTED_AT(0x581) ) )
+#if (defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) || BOOST_WORKAROUND( BOOST_BORLANDC,  BOOST_TESTED_AT(0x581) ) )
 #define BOOST_DATE_TIME_NO_MEMBER_INIT
 #endif
 
@@ -60,13 +47,13 @@
 
 
 /* Workaround for Borland iterator error. Error was "Cannot convert 'istream *' to 'wistream *' in function istream_iterator<>::istream_iterator() */
-#if defined(__BORLANDC__) && defined(BOOST_BCB_WITH_RW_LIB)
+#if defined(BOOST_BORLANDC) && defined(BOOST_BCB_WITH_RW_LIB)
 #define BOOST_DATE_TIME_NO_WISTREAM_ITERATOR
 #endif
 
 
 // Borland v5.64 does not have the following in std namespace; v5.5.1 does
-#if defined(__BORLANDC__) && defined(BOOST_BCB_WITH_STLPORT)
+#if defined(BOOST_BORLANDC) && defined(BOOST_BCB_WITH_STLPORT)
 #include <locale>
 namespace std {
   using stlport::tolower;
@@ -83,7 +70,7 @@ namespace std {
 #if (((defined(__GNUC__) && (__GNUC__ < 3)) || \
       (defined(_MSC_VER) && (_MSC_VER < 1300)) ) && \
       !defined(_STLP_OWN_IOSTREAMS) ) || \
-      BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
+      BOOST_WORKAROUND( BOOST_BORLANDC, BOOST_TESTED_AT(0x581) )
 #define BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS
 #endif
 

data/src/cxx_supportlib/vendor-modified/boost/date_time/constrained_value.hpp

@@ -13,7 +13,7 @@
 #include <stdexcept>
 #include <boost/config.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/mpl/if.hpp>
+#include <boost/type_traits/conditional.hpp>
 #include <boost/type_traits/is_base_of.hpp>
 
 namespace boost {
@@ -43,25 +43,29 @@ namespace CV {
   public:
     typedef typename value_policies::value_type value_type;
     //    typedef except_type exception_type;
-    constrained_value(value_type value) : value_((min)())
+    BOOST_CXX14_CONSTEXPR constrained_value(value_type value) : value_((min)())
     {
       assign(value);
     }
-    constrained_value& operator=(value_type v)
+    BOOST_CXX14_CONSTEXPR constrained_value& operator=(value_type v)
     {
       assign(v); 
       return *this;
     }
     //! Return the max allowed value (traits method)
-    static value_type max BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::max)();}
+    static BOOST_CONSTEXPR value_type
+    max BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::max)();}
+
     //! Return the min allowed value (traits method)
-    static value_type min BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::min)();}
+    static BOOST_CONSTEXPR value_type
+    min BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::min)();}
+
     //! Coerce into the representation type
-    operator value_type() const {return value_;}
+    BOOST_CXX14_CONSTEXPR operator value_type() const {return value_;}
   protected:
     value_type value_;
   private:
-    void assign(value_type value)
+    BOOST_CXX14_CONSTEXPR void assign(value_type value)
     {
       //adding 1 below gets rid of a compiler warning which occurs when the 
       //min_value is 0 and the type is unsigned....
@@ -95,16 +99,20 @@ namespace CV {
       }
     };
 
-    typedef typename mpl::if_<
-      is_base_of< std::exception, exception_type >,
+    typedef typename conditional<
+      is_base_of< std::exception, exception_type >::value,
       exception_type,
       exception_wrapper
     >::type actual_exception_type;
 
   public:
     typedef rep_type value_type;
-    static rep_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return min_value; }
-    static rep_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return max_value; }
+    static BOOST_CONSTEXPR rep_type
+    min BOOST_PREVENT_MACRO_SUBSTITUTION () { return min_value; }
+
+    static BOOST_CONSTEXPR rep_type
+    max BOOST_PREVENT_MACRO_SUBSTITUTION () { return max_value; }
+
     static void on_error(rep_type, rep_type, violation_enum)
     {
       boost::throw_exception(actual_exception_type());

data/src/cxx_supportlib/vendor-modified/boost/date_time/date.hpp

@@ -68,76 +68,76 @@ namespace date_time {
     typedef typename calendar::date_rep_type date_rep_type;
     typedef typename calendar::date_int_type date_int_type;
     typedef typename calendar::day_of_week_type day_of_week_type;
-    date(year_type y, month_type m, day_type d)
+    BOOST_CXX14_CONSTEXPR date(year_type y, month_type m, day_type d)
       : days_(calendar::day_number(ymd_type(y, m, d)))
     {}
-    date(const ymd_type& ymd)
+    BOOST_CXX14_CONSTEXPR date(const ymd_type& ymd)
       : days_(calendar::day_number(ymd))
     {}
     //let the compiler write copy, assignment, and destructor
-    year_type        year() const
+    BOOST_CXX14_CONSTEXPR year_type        year() const
     {
       ymd_type ymd = calendar::from_day_number(days_);
       return ymd.year;
     }
-    month_type       month() const
+    BOOST_CXX14_CONSTEXPR month_type       month() const
     {
       ymd_type ymd = calendar::from_day_number(days_);
       return ymd.month;
     }
-    day_type         day() const
+    BOOST_CXX14_CONSTEXPR day_type         day() const
     {
       ymd_type ymd = calendar::from_day_number(days_);
       return ymd.day;
     }
-    day_of_week_type day_of_week() const
+    BOOST_CXX14_CONSTEXPR day_of_week_type day_of_week() const
     {
       ymd_type ymd = calendar::from_day_number(days_);
       return calendar::day_of_week(ymd);
     }
-    ymd_type         year_month_day() const
+    BOOST_CXX14_CONSTEXPR ymd_type         year_month_day() const
     {
       return calendar::from_day_number(days_);
     }
-    bool operator<(const date_type& rhs)  const
+    BOOST_CONSTEXPR bool operator<(const date_type& rhs)  const
     {
       return days_ < rhs.days_;
     }
-    bool operator==(const date_type& rhs) const
+    BOOST_CONSTEXPR bool operator==(const date_type& rhs) const
     {
       return days_ == rhs.days_;
     }
     //! check to see if date is a special value
-    bool is_special()const
+    BOOST_CONSTEXPR bool is_special()const
     {
       return(is_not_a_date() || is_infinity());
     }
     //! check to see if date is not a value
-    bool is_not_a_date()  const
+    BOOST_CONSTEXPR bool is_not_a_date()  const
     {
       return traits_type::is_not_a_number(days_);
     }
     //! check to see if date is one of the infinity values
-    bool is_infinity()  const
+    BOOST_CONSTEXPR bool is_infinity()  const
     {
       return traits_type::is_inf(days_);
     }
     //! check to see if date is greater than all possible dates
-    bool is_pos_infinity()  const
+    BOOST_CONSTEXPR bool is_pos_infinity()  const
     {
       return traits_type::is_pos_inf(days_);
     }
     //! check to see if date is greater than all possible dates
-    bool is_neg_infinity()  const
+    BOOST_CONSTEXPR bool is_neg_infinity()  const
     {
       return traits_type::is_neg_inf(days_);
     }
     //! return as a special value or a not_special if a normal date
-    special_values as_special()  const
+    BOOST_CXX14_CONSTEXPR special_values as_special()  const
     {
       return traits_type::to_special(days_);
     }
-    duration_type operator-(const date_type& d) const
+    BOOST_CXX14_CONSTEXPR duration_type operator-(const date_type& d) const
     {
       if (!this->is_special() && !d.is_special())
       {
@@ -154,7 +154,7 @@ namespace date_time {
       }
     }
 
-    date_type operator-(const duration_type& dd) const
+    BOOST_CXX14_CONSTEXPR date_type operator-(const duration_type& dd) const
     {
       if(dd.is_special())
       {
@@ -162,17 +162,17 @@ namespace date_time {
       }
       return date_type(date_rep_type(days_) - static_cast<date_int_type>(dd.days()));
     }
-    date_type operator-=(const duration_type& dd)
+    BOOST_CXX14_CONSTEXPR date_type operator-=(const duration_type& dd)
     {
       *this = *this - dd;
       return date_type(days_);
     }
-    date_rep_type day_count() const
+    BOOST_CONSTEXPR date_rep_type day_count() const
     {
       return days_;
     }
     //allow internal access from operators
-    date_type operator+(const duration_type& dd) const
+    BOOST_CXX14_CONSTEXPR date_type operator+(const duration_type& dd) const
     {
       if(dd.is_special())
       {
@@ -180,7 +180,7 @@ namespace date_time {
       }
       return date_type(date_rep_type(days_) + static_cast<date_int_type>(dd.days()));
     }
-    date_type operator+=(const duration_type& dd)
+    BOOST_CXX14_CONSTEXPR date_type operator+=(const duration_type& dd)
     {
       *this = *this + dd;
       return date_type(days_);
@@ -192,8 +192,8 @@ namespace date_time {
       dates.  It is not exposed to users since that would require class
       users to understand the inner workings of the date class.
     */
-    explicit date(date_int_type days) : days_(days) {}
-    explicit date(date_rep_type days) : days_(days.as_number()) {}
+    BOOST_CONSTEXPR explicit date(date_int_type days) : days_(days) {}
+    BOOST_CXX14_CONSTEXPR explicit date(date_rep_type days) : days_(days.as_number()) {}
     date_int_type days_;
 
   };

data/src/cxx_supportlib/vendor-modified/boost/date_time/date_duration.hpp

@@ -13,6 +13,7 @@
 #include <boost/operators.hpp>
 #include <boost/date_time/special_defs.hpp>
 #include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/int_adapter.hpp>
 
 namespace boost {
 namespace date_time {
@@ -33,50 +34,44 @@ namespace date_time {
     typedef typename duration_rep_traits::impl_type duration_rep;
 
     //! Construct from a day count
-    explicit date_duration(duration_rep day_count) : days_(day_count) {}
+    BOOST_CXX14_CONSTEXPR explicit date_duration(duration_rep day_count) : days_(day_count) {}
 
     /*! construct from special_values - only works when
      * instantiated with duration_traits_adapted */
-    date_duration(special_values sv) :
+    BOOST_CXX14_CONSTEXPR date_duration(special_values sv) :
             days_(duration_rep::from_special(sv))
     {}
 
-    // copy constructor required for addable<> & subtractable<>
-    //! Construct from another date_duration (Copy Constructor)
-    date_duration(const date_duration<duration_rep_traits>& other) :
-            days_(other.days_)
-    {}
-
     //! returns days_ as it's instantiated type - used for streaming
-    duration_rep get_rep()const
+    BOOST_CXX14_CONSTEXPR duration_rep get_rep()const
     {
         return days_;
     }
-    special_values as_special() const
+    BOOST_CXX14_CONSTEXPR special_values as_special() const
     {
         return days_.as_special();
     }
-    bool is_special()const
+    BOOST_CXX14_CONSTEXPR bool is_special()const
     {
         return days_.is_special();
     }
     //! returns days as value, not object.
-    duration_rep_type days() const
+    BOOST_CXX14_CONSTEXPR duration_rep_type days() const
     {
         return duration_rep_traits::as_number(days_);
     }
     //! Returns the smallest duration -- used by to calculate 'end'
-    static date_duration unit()
+    static BOOST_CXX14_CONSTEXPR date_duration unit()
     {
         return date_duration<duration_rep_traits>(1);
     }
     //! Equality
-    bool operator==(const date_duration& rhs) const
+    BOOST_CXX14_CONSTEXPR bool operator==(const date_duration& rhs) const
     {
         return days_ == rhs.days_;
     }
     //! Less
-    bool operator<(const date_duration& rhs) const
+    BOOST_CXX14_CONSTEXPR bool operator<(const date_duration& rhs) const
     {
         return days_ < rhs.days_;
     }
@@ -87,33 +82,33 @@ namespace date_time {
      * so this will not compile */
 
     //! Subtract another duration -- result is signed
-    date_duration& operator-=(const date_duration& rhs)
+    BOOST_CXX14_CONSTEXPR date_duration& operator-=(const date_duration& rhs)
     {
         //days_ -= rhs.days_;
         days_ = days_ - rhs.days_;
         return *this;
     }
     //! Add a duration -- result is signed
-    date_duration& operator+=(const date_duration& rhs)
+    BOOST_CXX14_CONSTEXPR date_duration& operator+=(const date_duration& rhs)
     {
         days_ = days_ + rhs.days_;
         return *this;
     }
 
     //! unary- Allows for dd = -date_duration(2); -> dd == -2
-    date_duration operator-() const
+    BOOST_CXX14_CONSTEXPR date_duration operator-() const
     {
         return date_duration<duration_rep_traits>(get_rep() * (-1));
     }
     //! Division operations on a duration with an integer.
-    date_duration& operator/=(int divisor)
+    BOOST_CXX14_CONSTEXPR date_duration& operator/=(int divisor)
     {
         days_ = days_ / divisor;
         return *this;
     }
 
     //! return sign information
-    bool is_negative() const
+    BOOST_CXX14_CONSTEXPR bool is_negative() const
     {
         return days_ < 0;
     }
@@ -130,7 +125,7 @@ namespace date_time {
   {
     typedef long int_type;
     typedef long impl_type;
-    static int_type as_number(impl_type i) { return i; }
+    static BOOST_CXX14_CONSTEXPR int_type as_number(impl_type i) { return i; }
   };
 
   /*! Struct for instantiating date_duration <b>WITH</b> special values
@@ -140,7 +135,7 @@ namespace date_time {
   {
     typedef long int_type;
     typedef boost::date_time::int_adapter<long> impl_type;
-    static int_type as_number(impl_type i) { return i.as_number(); }
+    static BOOST_CXX14_CONSTEXPR int_type as_number(impl_type i) { return i.as_number(); }
   };