passenger 2.2.15 → 3.0.0.pre1

data/ext/boost/date_time/filetime_functions.hpp

@@ -6,70 +6,162 @@
  * 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:24:09 -0400 (Sat, 06 Jun 2009) $
  */
 
 /*! @file filetime_functions.hpp
- * Function(s) for converting between a FILETIME structure and a 
+ * Function(s) for converting between a FILETIME structure and a
  * time object. This file is only available on systems that have
  * BOOST_HAS_FTIME defined.
  */
 
 #include <boost/date_time/compiler_config.hpp>
+
 #if defined(BOOST_HAS_FTIME) // skip this file if no FILETIME
-#include <windows.h>
+
+#if defined(BOOST_USE_WINDOWS_H)
+#  include <windows.h>
+#endif
+
 #include <boost/cstdint.hpp>
 #include <boost/date_time/time.hpp>
-
+#include <boost/date_time/date_defs.hpp>
 
 namespace boost {
+
 namespace date_time {
 
+namespace winapi {
+
+#if !defined(BOOST_USE_WINDOWS_H)
+
+    extern "C" {
+
+        struct FILETIME
+        {
+            boost::uint32_t dwLowDateTime;
+            boost::uint32_t dwHighDateTime;
+        };
+        struct SYSTEMTIME
+        {
+            boost::uint16_t wYear;
+            boost::uint16_t wMonth;
+            boost::uint16_t wDayOfWeek;
+            boost::uint16_t wDay;
+            boost::uint16_t wHour;
+            boost::uint16_t wMinute;
+            boost::uint16_t wSecond;
+            boost::uint16_t wMilliseconds;
+        };
+
+        __declspec(dllimport) void __stdcall GetSystemTimeAsFileTime(FILETIME* lpFileTime);
+        __declspec(dllimport) int __stdcall FileTimeToLocalFileTime(const FILETIME* lpFileTime, FILETIME* lpLocalFileTime);
+        __declspec(dllimport) void __stdcall GetSystemTime(SYSTEMTIME* lpSystemTime);
+        __declspec(dllimport) int __stdcall SystemTimeToFileTime(const SYSTEMTIME* lpSystemTime, FILETIME* lpFileTime);
+
+    } // extern "C"
+
+#endif // defined(BOOST_USE_WINDOWS_H)
+
+    typedef FILETIME file_time;
+    typedef SYSTEMTIME system_time;
+
+    inline void get_system_time_as_file_time(file_time& ft)
+    {
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+        // Some runtime library implementations expect local times as the norm for ctime.
+        file_time ft_utc;
+        GetSystemTimeAsFileTime(&ft_utc);
+        FileTimeToLocalFileTime(&ft_utc, &ft);
+#elif defined(BOOST_NO_GETSYSTEMTIMEASFILETIME)
+        system_time st;
+        GetSystemTime(&st);
+        SystemTimeToFileTime(&st, &ft);
+#else
+        GetSystemTimeAsFileTime(&ft);
+#endif
+    }
+
+    /*!
+     * The function converts file_time into number of microseconds elapsed since 1970-Jan-01
+     *
+     * \note Only dates after 1970-Jan-01 are supported. Dates before will be wrapped.
+     *
+     * \note The function is templated on the FILETIME type, so that
+     *       it can be used with both native FILETIME and the ad-hoc
+     *       boost::date_time::winapi::file_time type.
+     */
+    template< typename FileTimeT >
+    inline boost::uint64_t file_time_to_microseconds(FileTimeT const& ft)
+    {
+        /* shift is difference between 1970-Jan-01 & 1601-Jan-01
+        * in 100-nanosecond intervals */
+        const uint64_t shift = 116444736000000000ULL; // (27111902 << 32) + 3577643008
+
+        union {
+            FileTimeT as_file_time;
+            uint64_t as_integer; // 100-nanos since 1601-Jan-01
+        } caster;
+        caster.as_file_time = ft;
+
+        caster.as_integer -= shift; // filetime is now 100-nanos since 1970-Jan-01
+        return (caster.as_integer / 10); // truncate to microseconds
+    }
+
+} // namespace winapi
+
+//! Create a time object from an initialized FILETIME struct.
+/*!
+ * Create a time object from an initialized FILETIME struct.
+ * A FILETIME struct holds 100-nanosecond units (0.0000001). When
+ * built with microsecond resolution the file_time's sub second value
+ * will be truncated. Nanosecond resolution has no truncation.
+ *
+ * \note The function is templated on the FILETIME type, so that
+ *       it can be used with both native FILETIME and the ad-hoc
+ *       boost::date_time::winapi::file_time type.
+ */
+template< typename TimeT, typename FileTimeT >
+inline
+TimeT time_from_ftime(const FileTimeT& ft)
+{
+    typedef typename TimeT::date_type date_type;
+    typedef typename TimeT::date_duration_type date_duration_type;
+    typedef typename TimeT::time_duration_type time_duration_type;
+
+    // https://svn.boost.org/trac/boost/ticket/2523
+    // Since this function can be called with arbitrary times, including ones that
+    // are before 1970-Jan-01, we'll have to cast the time a bit differently,
+    // than it is done in the file_time_to_microseconds function. This allows to
+    // avoid integer wrapping for dates before 1970-Jan-01.
+    union {
+        FileTimeT as_file_time;
+        uint64_t as_integer; // 100-nanos since 1601-Jan-01
+    } caster;
+    caster.as_file_time = ft;
 
-  //! Create a time object from an initialized FILETIME struct.
-  /*! Create a time object from an initialized FILETIME struct.
-   * A FILETIME struct holds 100-nanosecond units (0.0000001). When 
-   * built with microsecond resolution the FILETIME's sub second value 
-   * will be truncated. Nanosecond resolution has no truncation. */
-  template<class time_type>
-  inline
-  time_type time_from_ftime(const FILETIME& ft){
-    typedef typename time_type::date_type date_type;
-    typedef typename time_type::date_duration_type date_duration_type;
-    typedef typename time_type::time_duration_type time_duration_type;
-
-    /* OFFSET is difference between 1970-Jan-01 & 1601-Jan-01 
-     * in 100-nanosecond intervals */
-    uint64_t c1 = 27111902UL; 
-    uint64_t c2 = 3577643008UL; // issues warning without 'UL'
-    const uint64_t OFFSET = (c1 << 32) + c2;
-    const long sec_pr_day = 86400; // seconds per day
-
-    uint64_t filetime = ft.dwHighDateTime;
-    filetime <<= 32;
-    filetime += ft.dwLowDateTime;
-    filetime -= OFFSET; // filetime is now 100-nanos since 1970-Jan-01
-
-    uint64_t sec = filetime / 10000000;
-#if defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
-    uint64_t sub_sec = (filetime % 10000000) * 100; // nanoseconds
+    uint64_t sec = caster.as_integer / 10000000UL;
+    uint32_t sub_sec = (caster.as_integer % 10000000UL) // 100-nanoseconds since the last second
+#if !defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
+        / 10; // microseconds since the last second
 #else
-    uint64_t sub_sec = (filetime % 10000000) / 10; // truncate to microseconds
+        * 100; // nanoseconds since the last second
 #endif
 
     // split sec into usable chunks: days, hours, minutes, & seconds
-    long _d = sec / sec_pr_day;
-    long tmp = sec % sec_pr_day;
-    long _h = tmp / 3600; // sec_pr_hour
+    const uint32_t sec_per_day = 86400; // seconds per day
+    uint32_t days = static_cast< uint32_t >(sec / sec_per_day);
+    uint32_t tmp = static_cast< uint32_t >(sec % sec_per_day);
+    uint32_t hours = tmp / 3600; // sec_per_hour
     tmp %= 3600;
-    long _m = tmp / 60; // sec_pr_min
+    uint32_t minutes = tmp / 60; // sec_per_min
     tmp %= 60;
-    long _s = tmp; // seconds
+    uint32_t seconds = tmp; // seconds
 
-    date_duration_type dd(_d);
-    date_type d = date_type(1970, Jan, 01) + dd;
-    return time_type(d, time_duration_type(_h, _m, _s, sub_sec));
-  }
+    date_duration_type dd(days);
+    date_type d = date_type(1601, Jan, 01) + dd;
+    return TimeT(d, time_duration_type(hours, minutes, seconds, sub_sec));
+}
 
 }} // boost::date_time
 

data/ext/boost/date_time/format_date_parser.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: Jeff Garland, Bart Garst
- * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ * $Date: 2009-06-04 04:24:49 -0400 (Thu, 04 Jun 2009) $
  */
 
 
@@ -17,7 +17,20 @@
 #include "boost/date_time/special_values_parser.hpp"
 #include <string>
 #include <vector>
+#include <sstream>
+#include <iterator>
+#ifndef BOOST_NO_STDC_NAMESPACE
+#  include <cctype>
+#else
+#  include <ctype.h>
+#endif
 
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+  using ::isspace;
+  using ::isdigit;
+}
+#endif
 namespace boost { namespace date_time {
   
 //! Helper function for parsing fixed length strings into integers
@@ -57,7 +70,7 @@ fixed_string_to_int(std::istreambuf_iterator<charT>& itr,
   }
   try {
     i = boost::lexical_cast<int_type>(mr.cache);
-  }catch(bad_lexical_cast blc){
+  }catch(bad_lexical_cast&){
     // we want to return -1 if the cast fails so nothing to do here
   }
   return i;
@@ -87,19 +100,19 @@ template<typename int_type, typename charT>
 inline
 int_type
 var_string_to_int(std::istreambuf_iterator<charT>& itr,
-                  std::istreambuf_iterator<charT>& /* stream_end */,
+                  const std::istreambuf_iterator<charT>& stream_end,
                   unsigned int max_length)
 {
   typedef std::basic_string<charT>  string_type;
   unsigned int j = 0;
   string_type s;
-  while ((j < max_length) && std::isdigit(*itr)) {
+  while (itr != stream_end && (j < max_length) && std::isdigit(*itr)) {
     s += (*itr);
-    itr++;
-    j++;
+    ++itr;
+    ++j;
   }
   int_type i = -1;
-  if(s.length() != 0) {
+  if(!s.empty()) {
     i = boost::lexical_cast<int_type>(s);
   }
   return i;
@@ -139,7 +152,7 @@ class format_date_parser
 {
  public:
   typedef std::basic_string<charT>        string_type;
-  typedef std::basic_ostringstream<charT>  stringstream_type;
+  typedef std::basic_istringstream<charT>  stringstream_type;
   typedef std::istreambuf_iterator<charT> stream_itr_type;
   typedef typename string_type::const_iterator const_itr;
   typedef typename date_type::year_type  year_type;
@@ -216,8 +229,7 @@ class format_date_parser
              const string_type& format_str,
              const special_values_parser<date_type,charT>& sv_parser) const
   {
-    stringstream_type ss;
-    ss << value; 
+    stringstream_type ss(value);
     stream_itr_type sitr(ss);
     stream_itr_type stream_end;
     return parse_date(sitr, stream_end, format_str, sv_parser);

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

@@ -2,72 +2,65 @@
 #define _GREGORIAN__CONVERSION_HPP___
 
 /* Copyright (c) 2004-2005 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:27:35 -0400 (Sat, 06 Jun 2009) $
  */
 
-#include <exception>
-#include "boost/date_time/gregorian/gregorian_types.hpp"
-#include "boost/date_time/c_time.hpp"
-#if defined(USE_DATE_TIME_PRE_1_33_FACET_IO)
-#  if defined(BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS)
-#    include "boost/date_time/gregorian/formatters_limited.hpp"
-#  else
-#    include "boost/date_time/gregorian/formatters.hpp"
-#  endif // BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS
-#else
-#  include <sstream>
-#  include "boost/date_time/gregorian/gregorian_io.hpp"
-#endif // USE_DATE_TIME_PRE_1_33_FACET_IO
+#include <string>
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/c_time.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/gregorian/gregorian_types.hpp>
 
 namespace boost {
 
 namespace gregorian {
 
-
   //! Converts a date to a tm struct. Throws out_of_range exception if date is a special value
   inline
-  std::tm to_tm(const date& d) 
+  std::tm to_tm(const date& d)
   {
-    if(d.is_pos_infinity() || d.is_neg_infinity() || d.is_not_a_date()){
-#if defined(USE_DATE_TIME_PRE_1_33_FACET_IO)
-      std::string s("tm unable to handle date value of " + to_simple_string(d));
-      throw std::out_of_range(s);
-#else
-      std::stringstream ss;
-      ss << "tm unable to handle date value of " << d;
-      throw std::out_of_range(ss.str());
-#endif // USE_DATE_TIME_PRE_1_33_FACET_IO
+    if (d.is_special())
+    {
+        std::string s = "tm unable to handle ";
+        switch (d.as_special())
+        {
+        case date_time::not_a_date_time:
+            s += "not-a-date-time value"; break;
+        case date_time::neg_infin:
+            s += "-infinity date value"; break;
+        case date_time::pos_infin:
+            s += "+infinity date value"; break;
+        default:
+            s += "a special date value"; break;
+        }
+        boost::throw_exception(std::out_of_range(s));
     }
-    std::tm datetm;
+
+    std::tm datetm = {}; // zero initialization is needed for extension members, like tm_zone
     boost::gregorian::date::ymd_type ymd = d.year_month_day();
-    datetm.tm_year = ymd.year-1900; 
-    datetm.tm_mon = ymd.month-1; 
+    datetm.tm_year = ymd.year - 1900;
+    datetm.tm_mon = ymd.month - 1;
     datetm.tm_mday = ymd.day;
     datetm.tm_wday = d.day_of_week();
-    datetm.tm_yday = d.day_of_year()-1;
-    datetm.tm_hour = datetm.tm_min = datetm.tm_sec = 0;
+    datetm.tm_yday = d.day_of_year() - 1;
     datetm.tm_isdst = -1; // negative because not enough info to set tm_isdst
     return datetm;
   }
 
   //! Converts a tm structure into a date dropping the any time values.
   inline
-  date date_from_tm(const std::tm& datetm) 
+  date date_from_tm(const std::tm& datetm)
   {
-    return date(static_cast<unsigned short>(datetm.tm_year+1900), 
-                static_cast<unsigned short>(datetm.tm_mon+1), 
+    return date(static_cast<unsigned short>(datetm.tm_year+1900),
+                static_cast<unsigned short>(datetm.tm_mon+1),
                 static_cast<unsigned short>(datetm.tm_mday));
   }
-  
 
 } } //namespace boost::gregorian
 
-
-
-
 #endif
-

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

@@ -2,27 +2,28 @@
 #define GREGORIAN_GREGORIAN_CALENDAR_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 
- * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ * Author: Jeff Garland
+ * $Date: 2010-01-10 14:17:23 -0500 (Sun, 10 Jan 2010) $
  */
 
-#include "boost/date_time/gregorian/greg_weekday.hpp"
-#include "boost/date_time/gregorian/greg_day_of_year.hpp"
-#include "boost/date_time/gregorian_calendar.hpp"
-#include "boost/date_time/gregorian/greg_ymd.hpp"
-#include "boost/date_time/int_adapter.hpp"
+#include <boost/cstdint.hpp>
+#include <boost/date_time/gregorian/greg_weekday.hpp>
+#include <boost/date_time/gregorian/greg_day_of_year.hpp>
+#include <boost/date_time/gregorian_calendar.hpp>
+#include <boost/date_time/gregorian/greg_ymd.hpp>
+#include <boost/date_time/int_adapter.hpp>
 
 namespace boost {
 namespace gregorian {
-    
+
   //!An internal date representation that includes infinities, not a date
-  typedef date_time::int_adapter<unsigned long> fancy_date_rep;
+  typedef date_time::int_adapter<uint32_t> fancy_date_rep;
 
   //! Gregorian calendar for this implementation, hard work in the base
-  class gregorian_calendar : 
+  class gregorian_calendar :
     public date_time::gregorian_calendar_base<greg_year_month_day, fancy_date_rep::int_type> {
   public:
     //! Type to hold a weekday (eg: Sunday, Monday,...)
@@ -34,14 +35,14 @@ namespace gregorian {
     //! Date rep implements the traits stuff as well
     typedef fancy_date_rep       date_traits_type;
 
-    
+
   private:
   };
 
 } } //namespace gregorian
-  
+
 
 
 
 #endif
-  
+

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

@@ -2,17 +2,18 @@
 #define GREG_DATE_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 
- * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ * Author: Jeff Garland
+ * $Date: 2010-01-10 14:17:23 -0500 (Sun, 10 Jan 2010) $
  */
 
-#include "boost/date_time/date.hpp"
-#include "boost/date_time/special_defs.hpp"
-#include "boost/date_time/gregorian/greg_calendar.hpp"
-#include "boost/date_time/gregorian/greg_duration.hpp"
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/date.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/gregorian/greg_calendar.hpp>
+#include <boost/date_time/gregorian/greg_duration.hpp>
 
 namespace boost {
 namespace gregorian {
@@ -27,10 +28,10 @@ namespace gregorian {
   using date_time::min_date_time;
 
   //! A date type based on gregorian_calendar
-  /*! This class is the primary interface for programming with 
+  /*! This class is the primary interface for programming with
       greogorian dates.  The is a lightweight type that can be
-      freely passed by value.  All comparison operators are 
-      supported.  
+      freely passed by value.  All comparison operators are
+      supported.
       \ingroup date_basics
   */
   class date : public date_time::date<date, gregorian_calendar, date_duration>
@@ -51,15 +52,15 @@ namespace gregorian {
     {}
 #endif // DATE_TIME_NO_DEFAULT_CONSTRUCTOR
     //! Main constructor with year, month, day
-    date(year_type y, month_type m, day_type d) 
+    date(year_type y, month_type m, day_type d)
       : date_time::date<date, gregorian_calendar, date_duration>(y, m, d)
     {
       if (gregorian_calendar::end_of_month_day(y, m) < d) {
-        throw bad_day_of_month(std::string("Day of month is not valid for year"));
+        boost::throw_exception(bad_day_of_month(std::string("Day of month is not valid for year")));
       }
     }
     //! Constructor from a ymd_type structure
-    explicit date(const ymd_type& ymd) 
+    explicit date(const ymd_type& ymd)
       : date_time::date<date, gregorian_calendar, date_duration>(ymd)
     {}
     //! Needed copy constructor
@@ -98,16 +99,16 @@ namespace gregorian {
       return day_of_year_type(doy);
     }
     //!Return the Modified Julian Day number for the date.
-    long modjulian_day() const
+    date_int_type modjulian_day() const
     {
       ymd_type ymd = year_month_day();
-      return gregorian_calendar::modjulian_day_number(ymd);      
+      return gregorian_calendar::modjulian_day_number(ymd);
     }
     //!Return the iso 8601 week number 1..53
     int week_number() const
     {
       ymd_type ymd = year_month_day();
-      return gregorian_calendar::week_number(ymd);      
+      return gregorian_calendar::week_number(ymd);
     }
     //! Return the day number from the calendar
     date_int_type day_number() const
@@ -117,7 +118,7 @@ namespace gregorian {
     //! Return the last day of the current month
     date end_of_month() const
     {
-      ymd_type ymd = year_month_day(); 
+      ymd_type ymd = year_month_day();
       short eom_day =  gregorian_calendar::end_of_month_day(ymd.year, ymd.month);
       return date(ymd.year, ymd.month, eom_day);
     }
@@ -125,7 +126,7 @@ namespace gregorian {
    private:
 
   };
-  
+
 
 
 } } //namespace gregorian