passenger 2.2.15 → 3.0.0.pre1

data/ext/boost/date_time/time_formatting_streams.hpp

@@ -6,15 +6,19 @@
  * 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: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ * $Date: 2008-11-12 14:37:53 -0500 (Wed, 12 Nov 2008) $
  */
 
-
-#include "boost/date_time/date_formatting_locales.hpp" 
-#include "boost/date_time/time_resolution_traits.hpp"
+#include <boost/date_time/compiler_config.hpp>
 
 #ifndef BOOST_DATE_TIME_NO_LOCALE
 
+#include <locale>
+#include <iomanip>
+#include <iostream>
+#include <boost/date_time/date_formatting_locales.hpp>
+#include <boost/date_time/time_resolution_traits.hpp>
+
 namespace boost {
 namespace date_time {
 
@@ -116,4 +120,3 @@ namespace date_time {
 #endif //BOOST_DATE_TIME_NO_LOCALE
 
 #endif
-

data/ext/boost/date_time/time_resolution_traits.hpp

@@ -2,26 +2,27 @@
 #define DATE_TIME_TIME_RESOLUTION_TRAITS_HPP
 
 /* Copyright (c) 2002,2003 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+ * Use, modification and distribution is subject to the
  * 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: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ * $Date: 2009-06-06 07:25:55 -0400 (Sat, 06 Jun 2009) $
  */
 
 
-#include "boost/date_time/time_defs.hpp"
-#include "boost/date_time/int_adapter.hpp"
-#include "boost/cstdint.hpp"
+#include <boost/cstdint.hpp>
+#include <boost/date_time/time_defs.hpp>
+#include <boost/date_time/int_adapter.hpp>
+#include <boost/date_time/compiler_config.hpp>
 
 namespace boost {
 namespace date_time {
 
   //! Simple function to calculate absolute value of a numeric type
-  template <typename T> 
-  // JDG [7/6/02 made a template], 
+  template <typename T>
+  // JDG [7/6/02 made a template],
   // moved here from time_duration.hpp 2003-Sept-4.
-  inline T absolute_value(T x) 
+  inline T absolute_value(T x)
   {
     return x < 0 ? -x : x;
   }
@@ -58,16 +59,16 @@ namespace date_time {
     //! Used to determine if implemented type is int_adapter or int
     static bool is_adapted() { return true;}
   };
-  
-  template<typename frac_sec_type, 
+
+  template<typename frac_sec_type,
            time_resolutions res,
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
-             boost::int64_t resolution_adjust,
+           boost::int64_t resolution_adjust,
 #else
-             typename frac_sec_type::int_type resolution_adjust,
+           typename frac_sec_type::int_type resolution_adjust,
 #endif
-             unsigned short frac_digits,
-             typename v_type = boost::int32_t >
+           unsigned short frac_digits,
+           typename v_type = boost::int32_t >
   class time_resolution_traits {
   public:
     typedef typename frac_sec_type::int_type fractional_seconds_type;
@@ -77,9 +78,9 @@ namespace date_time {
     typedef v_type  hour_type;
     typedef v_type  min_type;
     typedef v_type  sec_type;
-    
+
     // bring in function from frac_sec_type traits structs
-    static typename frac_sec_type::int_type as_number(typename frac_sec_type::impl_type i)
+    static fractional_seconds_type as_number(impl_type i)
     {
       return frac_sec_type::as_number(i);
     }
@@ -87,11 +88,14 @@ namespace date_time {
     {
       return frac_sec_type::is_adapted();
     }
-    
+
     //Would like this to be frac_sec_type, but some compilers complain
-    BOOST_STATIC_CONSTANT(int, ticks_per_second = resolution_adjust);
-    //    static const boost::int32_t ticks_per_second = resolution_adjust;
-    
+#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
+    BOOST_STATIC_CONSTANT(boost::int64_t, ticks_per_second = resolution_adjust);
+#else
+    BOOST_STATIC_CONSTANT(fractional_seconds_type, ticks_per_second = resolution_adjust);
+#endif
+
     static time_resolutions resolution()
     {
       return res;
@@ -116,16 +120,16 @@ namespace date_time {
         minutes = absolute_value(minutes);
         seconds = absolute_value(seconds);
         fs = absolute_value(fs);
-        return (((((fractional_seconds_type(hours)*3600) 
-                   + (fractional_seconds_type(minutes)*60) 
+        return (((((fractional_seconds_type(hours)*3600)
+                   + (fractional_seconds_type(minutes)*60)
                    + seconds)*res_adjust()) + fs) * -1);
       }
 
-      return (((fractional_seconds_type(hours)*3600) 
-               + (fractional_seconds_type(minutes)*60) 
+      return (((fractional_seconds_type(hours)*3600)
+               + (fractional_seconds_type(minutes)*60)
                + seconds)*res_adjust()) + fs;
     }
-    
+
   };
 
   typedef time_resolution_traits<time_resolution_traits_adapted32_impl, milli, 1000, 3 > milli_res;

data/ext/boost/date_time/time_system_split.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: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ * $Date: 2008-11-13 15:10:23 -0500 (Thu, 13 Nov 2008) $
  */
 
 
@@ -76,7 +76,7 @@ namespace date_time {
 
     static time_rep_type get_time_rep(const date_type& day,
                                       const time_duration_type& tod,
-                                      date_time::dst_flags dst=not_dst)
+                                      date_time::dst_flags /* dst */ = not_dst)
     {
       if(day.is_special() || tod.is_special()) {
         if(day.is_not_a_date() || tod.is_not_a_date_time()) {
@@ -132,7 +132,7 @@ namespace date_time {
     }
     static std::string zone_name(const time_rep_type&)
     {
-      return "";
+      return std::string();
     }
     static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
     {
@@ -166,12 +166,9 @@ namespace date_time {
         return add_time_duration(base,td1);
       }
 
-      //std::cout << td.ticks() << std::endl;
       wrap_int_type  day_offset(base.time_of_day.ticks());
       date_duration_type day_overflow(static_cast<typename date_duration_type::duration_rep_type>(day_offset.subtract(td.ticks())));
-//       std::cout << "sub: " << base.time_of_day.ticks() << "|"
-//                 << day_offset.as_int() << "|"
-//                 << day_overflow.days() << std::endl;
+
       return time_rep_type(base.day-day_overflow,
                            time_duration_type(0,0,0,day_offset.as_int()));
     }
@@ -185,13 +182,10 @@ namespace date_time {
         time_duration_type td1 = td.invert_sign();
         return subtract_time_duration(base,td1);
       }
+
       wrap_int_type day_offset(base.time_of_day.ticks());      
-      typename date_duration_type::duration_rep_type doff = day_offset.add(td.ticks());
-//       std::cout << "day overflow: " << doff << std::endl;
-//       std::cout << "ticks: "         << td.ticks() << std::endl;
-      date_duration_type day_overflow(doff);
-//       std::cout << "base: " << to_simple_string(base.day) << std::endl;
-//       std::cout << "overflow " << day_overflow.days() << std::endl;
+      date_duration_type day_overflow(static_cast< typename date_duration_type::duration_rep_type >(day_offset.add(td.ticks())));
+
       return time_rep_type(base.day+day_overflow,
                            time_duration_type(0,0,0,day_offset.as_int()));
     }

data/ext/boost/date_time/wrapping_int.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: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ * $Date: 2008-11-12 14:37:53 -0500 (Wed, 12 Nov 2008) $
  */
 
 
@@ -43,10 +43,11 @@ public:
    * wraps went. Ex: add a negative number and wrapping under could occur,
    * this would be indicated by a negative return value. If wrapping over 
    * took place, a positive value would be returned */
-  int_type add(int_type v) 
+  template< typename IntT >
+  IntT add(IntT v) 
   {
     int_type remainder = static_cast<int_type>(v % (wrap_val));
-    int_type overflow = static_cast<int_type>(v / (wrap_val));
+    IntT overflow = static_cast<IntT>(v / (wrap_val));
     value_ = static_cast<int_type>(value_ + remainder);
     return calculate_wrap(overflow);
   }
@@ -56,26 +57,28 @@ public:
    * Ex: subtract a negative number and wrapping over could 
    * occur, this would be indicated by a negative return value. If 
    * wrapping under took place, a positive value would be returned. */
-  int_type subtract(int_type v) 
+  template< typename IntT >
+  IntT subtract(IntT v) 
   {
     int_type remainder = static_cast<int_type>(v % (wrap_val));
-    int_type underflow = static_cast<int_type>(-(v / (wrap_val)));
+    IntT underflow = static_cast<IntT>(-(v / (wrap_val)));
     value_ = static_cast<int_type>(value_ - remainder);
     return calculate_wrap(underflow) * -1;
   }
 private:
   int_type value_;
 
-  int_type calculate_wrap(int_type wrap)
+  template< typename IntT >
+  IntT calculate_wrap(IntT wrap)
   {
     if ((value_) >= wrap_val) 
     {
-      wrap++;
+      ++wrap;
       value_ -= (wrap_val);
     }
     else if(value_ < 0) 
     {
-      wrap--;
+      --wrap;
       value_ += (wrap_val);
     }
     return wrap;
@@ -114,10 +117,11 @@ public:
    * wraps went. Ex: add a negative number and wrapping under could occur,
    * this would be indicated by a negative return value. If wrapping over 
    * took place, a positive value would be returned */
-  int_type add(int_type v) 
+  template< typename IntT >
+  IntT add(IntT v) 
   {
     int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1));
-    int_type overflow = static_cast<int_type>(v / (wrap_max - wrap_min + 1));
+    IntT overflow = static_cast<IntT>(v / (wrap_max - wrap_min + 1));
     value_ = static_cast<int_type>(value_ + remainder);
     return calculate_wrap(overflow);
   }
@@ -126,10 +130,11 @@ public:
    * wraps went. Ex: subtract a negative number and wrapping over could 
    * occur, this would be indicated by a positive return value. If 
    * wrapping under took place, a negative value would be returned */
-  int_type subtract(int_type v) 
+  template< typename IntT >
+  IntT subtract(IntT v) 
   {
     int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1));
-    int_type underflow = static_cast<int_type>(-(v / (wrap_max - wrap_min + 1)));
+    IntT underflow = static_cast<IntT>(-(v / (wrap_max - wrap_min + 1)));
     value_ = static_cast<int_type>(value_ - remainder);
     return calculate_wrap(underflow);
   }
@@ -137,16 +142,17 @@ public:
 private:
   int_type value_;
 
-  int_type calculate_wrap(int_type wrap)
+  template< typename IntT >
+  IntT calculate_wrap(IntT wrap)
   {
     if ((value_) > wrap_max) 
     {
-      wrap++;
+      ++wrap;
       value_ -= (wrap_max - wrap_min + 1);
     }
     else if((value_) < wrap_min) 
     {
-      wrap--;
+      --wrap;
       value_ += (wrap_max - wrap_min + 1);
     }
     return wrap;

data/ext/boost/detail/call_traits.hpp

@@ -92,7 +92,7 @@ struct call_traits<T&>
    typedef T& param_type;  // hh removed const
 };
 
-#if BOOST_WORKAROUND( __BORLANDC__,  BOOST_TESTED_AT( 0x581 ) )
+#if BOOST_WORKAROUND( __BORLANDC__,  < 0x5A0 )
 // these are illegal specialisations; cv-qualifies applied to
 // references have no effect according to [8.3.2p1],
 // C++ Builder requires them though as it treats cv-qualified

data/ext/boost/detail/endian.hpp

@@ -42,15 +42,15 @@
 #  error Unknown machine endianness detected.
 # endif
 # define BOOST_BYTE_ORDER __BYTE_ORDER
-#elif defined(_BIG_ENDIAN)
+#elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
 # define BOOST_BIG_ENDIAN
 # define BOOST_BYTE_ORDER 4321
-#elif defined(_LITTLE_ENDIAN)
+#elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
 # define BOOST_LITTLE_ENDIAN
 # define BOOST_BYTE_ORDER 1234
 #elif defined(__sparc) || defined(__sparc__) \
    || defined(_POWER) || defined(__powerpc__) \
-   || defined(__ppc__) || defined(__hpux) \
+   || defined(__ppc__) || defined(__hpux) || defined(__hppa) \
    || defined(_MIPSEB) || defined(_POWER) \
    || defined(__s390__)
 # define BOOST_BIG_ENDIAN
@@ -61,7 +61,7 @@
    || defined(_M_ALPHA) || defined(__amd64) \
    || defined(__amd64__) || defined(_M_AMD64) \
    || defined(__x86_64) || defined(__x86_64__) \
-   || defined(_M_X64)
+   || defined(_M_X64) || defined(__bfin__)
 
 # define BOOST_LITTLE_ENDIAN
 # define BOOST_BYTE_ORDER 1234

data/ext/boost/detail/no_exceptions_support.hpp

@@ -0,0 +1,87 @@
+#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
+#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+//----------------------------------------------------------------------
+// (C) Copyright 2004 Pavel Vozenilek.
+// Use, modification and distribution is subject to 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)
+//
+//
+// This file contains helper macros used when exception support may be
+// disabled (as indicated by macro BOOST_NO_EXCEPTIONS).
+//
+// Before picking up these macros you may consider using RAII techniques
+// to deal with exceptions - their syntax can be always the same with 
+// or without exception support enabled.
+//
+
+/* Example of use:
+
+void foo() {
+  BOOST_TRY {
+    ...
+  } BOOST_CATCH(const std::bad_alloc&) {
+      ...
+      BOOST_RETHROW
+  } BOOST_CATCH(const std::exception& e) {
+      ...
+  }
+  BOOST_CATCH_END
+}
+
+With exception support enabled it will expand into:
+
+void foo() {
+  { try {
+    ...
+  } catch (const std::bad_alloc&) {
+      ...
+      throw;
+  } catch (const std::exception& e) {
+      ...
+  }
+  }
+}
+
+With exception support disabled it will expand into:
+
+void foo() {
+  { if(true) {
+    ...
+  } else if (false) {
+      ...
+  } else if (false)  {
+      ...
+  }
+  }
+}
+*/
+//----------------------------------------------------------------------
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if !(defined BOOST_NO_EXCEPTIONS)
+#    define BOOST_TRY { try
+#    define BOOST_CATCH(x) catch(x)
+#    define BOOST_RETHROW throw;
+#    define BOOST_CATCH_END }
+#else
+#    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#        define BOOST_TRY { if ("")
+#        define BOOST_CATCH(x) else if (!"")
+#    else
+#        define BOOST_TRY { if (true)
+#        define BOOST_CATCH(x) else if (false)
+#    endif
+#    define BOOST_RETHROW
+#    define BOOST_CATCH_END }
+#endif
+
+
+#endif 

data/ext/boost/detail/sp_typeinfo.hpp

@@ -19,20 +19,66 @@
 
 #if defined( BOOST_NO_TYPEID )
 
+#include <boost/current_function.hpp>
+#include <functional>
+
 namespace boost
 {
 
 namespace detail
 {
 
-typedef void* sp_typeinfo;
+class sp_typeinfo
+{
+private:
+
+    sp_typeinfo( sp_typeinfo const& );
+    sp_typeinfo& operator=( sp_typeinfo const& );
+
+    char const * name_;
+
+public:
+
+    explicit sp_typeinfo( char const * name ): name_( name )
+    {
+    }
+
+    bool operator==( sp_typeinfo const& rhs ) const
+    {
+        return this == &rhs;
+    }
+
+    bool operator!=( sp_typeinfo const& rhs ) const
+    {
+        return this != &rhs;
+    }
+
+    bool before( sp_typeinfo const& rhs ) const
+    {
+        return std::less< sp_typeinfo const* >()( this, &rhs );
+    }
+
+    char const* name() const
+    {
+        return name_;
+    }
+};
 
 template<class T> struct sp_typeid_
 {
-    static char v_;
+    static sp_typeinfo ti_;
+
+    static char const * name()
+    {
+        return BOOST_CURRENT_FUNCTION;
+    }
 };
 
-template<class T> char sp_typeid_< T >::v_;
+template<class T> sp_typeinfo sp_typeid_< T >::ti_( sp_typeid_< T >::name() );
+
+template<class T> struct sp_typeid_< T & >: sp_typeid_< T >
+{
+};
 
 template<class T> struct sp_typeid_< T const >: sp_typeid_< T >
 {
@@ -50,7 +96,7 @@ template<class T> struct sp_typeid_< T const volatile >: sp_typeid_< T >
 
 } // namespace boost
 
-#define BOOST_SP_TYPEID(T) (&boost::detail::sp_typeid_<T>::v_)
+#define BOOST_SP_TYPEID(T) (boost::detail::sp_typeid_<T>::ti_)
 
 #else