passenger 5.3.3 → 5.3.4

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

@@ -200,18 +200,18 @@ namespace boost {
             }
 #endif
 
-            bool shl_char_array(CharT const* str) BOOST_NOEXCEPT {
-                start = str;
-                finish = start + Traits::length(str);
+            bool shl_char_array(CharT const* str_value) BOOST_NOEXCEPT {
+                start = str_value;
+                finish = start + Traits::length(str_value);
                 return true;
             }
 
             template <class T>
-            bool shl_char_array(T const* str) {
+            bool shl_char_array(T const* str_value) {
                 BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)),
                     "boost::lexical_cast does not support narrowing of char types."
                     "Use boost::locale instead" );
-                return shl_input_streamable(str);
+                return shl_input_streamable(str_value);
             }
 
             bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT {
@@ -424,8 +424,8 @@ namespace boost {
             bool operator<<(unsigned char * ch)         { return ((*this) << reinterpret_cast<char *>(ch)); }
             bool operator<<(signed char const* ch)      { return ((*this) << reinterpret_cast<char const*>(ch)); }
             bool operator<<(signed char * ch)           { return ((*this) << reinterpret_cast<char *>(ch)); }
-            bool operator<<(char const* str)            { return shl_char_array(str); }
-            bool operator<<(char* str)                  { return shl_char_array(str); }
+            bool operator<<(char const* str_value)      { return shl_char_array(str_value); }
+            bool operator<<(char* str_value)            { return shl_char_array(str_value); }
             bool operator<<(short n)                    { return shl_signed(n); }
             bool operator<<(int n)                      { return shl_signed(n); }
             bool operator<<(long n)                     { return shl_signed(n); }

data/src/cxx_supportlib/vendor-modified/boost/libs/thread/src/pthread/once_atomic.cpp

@@ -40,7 +40,7 @@ namespace boost
         pthread::pthread_mutex_scoped_lock lk(&once_mutex);
         if (f.load(memory_order_acquire) != initialized)
         {
-          while (true)
+          for (;;)
           {
             atomic_int_type expected = uninitialized;
             if (f.compare_exchange_strong(expected, in_progress, memory_order_acq_rel, memory_order_acquire))

data/src/cxx_supportlib/vendor-modified/boost/libs/thread/src/pthread/thread.cpp

@@ -27,6 +27,10 @@
 #include <unistd.h>
 #endif
 
+#if defined(__VXWORKS__) 
+#include <vxCpuLib.h>
+#endif 
+
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/lexical_cast.hpp>
@@ -52,7 +56,7 @@ namespace boost
             for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                     i != e; ++i)
             {
-                (*i)->make_ready();
+                (*i)->notify_deferred();
             }
         }
 
@@ -350,7 +354,7 @@ namespace boost
         }
     }
 
-    bool thread::do_try_join_until_noexcept(struct timespec const &timeout, bool& res)
+    bool thread::do_try_join_until_noexcept(detail::internal_platform_timepoint const &timeout, bool& res)
     {
         detail::thread_data_ptr const local_thread_info=(get_thread_info)();
         if(local_thread_info)
@@ -361,11 +365,12 @@ namespace boost
                 unique_lock<mutex> lock(local_thread_info->data_mutex);
                 while(!local_thread_info->done)
                 {
-                    if(!local_thread_info->done_condition.do_wait_until(lock,timeout))
-                    {
-                      res=false;
-                      return true;
-                    }
+                    if(!local_thread_info->done_condition.do_wait_until(lock,timeout)) break; // timeout occurred
+                }
+                if(!local_thread_info->done)
+                {
+                  res=false;
+                  return true;
                 }
                 do_join=!local_thread_info->join_started;
 
@@ -432,100 +437,28 @@ namespace boost
       {
         namespace hidden
         {
-          void BOOST_THREAD_DECL sleep_for(const timespec& ts)
+          void BOOST_THREAD_DECL sleep_for_internal(const detail::platform_duration& ts)
           {
-
-                if (boost::detail::timespec_ge(ts, boost::detail::timespec_zero()))
+                if (ts > detail::platform_duration::zero())
                 {
-
+                  // Use pthread_delay_np or nanosleep whenever possible here in the no_interruption_point
+                  // namespace because they do not provide an interruption point.
     #   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
     #     if defined(__IBMCPP__) ||  defined(_AIX)
-                  BOOST_VERIFY(!pthread_delay_np(const_cast<timespec*>(&ts)));
+                  BOOST_VERIFY(!pthread_delay_np(const_cast<timespec*>(&ts.getTs())));
     #     else
-                  BOOST_VERIFY(!pthread_delay_np(&ts));
+                  BOOST_VERIFY(!pthread_delay_np(&ts.getTs()));
     #     endif
     #   elif defined(BOOST_HAS_NANOSLEEP)
-                  //  nanosleep takes a timespec that is an offset, not
-                  //  an absolute time.
-                  nanosleep(&ts, 0);
-    #   else
-                  mutex mx;
-                  unique_lock<mutex> lock(mx);
-                  condition_variable cond;
-                  cond.do_wait_for(lock, ts);
-    #   endif
-                }
-          }
-
-          void BOOST_THREAD_DECL sleep_until(const timespec& ts)
-          {
-                timespec now = boost::detail::timespec_now();
-                if (boost::detail::timespec_gt(ts, now))
-                {
-                  for (int foo=0; foo < 5; ++foo)
-                  {
-
-    #   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
-                    timespec d = boost::detail::timespec_minus(ts, now);
-                    BOOST_VERIFY(!pthread_delay_np(&d));
-    #   elif defined(BOOST_HAS_NANOSLEEP)
-                    //  nanosleep takes a timespec that is an offset, not
-                    //  an absolute time.
-                    timespec d = boost::detail::timespec_minus(ts, now);
-                    nanosleep(&d, 0);
+                  nanosleep(&ts.getTs(), 0);
     #   else
-                    mutex mx;
-                    unique_lock<mutex> lock(mx);
-                    condition_variable cond;
-                    cond.do_wait_until(lock, ts);
+                  // This should never be reached due to BOOST_THREAD_SLEEP_FOR_IS_STEADY
     #   endif
-                    timespec now2 = boost::detail::timespec_now();
-                    if (boost::detail::timespec_ge(now2, ts))
-                    {
-                      return;
-                    }
-                  }
                 }
           }
-
         }
       }
-      namespace hidden
-      {
-        void BOOST_THREAD_DECL sleep_for(const timespec& ts)
-        {
-            boost::detail::thread_data_base* const thread_info=boost::detail::get_current_thread_data();
-
-            if(thread_info)
-            {
-              unique_lock<mutex> lk(thread_info->sleep_mutex);
-              while( thread_info->sleep_condition.do_wait_for(lk,ts)) {}
-            }
-            else
-            {
-              boost::this_thread::no_interruption_point::hidden::sleep_for(ts);
-            }
-        }
-
-        void BOOST_THREAD_DECL sleep_until(const timespec& ts)
-        {
-            boost::detail::thread_data_base* const thread_info=boost::detail::get_current_thread_data();
-
-            if(thread_info)
-            {
-              unique_lock<mutex> lk(thread_info->sleep_mutex);
-              while(thread_info->sleep_condition.do_wait_until(lk,ts)) {}
-            }
-            else
-            {
-              boost::this_thread::no_interruption_point::hidden::sleep_until(ts);
-            }
-        }
-      } // hidden
-    } // this_thread
 
-    namespace this_thread
-    {
         void yield() BOOST_NOEXCEPT
         {
 #   if defined(BOOST_HAS_SCHED_YIELD)
@@ -538,11 +471,10 @@ namespace boost
 //            sleep(xt);
 //            sleep_for(chrono::milliseconds(0));
 #   else
-#error
-            timespec ts;
-            ts.tv_sec= 0;
-            ts.tv_nsec= 0;
-            hidden::sleep_for(ts);
+            mutex mx;
+            unique_lock<mutex> lock(mx);
+            condition_variable cond;
+            cond.do_wait_until(lock, detail::internal_platform_clock::now())
 #   endif
         }
     }
@@ -557,6 +489,18 @@ namespace boost
 #elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN)
         int const count=sysconf(_SC_NPROCESSORS_ONLN);
         return (count>0)?count:0;
+#elif defined(__VXWORKS__)
+        cpuset_t set =  ::vxCpuEnabledGet();
+  #ifdef __DCC__
+        int i;
+        for( i = 0; set; ++i)
+        {
+           set &= set -1;
+        }
+        return(i);
+  #else  
+        return (__builtin_popcount(set) );
+  #endif  
 #elif defined(__GLIBC__)
         return get_nprocs();
 #else

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

@@ -9,8 +9,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 //
-//  See http://www.boost.org/libs/smart_ptr/make_shared.html
-//  for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/smart_ptr/make_shared.hpp>
 

data/src/cxx_supportlib/vendor-modified/boost/math/special_functions/detail/fp_traits.hpp

@@ -556,7 +556,8 @@ struct select_native<long double>
    && !defined(__FAST_MATH__)\
    && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)\
    && !defined(BOOST_INTEL)\
-   && !defined(sun)
+   && !defined(sun)\
+   && !defined(__VXWORKS__)   
 #  define BOOST_MATH_USE_STD_FPCLASSIFY
 #endif
 

data/src/cxx_supportlib/vendor-modified/boost/math/special_functions/math_fwd.hpp

@@ -23,6 +23,7 @@
 #pragma once
 #endif
 
+#include <vector>
 #include <boost/math/special_functions/detail/round_fwd.hpp>
 #include <boost/math/tools/promotion.hpp> // for argument promotion.
 #include <boost/math/policies/policy.hpp>
@@ -181,10 +182,24 @@ namespace boost
    template <class T>
    typename tools::promote_args<T>::type
          legendre_p(int l, T x);
+   template <class T>
+   typename tools::promote_args<T>::type
+          legendre_p_prime(int l, T x);
+
+
+   template <class T, class Policy>
+   inline std::vector<T> legendre_p_zeros(int l, const Policy& pol);
+
+   template <class T>
+   inline std::vector<T> legendre_p_zeros(int l);
+
 #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);
+   template <class T, class Policy>
+   inline typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
+      legendre_p_prime(int l, T x, const Policy& pol);
 #endif
    template <class T>
    typename tools::promote_args<T>::type
@@ -248,6 +263,30 @@ namespace boost
    typename tools::promote_args<T1, T2, T3>::type
       hermite_next(unsigned n, T1 x, T2 Hn, T3 Hnm1);
 
+   template<class T1, class T2, class T3>
+   typename tools::promote_args<T1, T2, T3>::type chebyshev_next(T1 const & x, T2 const & Tn, T3 const & Tn_1);
+
+   template <class Real, class Policy>
+   typename tools::promote_args<Real>::type
+      chebyshev_t(unsigned n, Real const & x, const Policy&);
+   template<class Real>
+   typename tools::promote_args<Real>::type chebyshev_t(unsigned n, Real const & x);
+   
+   template <class Real, class Policy>
+   typename tools::promote_args<Real>::type
+      chebyshev_u(unsigned n, Real const & x, const Policy&);
+   template<class Real>
+   typename tools::promote_args<Real>::type chebyshev_u(unsigned n, Real const & x);
+
+   template <class Real, class Policy>
+   typename tools::promote_args<Real>::type
+      chebyshev_t_prime(unsigned n, Real const & x, const Policy&);
+   template<class Real>
+   typename tools::promote_args<Real>::type chebyshev_t_prime(unsigned n, Real const & x);
+
+   template<class Real, class T2>
+   Real chebyshev_clenshaw_recurrence(const Real* const c, size_t length, const T2& x);
+
    template <class T1, class T2>
    std::complex<typename tools::promote_args<T1, T2>::type>
          spherical_harmonic(unsigned n, int m, T1 theta, T2 phi);
@@ -1018,7 +1057,7 @@ namespace boost
    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);
+   BOOST_MATH_CONSTEXPR_TABLE_FUNCTION T unchecked_bernoulli_b2n(const std::size_t n);
    template <class T, class Policy>
    T bernoulli_b2n(const int i, const Policy &pol);
    template <class T>
@@ -1144,6 +1183,10 @@ namespace boost
    template <class T>\
    inline typename boost::math::tools::promote_args<T>::type \
    legendre_p(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); }\
+\
+   template <class T>\
+   inline typename boost::math::tools::promote_args<T>::type \
+   legendre_p_prime(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); }\
 \
    template <class T>\
    inline typename boost::math::tools::promote_args<T>::type \
@@ -1170,6 +1213,19 @@ namespace boost
    hermite(unsigned n, T x){ return ::boost::math::hermite(n, x, Policy()); }\
 \
    using boost::math::hermite_next;\
+\
+   using boost::math::chebyshev_next;\
+\
+  template<class Real>\
+  Real chebyshev_t(unsigned n, Real const & x){ return ::boost::math::chebyshev_t(n, x, Policy()); }\
+\
+  template<class Real>\
+  Real chebyshev_u(unsigned n, Real const & x){ return ::boost::math::chebyshev_u(n, x, Policy()); }\
+\
+  template<class Real>\
+  Real chebyshev_t_prime(unsigned n, Real const & x){ return ::boost::math::chebyshev_t_prime(n, x, Policy()); }\
+\
+  using ::boost::math::chebyshev_clenshaw_recurrence;\
 \
    template <class T1, class T2>\
    inline std::complex<typename boost::math::tools::promote_args<T1, T2>::type> \
@@ -1593,5 +1649,3 @@ template <class OutputIterator, class T>\
 
 
 #endif // BOOST_MATH_SPECIAL_MATH_FWD_HPP
-
-

data/src/cxx_supportlib/vendor-modified/boost/math/special_functions/sign.hpp

@@ -27,7 +27,7 @@ namespace detail {
     template<class T> 
     inline int signbit_impl(T x, native_tag const&)
     {
-        return (std::signbit)(x);
+        return (std::signbit)(x) ? 1 : 0;
     }
 #endif
 

data/src/cxx_supportlib/vendor-modified/boost/math/tools/config.hpp

@@ -31,7 +31,7 @@
 #if (defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) \
    || (defined(__hppa) && !defined(__OpenBSD__)) || (defined(__NO_LONG_DOUBLE_MATH) && (DBL_MANT_DIG != LDBL_MANT_DIG))) \
    && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
-//#  define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+#  define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
 #endif
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
 //
@@ -451,6 +451,17 @@ namespace boost{ namespace math{
 #  define BOOST_MATH_THREAD_LOCAL
 #endif
 
+//
+// Can we have constexpr tables?
+//
+#if (!defined(BOOST_NO_CXX11_HDR_ARRAY) && !defined(BOOST_NO_CXX14_CONSTEXPR)) || BOOST_WORKAROUND(BOOST_MSVC, >= 1910)
+#define BOOST_MATH_HAVE_CONSTEXPR_TABLES
+#define BOOST_MATH_CONSTEXPR_TABLE_FUNCTION constexpr
+#else
+#define BOOST_MATH_CONSTEXPR_TABLE_FUNCTION
+#endif
+
+
 #endif // BOOST_MATH_TOOLS_CONFIG_HPP
 
 

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

@@ -1,22 +1,22 @@
-#ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED
-#define BOOST_MEMORY_ORDER_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
 //  boost/memory_order.hpp
 //
 //  Defines enum boost::memory_order per the C++0x working draft
 //
 //  Copyright (c) 2008, 2009 Peter Dimov
+//  Copyright (c) 2018 Andrey Semashev
 //
 //  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_MEMORY_ORDER_HPP_INCLUDED
+#define BOOST_MEMORY_ORDER_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
 
 namespace boost
 {
@@ -42,6 +42,35 @@ namespace boost
 // efficiently in compare_exchange methods.
 //
 
+#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
+
+enum class memory_order : unsigned int
+{
+    relaxed = 0,
+    consume = 1,
+    acquire = 2,
+    release = 4,
+    acq_rel = 6, // acquire | release
+    seq_cst = 14 // acq_rel | 8
+};
+
+#if !defined(BOOST_NO_CXX17_INLINE_VARIABLES)
+#define BOOST_MEMORY_ORDER_INLINE_VARIABLE inline
+#else
+#define BOOST_MEMORY_ORDER_INLINE_VARIABLE
+#endif
+
+BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_relaxed = memory_order::relaxed;
+BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_consume = memory_order::consume;
+BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acquire = memory_order::acquire;
+BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_release = memory_order::release;
+BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acq_rel = memory_order::acq_rel;
+BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_seq_cst = memory_order::seq_cst;
+
+#undef BOOST_MEMORY_ORDER_INLINE_VARIABLE
+
+#else // !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
+
 enum memory_order
 {
     memory_order_relaxed = 0,
@@ -52,6 +81,8 @@ enum memory_order
     memory_order_seq_cst = 14 // acq_rel | 8
 };
 
+#endif // !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
+
 } // namespace boost
 
 #endif // #ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED