passenger 5.1.4 → 5.1.5

data/src/cxx_supportlib/vendor-modified/boost/intrusive/unordered_set_hook.hpp

@@ -152,19 +152,33 @@ struct uset_algo_wrapper : public Algo
 {};
 
 template<class VoidPointer, bool StoreHash, bool OptimizeMultiKey>
-struct get_uset_node_algo
+struct get_uset_node_traits
 {
    typedef typename detail::if_c
       < (StoreHash || OptimizeMultiKey)
       , unordered_node_traits<VoidPointer, StoreHash, OptimizeMultiKey>
       , slist_node_traits<VoidPointer>
-      >::type node_traits_type;
-   typedef typename detail::if_c
-                              < OptimizeMultiKey
-                              , unordered_algorithms<node_traits_type>
-                              , uset_algo_wrapper< circular_slist_algorithms<node_traits_type> >
       >::type type;
 };
+
+template<bool OptimizeMultiKey>
+struct get_uset_algo_type
+{
+   static const algo_types value = OptimizeMultiKey ? UnorderedAlgorithms : UnorderedCircularSlistAlgorithms;
+};
+
+template<class NodeTraits>
+struct get_algo<UnorderedAlgorithms, NodeTraits>
+{
+   typedef unordered_algorithms<NodeTraits> type;
+};
+
+template<class NodeTraits>
+struct get_algo<UnorderedCircularSlistAlgorithms, NodeTraits>
+{
+   typedef uset_algo_wrapper< circular_slist_algorithms<NodeTraits> > type;
+};
+
 /// @endcond
 
 //! Helper metafunction to define a \c unordered_set_base_hook that yields to the same
@@ -187,10 +201,11 @@ struct make_unordered_set_base_hook
       >::type packed_options;
 
    typedef generic_hook
-   < typename get_uset_node_algo < typename packed_options::void_pointer
-                                 , packed_options::store_hash
-                                 , packed_options::optimize_multikey
-                                 >::type
+   < get_uset_algo_type <packed_options::optimize_multikey>::value
+   , typename get_uset_node_traits < typename packed_options::void_pointer
+                                   , packed_options::store_hash
+                                   , packed_options::optimize_multikey
+                                   >::type
    , typename packed_options::tag
    , packed_options::link_mode
    , HashBaseHookId
@@ -326,10 +341,11 @@ struct make_unordered_set_member_hook
       >::type packed_options;
 
    typedef generic_hook
-   < typename get_uset_node_algo< typename packed_options::void_pointer
-                                , packed_options::store_hash
-                                , packed_options::optimize_multikey
-                                >::type
+   < get_uset_algo_type <packed_options::optimize_multikey>::value
+   , typename get_uset_node_traits < typename packed_options::void_pointer
+                                   , packed_options::store_hash
+                                   , packed_options::optimize_multikey
+                                   >::type
    , member_tag
    , packed_options::link_mode
    , NoBaseHookId

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

@@ -36,7 +36,7 @@ namespace boost
     template <typename Target, typename Source>
     inline Target lexical_cast(const Source &arg)
     {
-        Target result;
+        Target result = Target();
 
         if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
             boost::conversion::detail::throw_bad_cast<Source, Target>();

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

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2014.
+// Copyright Antony Polukhin, 2011-2016.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,7 +13,7 @@
 //        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
 //        Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
 //        Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
-// when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+// when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2014, Nowember 2016
 
 #ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
 #define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
@@ -107,23 +107,26 @@ namespace boost {
 
     namespace detail
     {
-        struct do_not_construct_out_stream_t{};
-        
+        struct do_not_construct_out_buffer_t{};
+        struct do_not_construct_out_stream_t{
+            do_not_construct_out_stream_t(do_not_construct_out_buffer_t*){}
+        };
+
         template <class CharT, class Traits>
         struct out_stream_helper_trait {
 #if defined(BOOST_NO_STRINGSTREAM)
-            typedef std::ostrstream                                 out_stream_t;
-            typedef void                                            buffer_t;
+            typedef std::ostream                                                    out_stream_t;
+            typedef basic_unlockedbuf<std::strstreambuf, char>                      stringbuffer_t;
 #elif defined(BOOST_NO_STD_LOCALE)
-            typedef std::ostringstream                              out_stream_t;
-            typedef basic_unlockedbuf<std::streambuf, char>         buffer_t;
+            typedef std::ostream                                                    out_stream_t;
+            typedef basic_unlockedbuf<std::stringbuf, char>                         stringbuffer_t;
+            typedef basic_unlockedbuf<std::streambuf, char>                         buffer_t;
 #else
-            typedef std::basic_ostringstream<CharT, Traits> 
-                out_stream_t;
-            typedef basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT>  
-                buffer_t;
+            typedef std::basic_ostream<CharT, Traits>                               out_stream_t;
+            typedef basic_unlockedbuf<std::basic_stringbuf<CharT, Traits>, CharT>   stringbuffer_t;
+            typedef basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT>   buffer_t;
 #endif
-        };   
+        };
     }
 
     namespace detail // optimized stream wrappers
@@ -134,19 +137,19 @@ namespace boost {
                 , std::size_t CharacterBufferSize
                 >
         class lexical_istream_limited_src: boost::noncopyable {
-            typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t
-                buffer_t;
-
-            typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::out_stream_t
-                out_stream_t;
-    
             typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
                 RequiresStringbuffer,
-                out_stream_t,
+                BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::out_stream_t,
                 do_not_construct_out_stream_t
             >::type deduced_out_stream_t;
 
-            // A string representation of Source is written to `buffer`.
+            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+                RequiresStringbuffer,
+                BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::stringbuffer_t,
+                do_not_construct_out_buffer_t
+            >::type deduced_out_buffer_t;
+
+            deduced_out_buffer_t out_buffer;
             deduced_out_stream_t out_stream;
             CharT   buffer[CharacterBufferSize];
 
@@ -157,7 +160,9 @@ namespace boost {
 
         public:
             lexical_istream_limited_src() BOOST_NOEXCEPT
-              : start(buffer)
+              : out_buffer()
+              , out_stream(&out_buffer)
+              , start(buffer)
               , finish(buffer + CharacterBufferSize)
             {}
     
@@ -170,10 +175,6 @@ namespace boost {
             }
 
         private:
-            // Undefined:
-            lexical_istream_limited_src(lexical_istream_limited_src const&);
-            void operator=(lexical_istream_limited_src const&);
-
 /************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/
             bool shl_char(CharT ch) BOOST_NOEXCEPT {
                 Traits::assign(buffer[0], ch);
@@ -212,7 +213,7 @@ namespace boost {
                     "Use boost::locale instead" );
                 return shl_input_streamable(str);
             }
-            
+
             bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT {
                 start = str;
                 finish = std::find(start, start + max_size, Traits::to_char_type(0));
@@ -232,8 +233,8 @@ namespace boost {
                 try {
 #endif
                 bool const result = !(out_stream << input).fail();
-                const buffer_t* const p = static_cast<buffer_t*>(
-                    static_cast<std::basic_streambuf<CharT, Traits>*>(out_stream.rdbuf())
+                const deduced_out_buffer_t* const p = static_cast<deduced_out_buffer_t*>(
+                    out_stream.rdbuf()
                 );
                 start = p->pbase();
                 finish = p->pptr();
@@ -467,7 +468,7 @@ namespace boost {
 
             template <std::size_t N>
             bool operator<<(boost::array<const CharT, N> const& input) BOOST_NOEXCEPT { 
-                return shl_char_array_limited(input.begin(), N); 
+                return shl_char_array_limited(input.data(), N);
             }
 
             template <std::size_t N>
@@ -573,17 +574,15 @@ namespace boost {
                     "support such conversions. Try updating it."
                 );
 #endif
-                typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t
-                    buffer_t;
 
 #if defined(BOOST_NO_STRINGSTREAM)
-                std::istrstream stream(start, finish - start);
+                std::istrstream stream(start, static_cast<std::istrstream::streamsize>(finish - start));
 #else
-
+                typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t buffer_t;
                 buffer_t buf;
                 // Usually `istream` and `basic_istream` do not modify 
                 // content of buffer; `buffer_t` assures that this is true
-                buf.setbuf(const_cast<CharT*>(start), finish - start);
+                buf.setbuf(const_cast<CharT*>(start), static_cast<typename buffer_t::streamsize>(finish - start));
 #if defined(BOOST_NO_STD_LOCALE)
                 std::istream stream(&buf);
 #else
@@ -697,7 +696,7 @@ namespace boost {
             template <class C, std::size_t N>
             bool operator>>(std::array<C, N>& output) BOOST_NOEXCEPT { 
                 BOOST_STATIC_ASSERT_MSG(
-                    (sizeof(boost::array<C, N>) == sizeof(boost::array<C, N>)),
+                    (sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)),
                     "std::array<C, N> and boost::array<C, N> must have exactly the same layout."
                 );
                 return ((*this) >> reinterpret_cast<boost::array<C, N>& >(output));

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

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2014.
+// Copyright Antony Polukhin, 2011-2016.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,7 +13,7 @@
 //        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
 //        Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
 //        Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
-// when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+// when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2016
 
 #ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
 #define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
@@ -154,35 +154,13 @@ struct dynamic_num_converter_impl
 {
     static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
         typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-        	boost::is_unsigned<Target>::value &&
-        	(boost::is_signed<Source>::value || boost::is_float<Source>::value) &&
-        	!(boost::is_same<Source, bool>::value) &&
-        	!(boost::is_same<Target, bool>::value),
+            boost::is_unsigned<Target>::value &&
+            (boost::is_signed<Source>::value || boost::is_float<Source>::value) &&
+            !(boost::is_same<Source, bool>::value) &&
+            !(boost::is_same<Target, bool>::value),
             lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
             lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
         >::type caster_type;
-        
-#if 0
-
-        typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
-            BOOST_DEDUCED_TYPENAME boost::mpl::and_<
-                boost::is_unsigned<Target>,
-                boost::mpl::or_<
-                    boost::is_signed<Source>,
-                    boost::is_float<Source>
-                >,
-                boost::mpl::not_<
-                    boost::is_same<Source, bool>
-                >,
-                boost::mpl::not_<
-                    boost::is_same<Target, bool>
-                >
-            >::type,
-            lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
-            lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
-        >::type caster_type;
-        
-#endif
 
         return caster_type::try_convert(arg, result);
     }

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/try_lexical_convert.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2014.
+// Copyright Antony Polukhin, 2011-2016.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -57,8 +57,15 @@ namespace boost {
             : boost::true_type
         {};
 
+        // Sun Studio has problem with partial specialization of templates differing only in namespace.
+        // We workaround that by making `is_booststring` trait, instead of specializing `is_stdstring` for `boost::container::basic_string`.
+        template<typename T>
+        struct is_booststring
+            : boost::false_type
+        {};
+
         template<typename CharT, typename Traits, typename Alloc>
-        struct is_stdstring< boost::container::basic_string<CharT, Traits, Alloc> >
+        struct is_booststring< boost::container::basic_string<CharT, Traits, Alloc> >
             : boost::true_type
         {};
 
@@ -111,13 +118,20 @@ namespace boost {
             : boost::true_type
         {};
 
+        // Sun Studio has problem with partial specialization of templates differing only in namespace.
+        // We workaround that by making `is_char_array_to_booststring` trait, instead of specializing `is_char_array_to_stdstring` for `boost::container::basic_string`.
+        template<typename Target, typename Source>
+        struct is_char_array_to_booststring
+            : boost::false_type
+        {};
+
         template<typename CharT, typename Traits, typename Alloc>
-        struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
+        struct is_char_array_to_booststring< boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
             : boost::true_type
         {};
 
         template<typename CharT, typename Traits, typename Alloc>
-        struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
+        struct is_char_array_to_booststring< boost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
             : boost::true_type
         {};
 
@@ -151,9 +165,10 @@ namespace boost {
             typedef boost::mpl::bool_<
                 boost::detail::is_xchar_to_xchar<Target, src >::value ||
                 boost::detail::is_char_array_to_stdstring<Target, src >::value ||
+                boost::detail::is_char_array_to_booststring<Target, src >::value ||
                 (
                      boost::is_same<Target, src >::value &&
-                     boost::detail::is_stdstring<Target >::value
+                     (boost::detail::is_stdstring<Target >::value || boost::detail::is_booststring<Target >::value)
                 ) ||
                 (
                      boost::is_same<Target, src >::value &&

data/src/cxx_supportlib/vendor-modified/boost/libs/regex/src/posix_api.cpp

@@ -182,10 +182,12 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int code, const regex_tA*
          }
       }
 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
-      (::sprintf_s)(localbuf, 5, "%d", 0);
+      int r = (::sprintf_s)(localbuf, 5, "%d", 0);
 #else
-      (std::sprintf)(localbuf, "%d", 0);
+      int r = (std::sprintf)(localbuf, "%d", 0);
 #endif
+      if(r < 0)
+         return 0; // sprintf failed
       if(std::strlen(localbuf) < buf_size)
          BOOST_REGEX_DETAIL_NS::strcpy_s(buf, buf_size, localbuf);
       return std::strlen(localbuf) + 1;

data/src/cxx_supportlib/vendor-modified/boost/libs/regex/src/regex.cpp

@@ -191,7 +191,9 @@ BOOST_REGEX_DECL void BOOST_REGEX_CALL put_mem_block(void* p)
 
 #else
 
-#ifdef BOOST_HAS_THREADS
+#if defined(BOOST_REGEX_MEM_BLOCK_CACHE_LOCK_FREE)
+mem_block_cache block_cache = { { {nullptr} } } ;
+#elif defined(BOOST_HAS_THREADS)
 mem_block_cache block_cache = { 0, 0, BOOST_STATIC_MUTEX_INIT, };
 #else
 mem_block_cache block_cache = { 0, 0, };

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

@@ -42,6 +42,7 @@ namespace boost
                 }
             }
 
+#if defined BOOST_THREAD_PATCH
             const pthread_once_t pthread_once_init_value=PTHREAD_ONCE_INIT;
             struct BOOST_THREAD_DECL delete_epoch_tss_key_on_dlclose_t
             {
@@ -52,11 +53,15 @@ namespace boost
                 {
                     if(memcmp(&epoch_tss_key_flag, &pthread_once_init_value, sizeof(pthread_once_t)))
                     {
+                        void* data = pthread_getspecific(epoch_tss_key);
+                        if (data)
+                            delete_epoch_tss_data(data);
                         pthread_key_delete(epoch_tss_key);
                     }
                 }
             };
             delete_epoch_tss_key_on_dlclose_t delete_epoch_tss_key_on_dlclose;
+#endif
         }
 
         uintmax_atomic_t& get_once_per_thread_epoch()

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

@@ -115,6 +115,7 @@ namespace boost
                 }
             }
 
+#if defined BOOST_THREAD_PATCH
             struct  delete_current_thread_tls_key_on_dlclose_t
             {
                 delete_current_thread_tls_key_on_dlclose_t()
@@ -125,12 +126,15 @@ namespace boost
                     const boost::once_flag uninitialized = BOOST_ONCE_INIT;
                     if (memcmp(&current_thread_tls_init_flag, &uninitialized, sizeof(boost::once_flag)))
                     {
+                        void* data = pthread_getspecific(current_thread_tls_key);
+                        if (data)
+                            tls_destructor(data);
                         pthread_key_delete(current_thread_tls_key);
                     }
                 }
             };
             delete_current_thread_tls_key_on_dlclose_t delete_current_thread_tls_key_on_dlclose;
-
+#endif
             void create_current_thread_tls_key()
             {
                 BOOST_VERIFY(!pthread_key_create(&current_thread_tls_key,&tls_destructor));
@@ -426,7 +430,7 @@ namespace boost
     {
       namespace no_interruption_point
       {
-        namespace hiden
+        namespace hidden
         {
           void BOOST_THREAD_DECL sleep_for(const timespec& ts)
           {
@@ -486,7 +490,7 @@ namespace boost
 
         }
       }
-      namespace hiden
+      namespace hidden
       {
         void BOOST_THREAD_DECL sleep_for(const timespec& ts)
         {
@@ -499,7 +503,7 @@ namespace boost
             }
             else
             {
-              boost::this_thread::no_interruption_point::hiden::sleep_for(ts);
+              boost::this_thread::no_interruption_point::hidden::sleep_for(ts);
             }
         }
 
@@ -514,10 +518,10 @@ namespace boost
             }
             else
             {
-              boost::this_thread::no_interruption_point::hiden::sleep_until(ts);
+              boost::this_thread::no_interruption_point::hidden::sleep_until(ts);
             }
         }
-      } // hiden
+      } // hidden
     } // this_thread
 
     namespace this_thread
@@ -538,7 +542,7 @@ namespace boost
             timespec ts;
             ts.tv_sec= 0;
             ts.tv_nsec= 0;
-            hiden::sleep_for(ts);
+            hidden::sleep_for(ts);
 #   endif
         }
     }