passenger 6.0.2 → 6.0.7

data/src/cxx_supportlib/vendor-modified/boost/thread/pthread/condition_variable.hpp

@@ -249,7 +249,7 @@ namespace boost
 #endif
         }
         template<typename lock_type>
-        bool timed_wait(lock_type& m,xtime const& abs_time)
+        bool timed_wait(lock_type& m,::boost::xtime const& abs_time)
         {
             return timed_wait(m,system_time(abs_time));
         }
@@ -309,7 +309,7 @@ namespace boost
         }
 
         template<typename lock_type,typename predicate_type>
-        bool timed_wait(lock_type& m,xtime const& abs_time, predicate_type pred)
+        bool timed_wait(lock_type& m,::boost::xtime const& abs_time, predicate_type pred)
         {
             return timed_wait(m,system_time(abs_time),pred);
         }

data/src/cxx_supportlib/vendor-modified/boost/thread/pthread/condition_variable_fwd.hpp

@@ -128,7 +128,7 @@ namespace boost
         }
         bool timed_wait(
             unique_lock<mutex>& m,
-            xtime const& abs_time)
+            ::boost::xtime const& abs_time)
         {
             return timed_wait(m,system_time(abs_time));
         }
@@ -194,7 +194,7 @@ namespace boost
         template<typename predicate_type>
         bool timed_wait(
             unique_lock<mutex>& m,
-            xtime const& abs_time,predicate_type pred)
+            ::boost::xtime const& abs_time,predicate_type pred)
         {
             return timed_wait(m,system_time(abs_time),pred);
         }

data/src/cxx_supportlib/vendor-modified/boost/thread/pthread/mutex.hpp

@@ -39,53 +39,8 @@
 
 namespace boost
 {
-  namespace posix {
-#ifdef BOOST_THREAD_HAS_EINTR_BUG
-    BOOST_FORCEINLINE int pthread_mutex_destroy(pthread_mutex_t* m)
-    {
-      int ret;
-      do
-      {
-          ret = ::pthread_mutex_destroy(m);
-      } while (ret == EINTR);
-      return ret;
-    }
-    BOOST_FORCEINLINE int pthread_mutex_lock(pthread_mutex_t* m)
-    {
-      int ret;
-      do
-      {
-          ret = ::pthread_mutex_lock(m);
-      } while (ret == EINTR);
-      return ret;
-    }
-    BOOST_FORCEINLINE int pthread_mutex_unlock(pthread_mutex_t* m)
-    {
-      int ret;
-      do
-      {
-          ret = ::pthread_mutex_unlock(m);
-      } while (ret == EINTR);
-      return ret;
-    }
-#else
-    BOOST_FORCEINLINE int pthread_mutex_destroy(pthread_mutex_t* m)
-    {
-      return ::pthread_mutex_destroy(m);
-    }
-    BOOST_FORCEINLINE int pthread_mutex_lock(pthread_mutex_t* m)
-    {
-      return ::pthread_mutex_lock(m);
-    }
-    BOOST_FORCEINLINE int pthread_mutex_unlock(pthread_mutex_t* m)
-    {
-      return ::pthread_mutex_unlock(m);
-    }
-
-#endif
 
-  }
-    class mutex
+    class BOOST_THREAD_CAPABILITY("mutex") mutex
     {
     private:
         pthread_mutex_t m;
@@ -107,7 +62,7 @@ namespace boost
           BOOST_ASSERT(!res);
         }
 
-        void lock()
+        void lock() BOOST_THREAD_ACQUIRE()
         {
             int res = posix::pthread_mutex_lock(&m);
             if (res)
@@ -116,7 +71,7 @@ namespace boost
             }
         }
 
-        void unlock()
+        void unlock() BOOST_THREAD_RELEASE()
         {
             int res = posix::pthread_mutex_unlock(&m);
             (void)res;
@@ -127,12 +82,12 @@ namespace boost
 //            }
         }
 
-        bool try_lock()
+        bool try_lock() BOOST_THREAD_TRY_ACQUIRE(true)
         {
             int res;
             do
             {
-                res = pthread_mutex_trylock(&m);
+                res = posix::pthread_mutex_trylock(&m);
             } while (res == EINTR);
             if (res==EBUSY)
             {
@@ -251,7 +206,7 @@ namespace boost
           int res;
           do
           {
-              res = pthread_mutex_trylock(&m);
+              res = posix::pthread_mutex_trylock(&m);
           } while (res == EINTR);
           if (res==EBUSY)
           {
@@ -277,7 +232,7 @@ namespace boost
             boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
             while(is_locked)
             {
-                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+                BOOST_VERIFY(!posix::pthread_cond_wait(&cond,&m));
             }
             is_locked=true;
         }
@@ -286,7 +241,7 @@ namespace boost
         {
             boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
             is_locked=false;
-            BOOST_VERIFY(!pthread_cond_signal(&cond));
+            BOOST_VERIFY(!posix::pthread_cond_signal(&cond));
         }
 
         bool try_lock()

data/src/cxx_supportlib/vendor-modified/boost/thread/pthread/pthread_mutex_scoped_lock.hpp

@@ -13,6 +13,75 @@
 
 namespace boost
 {
+namespace posix {
+#ifdef BOOST_THREAD_HAS_EINTR_BUG
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_destroy(pthread_mutex_t* m)
+  {
+    int ret;
+    do
+    {
+        ret = ::pthread_mutex_destroy(m);
+    } while (ret == EINTR);
+    return ret;
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_lock(pthread_mutex_t* m)
+  {
+    int ret;
+    do
+    {
+        ret = ::pthread_mutex_lock(m);
+    } while (ret == EINTR);
+    return ret;
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_unlock(pthread_mutex_t* m)
+  {
+    int ret;
+    do
+    {
+        ret = ::pthread_mutex_unlock(m);
+    } while (ret == EINTR);
+    return ret;
+  }
+#else
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_destroy(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_destroy(m);
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_lock(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_lock(m);
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_unlock(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_unlock(m);
+  }
+
+#endif
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_trylock(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_trylock(m);
+  }
+
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
+  {
+    return ::pthread_cond_wait(cond, mutex);
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_cond_signal(pthread_cond_t *cond)
+  {
+    return ::pthread_cond_signal(cond);
+  }
+
+
+}
     namespace pthread
     {
         class pthread_mutex_scoped_lock
@@ -23,11 +92,11 @@ namespace boost
             explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
                 m(m_),locked(true)
             {
-                BOOST_VERIFY(!pthread_mutex_lock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_lock(m));
             }
             void unlock() BOOST_NOEXCEPT
             {
-                BOOST_VERIFY(!pthread_mutex_unlock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
                 locked=false;
             }
             void unlock_if_locked() BOOST_NOEXCEPT
@@ -54,11 +123,11 @@ namespace boost
             explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
                 m(m_)
             {
-                BOOST_VERIFY(!pthread_mutex_unlock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
             }
             ~pthread_mutex_scoped_unlock() BOOST_NOEXCEPT
             {
-                BOOST_VERIFY(!pthread_mutex_lock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_lock(m));
             }
 
         };

data/src/cxx_supportlib/vendor-modified/boost/thread/pthread/recursive_mutex.hpp

@@ -105,17 +105,17 @@ namespace boost
 #ifdef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
         void lock()
         {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_lock(&m));
         }
 
         void unlock()
         {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_unlock(&m));
         }
 
         bool try_lock() BOOST_NOEXCEPT
         {
-            int const res=pthread_mutex_trylock(&m);
+            int const res=posix::pthread_mutex_trylock(&m);
             BOOST_ASSERT(!res || res==EBUSY);
             return !res;
         }
@@ -270,17 +270,17 @@ namespace boost
 #ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
         void lock()
         {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_lock(&m));
         }
 
         void unlock()
         {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_unlock(&m));
         }
 
         bool try_lock()
         {
-            int const res=pthread_mutex_trylock(&m);
+            int const res=posix::pthread_mutex_trylock(&m);
             BOOST_ASSERT(!res || res==EBUSY);
             return !res;
         }

data/src/cxx_supportlib/vendor-modified/boost/thread/pthread/thread_data.hpp

@@ -12,6 +12,7 @@
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/pthread/condition_variable_fwd.hpp>
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 
 #include <boost/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
@@ -56,7 +57,7 @@ namespace boost
 #else
           std::size_t page_size = ::sysconf( _SC_PAGESIZE);
 #endif
-#ifdef PTHREAD_STACK_MIN
+#if PTHREAD_STACK_MIN > 0
           if (size<PTHREAD_STACK_MIN) size=PTHREAD_STACK_MIN;
 #endif
           size = ((size+page_size-1)/page_size)*page_size;
@@ -130,9 +131,10 @@ namespace boost
             > notify_list_t;
             notify_list_t notify;
 
+//#ifndef BOOST_NO_EXCEPTIONS
             typedef std::vector<shared_ptr<shared_state_base> > async_states_t;
             async_states_t async_states_;
-
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             // These data must be at the end so that the access to the other fields doesn't change
             // when BOOST_THREAD_PROVIDES_INTERRUPTIONS is defined.
@@ -148,8 +150,10 @@ namespace boost
                 cond_mutex(0),
                 current_cond(0),
 //#endif
-                notify(),
-                async_states_()
+                notify()
+//#ifndef BOOST_NO_EXCEPTIONS
+                , async_states_()
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 , interrupt_enabled(true)
                 , interrupt_requested(false)
@@ -165,11 +169,12 @@ namespace boost
               notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
             }
 
+//#ifndef BOOST_NO_EXCEPTIONS
             void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
             {
               async_states_.push_back(as);
             }
-
+//#endif
         };
 
         BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
@@ -205,11 +210,11 @@ namespace boost
                     check_for_interruption();
                     thread_info->cond_mutex=cond_mutex;
                     thread_info->current_cond=cond;
-                    BOOST_VERIFY(!pthread_mutex_lock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_lock(m));
                 }
                 else
                 {
-                    BOOST_VERIFY(!pthread_mutex_lock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_lock(m));
                 }
             }
             void unlock_if_locked()
@@ -217,14 +222,14 @@ namespace boost
               if ( ! done) {
                 if (set)
                 {
-                    BOOST_VERIFY(!pthread_mutex_unlock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
                     lock_guard<mutex> guard(thread_info->data_mutex);
                     thread_info->cond_mutex=NULL;
                     thread_info->current_cond=NULL;
                 }
                 else
                 {
-                    BOOST_VERIFY(!pthread_mutex_unlock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
                 }
                 done = true;
               }

data/src/cxx_supportlib/vendor-modified/boost/thread/xtime.hpp

@@ -57,17 +57,17 @@ struct xtime
 
 };
 
-inline xtime get_xtime(boost::system_time const& abs_time)
+inline ::boost::xtime get_xtime(boost::system_time const& abs_time)
 {
-    xtime res;
+    ::boost::xtime res;
     boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);
 
-    res.sec=static_cast<xtime::xtime_sec_t>(time_since_epoch.total_seconds());
-    res.nsec=static_cast<xtime::xtime_nsec_t>(time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second()));
+    res.sec=static_cast< ::boost::xtime::xtime_sec_t>(time_since_epoch.total_seconds());
+    res.nsec=static_cast< ::boost::xtime::xtime_nsec_t>(time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second()));
     return res;
 }
 
-inline int xtime_get(struct xtime* xtp, int clock_type)
+inline int xtime_get(struct ::boost::xtime* xtp, int clock_type)
 {
     if (clock_type == TIME_UTC_)
     {
@@ -78,7 +78,7 @@ inline int xtime_get(struct xtime* xtp, int clock_type)
 }
 
 
-inline int xtime_cmp(const xtime& xt1, const xtime& xt2)
+inline int xtime_cmp(const ::boost::xtime& xt1, const ::boost::xtime& xt2)
 {
     if (xt1.sec == xt2.sec)
         return (int)(xt1.nsec - xt2.nsec);

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

@@ -1,11 +1,5 @@
 #ifndef UUID_AA15E74A856F11E08B8D93F24824019B
 #define UUID_AA15E74A856F11E08B8D93F24824019B
-#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma GCC system_header
-#endif
-#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma warning(push,1)
-#endif
 
 // MS compatible compilers support #pragma once
 
@@ -26,8 +20,8 @@
 //  http://www.boost.org/libs/utility/throw_exception.html
 //
 
-#include <boost/detail/workaround.hpp>
 #include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
 #include <exception>
 
 #if !defined( BOOST_EXCEPTION_DISABLE ) && defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x593) )
@@ -49,6 +43,13 @@
 # define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(x)
 #endif
 
+#if defined(__GNUC__) && (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma GCC system_header
+#endif
+#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma warning(push,1)
+#endif
+
 namespace boost
 {
 #ifdef BOOST_NO_EXCEPTIONS
@@ -66,7 +67,7 @@ template<class E> BOOST_NORETURN inline void throw_exception( E const & e )
     throw_exception_assert_compatibility(e);
 
 #ifndef BOOST_EXCEPTION_DISABLE
-    throw enable_current_exception(enable_error_info(e));
+    throw exception_detail::enable_both( e );
 #else
     throw e;
 #endif