passenger 3.0.0 → 3.0.1

data/ext/boost/date_time/gregorian/conversion.hpp

@@ -6,9 +6,10 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2009-06-06 07:27:35 -0400 (Sat, 06 Jun 2009) $
+ * $Date: 2010-06-09 14:10:13 -0400 (Wed, 09 Jun 2010) $
  */
 
+#include <cstring>
 #include <string>
 #include <stdexcept>
 #include <boost/throw_exception.hpp>
@@ -41,7 +42,8 @@ namespace gregorian {
         boost::throw_exception(std::out_of_range(s));
     }
 
-    std::tm datetm = {}; // zero initialization is needed for extension members, like tm_zone
+    std::tm datetm;
+    std::memset(&datetm, 0, sizeof(datetm));
     boost::gregorian::date::ymd_type ymd = d.year_month_day();
     datetm.tm_year = ymd.year - 1900;
     datetm.tm_mon = ymd.month - 1;

data/ext/boost/date_time/microsec_time_clock.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2009-06-04 07:36:43 -0400 (Thu, 04 Jun 2009) $
+ * $Date: 2010-05-10 05:15:48 -0400 (Mon, 10 May 2010) $
  */
 
 
@@ -98,9 +98,9 @@ namespace date_time {
 
       std::tm curr;
       std::tm* curr_ptr = converter(&t, &curr);
-      date_type d(curr_ptr->tm_year + 1900,
-                  curr_ptr->tm_mon + 1,
-                  curr_ptr->tm_mday);
+      date_type d(static_cast< typename date_type::year_type::value_type >(curr_ptr->tm_year + 1900),
+                  static_cast< typename date_type::month_type::value_type >(curr_ptr->tm_mon + 1),
+                  static_cast< typename date_type::day_type::value_type >(curr_ptr->tm_mday));
 
       //The following line will adjust the fractional second tick in terms
       //of the current time system.  For example, if the time system
@@ -108,9 +108,9 @@ namespace date_time {
       //and all the fractional seconds return 0.
       int adjust = static_cast< int >(resolution_traits_type::res_adjust() / 1000000);
 
-      time_duration_type td(curr_ptr->tm_hour,
-                            curr_ptr->tm_min,
-                            curr_ptr->tm_sec,
+      time_duration_type td(static_cast< typename time_duration_type::hour_type >(curr_ptr->tm_hour),
+                            static_cast< typename time_duration_type::min_type >(curr_ptr->tm_min),
+                            static_cast< typename time_duration_type::sec_type >(curr_ptr->tm_sec),
                             sub_sec * adjust);
 
       return time_type(d,td);

data/ext/boost/date_time/posix_time/conversion.hpp

@@ -6,9 +6,10 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2010-01-10 14:17:23 -0500 (Sun, 10 Jan 2010) $
+ * $Date: 2010-06-09 14:10:13 -0400 (Wed, 09 Jun 2010) $
  */
 
+#include <cstring>
 #include <boost/date_time/posix_time/ptime.hpp>
 #include <boost/date_time/posix_time/posix_time_duration.hpp>
 #include <boost/date_time/filetime_functions.hpp>
@@ -43,7 +44,8 @@ namespace posix_time {
   //! Convert a time_duration to a tm structure truncating any fractional seconds and zeroing fields for date components
   inline
   std::tm to_tm(const boost::posix_time::time_duration& td) {
-    std::tm timetm = {};
+    std::tm timetm;
+    std::memset(&timetm, 0, sizeof(timetm));
     timetm.tm_hour = date_time::absolute_value(td.hours());
     timetm.tm_min = date_time::absolute_value(td.minutes());
     timetm.tm_sec = date_time::absolute_value(td.seconds());

data/ext/boost/date_time/time_facet.hpp

@@ -7,7 +7,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author:  Martin Andrian, Jeff Garland, Bart Garst
- * $Date: 2010-01-10 14:17:23 -0500 (Sun, 10 Jan 2010) $
+ * $Date: 2010-06-09 12:39:31 -0400 (Wed, 09 Jun 2010) $
  */
 
 #include <cctype>
@@ -21,6 +21,7 @@
 #include <boost/assert.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/throw_exception.hpp>
+#include <boost/range/as_literal.hpp>
 #include <boost/algorithm/string/erase.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/date_time/compiler_config.hpp>
@@ -42,6 +43,10 @@ namespace date_time {
       static const char_type seconds_format[3];                          // S
       static const char_type hours_format[3];                            // H
       static const char_type unrestricted_hours_format[3];               // O
+      static const char_type full_24_hour_time_format[3];                // T
+      static const char_type full_24_hour_time_expanded_format[9];       // HH:MM:SS
+      static const char_type short_24_hour_time_format[3];               // R
+      static const char_type short_24_hour_time_expanded_format[6];      // HH:MM
       static const char_type standard_format[9];                         // x X
       static const char_type zone_abbrev_format[3];                      // z
       static const char_type zone_name_format[3];                        // Z
@@ -73,8 +78,7 @@ namespace date_time {
 
   template <class CharT>
   const typename time_formats<CharT>::char_type
-  time_formats<CharT>::seconds_with_fractional_seconds_format[3] =
-    {'%','s'};
+  time_formats<CharT>::seconds_with_fractional_seconds_format[3] = {'%','s'};
 
   template <class CharT>
   const typename time_formats<CharT>::char_type
@@ -88,6 +92,24 @@ namespace date_time {
   const typename time_formats<CharT>::char_type
   time_formats<CharT>::unrestricted_hours_format[3] =  {'%','O'};
 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
+  time_formats<CharT>::full_24_hour_time_format[3] =  {'%','T'};
+
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
+  time_formats<CharT>::full_24_hour_time_expanded_format[9] =
+  {'%','H',':','%','M',':','%','S'};
+
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
+  time_formats<CharT>::short_24_hour_time_format[3] =  {'%','R'};
+
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
+  time_formats<CharT>::short_24_hour_time_expanded_format[6] =
+  {'%','H',':','%','M'};
+
   template <class CharT>
   const typename time_formats<CharT>::char_type
   //time_formats<CharT>::standard_format[5] =  {'%','c',' ','%','z'};
@@ -180,6 +202,7 @@ namespace date_time {
             class OutItrT = std::ostreambuf_iterator<CharT, std::char_traits<CharT> > >
   class time_facet :
     public boost::date_time::date_facet<typename time_type::date_type , CharT, OutItrT> {
+    typedef time_formats< CharT > formats_type;
    public:
     typedef typename time_type::date_type date_type;
     typedef typename time_type::time_duration_type time_duration_type;
@@ -266,6 +289,14 @@ namespace date_time {
       }
       string_type format(this->m_format);
 
+      // %T and %R have to be replaced here since they are not standard
+      boost::algorithm::replace_all(format,
+        boost::as_literal(formats_type::full_24_hour_time_format),
+        boost::as_literal(formats_type::full_24_hour_time_expanded_format));
+      boost::algorithm::replace_all(format,
+        boost::as_literal(formats_type::short_24_hour_time_format),
+        boost::as_literal(formats_type::short_24_hour_time_expanded_format));
+
       string_type frac_str;
       if (format.find(seconds_with_fractional_seconds_format) != string_type::npos) {
         // replace %s with %S.nnn
@@ -366,7 +397,7 @@ namespace date_time {
       }
       if (format.find(fractional_seconds_format) != string_type::npos) {
         // replace %f with nnnnnnn
-        if (!frac_str.size()) {
+        if (frac_str.empty()) {
           frac_str = fractional_seconds_as_string(a_time.time_of_day(), false);
         }
         boost::algorithm::replace_all(format,
@@ -428,6 +459,14 @@ namespace date_time {
                                       positive_sign);
       }
 
+      // %T and %R have to be replaced here since they are not standard
+      boost::algorithm::replace_all(format,
+        boost::as_literal(formats_type::full_24_hour_time_format),
+        boost::as_literal(formats_type::full_24_hour_time_expanded_format));
+      boost::algorithm::replace_all(format,
+        boost::as_literal(formats_type::short_24_hour_time_format),
+        boost::as_literal(formats_type::short_24_hour_time_expanded_format));
+
       /*
        * It is possible for a time duration to span more then 24 hours.
        * Standard time_put::put is obliged to behave the same as strftime

data/ext/boost/detail/endian.hpp

@@ -1,5 +1,6 @@
 // Copyright 2005 Caleb Epstein
 // Copyright 2006 John Maddock
+// Copyright 2010 Rene Rivera
 // Distributed under the Boost Software License, Version 1.0. (See accompany-
 // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -42,10 +43,12 @@
 #  error Unknown machine endianness detected.
 # endif
 # define BOOST_BYTE_ORDER __BYTE_ORDER
-#elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
+#elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) || \
+    defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
 # define BOOST_BIG_ENDIAN
 # define BOOST_BYTE_ORDER 4321
-#elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
+#elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) || \
+    defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
 # define BOOST_LITTLE_ENDIAN
 # define BOOST_BYTE_ORDER 1234
 #elif defined(__sparc) || defined(__sparc__) \

data/ext/boost/detail/lcast_precision.hpp

@@ -173,8 +173,8 @@ inline void lcast_set_precision(std::ios_base& stream, T*)
 template<class Source, class Target>
 inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
 {
-    std::streamsize const s = lcast_get_precision((Source*)0);
-    std::streamsize const t = lcast_get_precision((Target*)0);
+    std::streamsize const s = lcast_get_precision(static_cast<Source*>(0));
+    std::streamsize const t = lcast_get_precision(static_cast<Target*>(0));
     stream.precision(s > t ? s : t);
 }
 

data/ext/boost/detail/sp_typeinfo.hpp

@@ -74,7 +74,7 @@ template<class T> struct sp_typeid_
     }
 };
 
-template<class T> sp_typeinfo sp_typeid_< T >::ti_( sp_typeid_< T >::name() );
+template<class T> sp_typeinfo sp_typeid_< T >::ti_ = sp_typeid_< T >::name();
 
 template<class T> struct sp_typeid_< T & >: sp_typeid_< T >
 {

data/ext/boost/detail/workaround.hpp

@@ -65,6 +65,11 @@
 #else
 #define BOOST_MSVC_WORKAROUND_GUARD 0
 #endif
+#ifndef BOOST_MSVC_FULL_VER
+#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
+#else
+#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0
+#endif
 #ifndef __GNUC__
 #define __GNUC___WORKAROUND_GUARD 1
 #else

data/ext/boost/exception/detail/error_info_impl.hpp

@@ -1,4 +1,4 @@
-//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2010 Emil Dotchevski and Reverge Studios, Inc.
 
 //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)
@@ -25,7 +25,7 @@ boost
             {
             public:
 
-            virtual char const * tag_typeid_name() const = 0;
+            virtual std::string tag_typeid_name() const = 0;
             virtual std::string value_as_string() const = 0;
 
             protected:
@@ -62,7 +62,7 @@ boost
 
         private:
 
-        char const * tag_typeid_name() const;
+        std::string tag_typeid_name() const;
         std::string value_as_string() const;
 
         value_type value_;

data/ext/boost/exception/detail/exception_ptr.hpp

@@ -28,6 +28,26 @@
 namespace
 boost
     {
+    typedef shared_ptr<exception_detail::clone_base const> exception_ptr;
+
+    exception_ptr current_exception();
+
+    template <class T>
+    inline
+    exception_ptr
+    copy_exception( T const & e )
+        {
+        try
+            {
+            throw enable_current_exception(e);
+            }
+        catch(
+        ... )
+            {
+            return current_exception();
+            }
+        }
+
 #ifndef BOOST_NO_RTTI
     typedef error_info<struct tag_original_exception_type,std::type_info const *> original_exception_type;
 
@@ -39,91 +59,47 @@ boost
         }
 #endif
 
-    class exception_ptr;
-    exception_ptr current_exception();
-    void rethrow_exception( exception_ptr const & );
-
-    class
-    exception_ptr
+    namespace
+    exception_detail
         {
-        typedef bool exception_ptr::*unspecified_bool_type;
-        friend exception_ptr current_exception();
-        friend void rethrow_exception( exception_ptr const & );
-
-        shared_ptr<exception_detail::clone_base const> c_;
-        bool bad_alloc_;
-
         struct
-        bad_alloc_tag
-            {
-            };
-
-        explicit
-        exception_ptr( bad_alloc_tag ):
-            bad_alloc_(true)
-            {
-            }
-
-        explicit
-        exception_ptr( shared_ptr<exception_detail::clone_base const> const & c ):
-            c_(c),
-            bad_alloc_(false)
-            {
-            BOOST_ASSERT(c);
-            }
-
-        void
-        rethrow() const
-            {
-            BOOST_ASSERT(*this);
-            if( bad_alloc_ )
-                throw enable_current_exception(std::bad_alloc());
-            else
-                c_->rethrow();
-            }
-
-        bool
-        empty() const
-            {
-            return !bad_alloc_ && !c_;
-            }
-
-        public:
-
-        exception_ptr():
-            bad_alloc_(false)
-            {
-            }
-
-        ~exception_ptr() throw()
-            {
-            }
+        bad_alloc_:
+            boost::exception,
+            std::bad_alloc
+                {
+                };
 
-        operator unspecified_bool_type() const
+        template <int Dummy>
+        exception_ptr
+        get_bad_alloc()
             {
-            return empty() ? 0 : &exception_ptr::bad_alloc_;
+            bad_alloc_ ba;
+            exception_detail::clone_impl<bad_alloc_> c(ba);
+            c <<
+                throw_function(BOOST_CURRENT_FUNCTION) <<
+                throw_file(__FILE__) <<
+                throw_line(__LINE__);
+            static exception_ptr ep(new exception_detail::clone_impl<bad_alloc_>(c));
+            return ep;
             }
 
-        friend
-        bool
-        operator==( exception_ptr const & a, exception_ptr const & b )
+        template <int Dummy>
+        struct
+        exception_ptr_bad_alloc
             {
-            return a.c_==b.c_ && a.bad_alloc_==b.bad_alloc_;
-            }
+            static exception_ptr const e;
+            };
 
-        friend
-        bool
-        operator!=( exception_ptr const & a, exception_ptr const & b )
-            {
-            return !(a==b);
-            }
-        };
+        template <int Dummy>
+        exception_ptr const
+        exception_ptr_bad_alloc<Dummy>::
+        e = get_bad_alloc<Dummy>();
+        }
 
     class
     unknown_exception:
-        public exception,
-        public std::exception,
-        public exception_detail::clone_base
+        public boost::exception,
+        public std::exception
         {
         public:
 
@@ -150,18 +126,6 @@ boost
 
         private:
 
-        exception_detail::clone_base const *
-        clone() const
-            {
-            return new unknown_exception(*this);
-            }
-
-        void
-        rethrow() const
-            {
-            throw*this;
-            }
-
         template <class E>
         void
         add_original_type( E const & e )
@@ -179,8 +143,7 @@ boost
         class
         current_exception_std_exception_wrapper:
             public T,
-            public boost::exception,
-            public clone_base
+            public boost::exception
             {
             public:
 
@@ -204,18 +167,6 @@ boost
 
             private:
 
-            clone_base const *
-            clone() const
-                {
-                return new current_exception_std_exception_wrapper(*this);
-                }
-
-            void
-            rethrow() const
-                {
-                throw *this;
-                }
-
             template <class E>
             void
             add_original_type( E const & e )
@@ -228,7 +179,7 @@ boost
 
 #ifdef BOOST_NO_RTTI
         template <class T>
-        exception const *
+        boost::exception const *
         get_boost_exception( T const * )
             {
             try
@@ -236,7 +187,7 @@ boost
                 throw;
                 }
             catch(
-            exception & x )
+            boost::exception & x )
                 {
                 return &x;
                 }
@@ -247,50 +198,50 @@ boost
             }
 #else
         template <class T>
-        exception const *
+        boost::exception const *
         get_boost_exception( T const * x )
             {
-            return dynamic_cast<exception const *>(x);
+            return dynamic_cast<boost::exception const *>(x);
             }
 #endif
 
         template <class T>
         inline
-        shared_ptr<clone_base const>
+        exception_ptr
         current_exception_std_exception( T const & e1 )
             {
             if( boost::exception const * e2 = get_boost_exception(&e1) )
-                return shared_ptr<current_exception_std_exception_wrapper<T> const>(new current_exception_std_exception_wrapper<T>(e1,*e2));
+                return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1,*e2));
             else
-                return shared_ptr<current_exception_std_exception_wrapper<T> const>(new current_exception_std_exception_wrapper<T>(e1));
+                return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1));
             }
 
         inline
-        shared_ptr<clone_base const>
+        exception_ptr
         current_exception_unknown_exception()
             {
-            return shared_ptr<unknown_exception const>(new unknown_exception());
+            return boost::copy_exception(unknown_exception());
             }
 
         inline
-        shared_ptr<clone_base const>
+        exception_ptr
         current_exception_unknown_boost_exception( boost::exception const & e )
             {
-            return shared_ptr<unknown_exception const>(new unknown_exception(e));
+            return boost::copy_exception(unknown_exception(e));
             }
 
         inline
-        shared_ptr<clone_base const>
+        exception_ptr
         current_exception_unknown_std_exception( std::exception const & e )
             {
             if( boost::exception const * be = get_boost_exception(&e) )
                 return current_exception_unknown_boost_exception(*be);
             else
-                return shared_ptr<unknown_exception const>(new unknown_exception(e));
+                return boost::copy_exception(unknown_exception(e));
             }
 
         inline
-        shared_ptr<clone_base const>
+        exception_ptr
         current_exception_impl()
             {
             try
@@ -300,7 +251,7 @@ boost
             catch(
             exception_detail::clone_base & e )
                 {
-                return shared_ptr<exception_detail::clone_base const>(e.clone());
+                return exception_ptr(e.clone());
                 }
             catch(
             std::domain_error & e )
@@ -396,24 +347,28 @@ boost
     exception_ptr
     current_exception()
         {
+        exception_ptr ret;
+        BOOST_ASSERT(!ret);
         try
             {
-            return exception_ptr(exception_detail::current_exception_impl());
+            ret=exception_detail::current_exception_impl();
             }
         catch(
         std::bad_alloc & )
             {
+            ret=exception_detail::exception_ptr_bad_alloc<42>::e;
             }
         catch(
         ... )
             {
             try
                 {
-                return exception_ptr(exception_detail::current_exception_std_exception(std::bad_exception()));
+                ret=exception_detail::current_exception_std_exception(std::bad_exception());
                 }
             catch(
             std::bad_alloc & )
                 {
+                ret=exception_detail::exception_ptr_bad_alloc<42>::e;
                 }
             catch(
             ... )
@@ -421,30 +376,16 @@ boost
                 BOOST_ASSERT(0);
                 }
             }
-        return exception_ptr(exception_ptr::bad_alloc_tag());
-        }
-
-    template <class T>
-    inline
-    exception_ptr
-    copy_exception( T const & e )
-        {
-        try
-            {
-            throw enable_current_exception(e);
-            }
-        catch(
-        ... )
-            {
-            return current_exception();
-            }
+        BOOST_ASSERT(ret);
+        return ret;
         }
 
     inline
     void
     rethrow_exception( exception_ptr const & p )
         {
-        p.rethrow();
+        BOOST_ASSERT(p);
+        p->rethrow();
         }
 
     inline