passenger 2.2.15 → 3.0.0.pre1

data/ext/boost/date_time/strings_from_facet.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
- * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ * $Date: 2009-02-01 06:29:43 -0500 (Sun, 01 Feb 2009) $
  */
 
 #include <sstream>
@@ -49,6 +49,7 @@ gather_month_strings(const std::locale& locale, bool short_strings=true)
   {
     //grab the needed strings by using the locale to
     //output each month
+    const charT* p_outfmt = outfmt.c_str(), *p_outfmt_end = p_outfmt + outfmt.size();
     for (int m=0; m < 12; m++) {
       tm tm_value;
       tm_value.tm_mon = m;
@@ -56,8 +57,8 @@ gather_month_strings(const std::locale& locale, bool short_strings=true)
       ostream_iter_type oitr(ss);
       std::use_facet<time_put_facet_type>(locale).put(oitr, ss, ss.fill(),
                                                       &tm_value,
-                                                      &*outfmt.begin(),
-                                                      &*outfmt.begin()+outfmt.size());
+                                                      p_outfmt,
+                                                      p_outfmt_end);
       months.push_back(ss.str());
     }
   }
@@ -101,6 +102,7 @@ gather_weekday_strings(const std::locale& locale, bool short_strings=true)
   {
     //grab the needed strings by using the locale to
     //output each month / weekday
+    const charT* p_outfmt = outfmt.c_str(), *p_outfmt_end = p_outfmt + outfmt.size();
     for (int i=0; i < 7; i++) {
       tm tm_value;
       tm_value.tm_wday = i;
@@ -108,8 +110,8 @@ gather_weekday_strings(const std::locale& locale, bool short_strings=true)
       ostream_iter_type oitr(ss);
       std::use_facet<time_put_facet_type>(locale).put(oitr, ss, ss.fill(),
                                                       &tm_value,
-                                                      &*outfmt.begin(),
-                                                      &*outfmt.begin()+outfmt.size());
+                                                      p_outfmt,
+                                                      p_outfmt_end);
 
       weekdays.push_back(ss.str());
     }

data/ext/boost/date_time/time.hpp

@@ -6,16 +6,17 @@
  * 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) $
  */
 
 
 /*! @file time.hpp
   This file contains the interface for the time associated classes.
 */
-#include "boost/date_time/time_defs.hpp"
-#include "boost/operators.hpp"
 #include <string>
+#include <boost/operators.hpp>
+#include <boost/date_time/time_defs.hpp>
+#include <boost/date_time/special_defs.hpp>
 
 namespace boost {
 namespace date_time {
@@ -77,21 +78,21 @@ namespace date_time {
     /*! Optional bool parameter will return time zone as an offset 
      * (ie "+07:00"). Empty string is returned for classes that do 
      * not use a time_zone */
-    std::string zone_name(bool as_offset=false) const
+    std::string zone_name(bool /*as_offset*/=false) const
     {
       return time_system::zone_name(time_);
     }
     /*! Optional bool parameter will return time zone as an offset 
      * (ie "+07:00"). Empty string is returned for classes that do 
      * not use a time_zone */
-    std::string zone_abbrev(bool as_offset=false) const
+    std::string zone_abbrev(bool /*as_offset*/=false) const
     {
       return time_system::zone_name(time_);
     }
     //! An empty string is returned for classes that do not use a time_zone
     std::string zone_as_posix_string() const
     {
-      return std::string("");
+      return std::string();
     }
 
     //! check to see if date is not a value

data/ext/boost/date_time/time_defs.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 
- * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ * $Date: 2008-11-12 14:37:53 -0500 (Wed, 12 Nov 2008) $
  */
 
 
@@ -20,7 +20,17 @@ namespace boost {
 namespace date_time {
 
   //!Defines some nice types for handling time level resolutions
-  enum time_resolutions {sec, tenth, hundreth, milli, ten_thousandth, micro, nano, NumResolutions };
+  enum time_resolutions {
+    sec,
+    tenth,
+    hundreth, // deprecated misspelled version of hundredth
+    hundredth = hundreth,
+    milli,
+    ten_thousandth,
+    micro,
+    nano,
+    NumResolutions
+  };
 
   //! Flags for daylight savings or summer time
   enum dst_flags {not_dst, is_dst, calculate};

data/ext/boost/date_time/time_duration.hpp

@@ -6,18 +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: 2009-06-04 04:24:49 -0400 (Thu, 04 Jun 2009) $
  */
 
-#include "boost/operators.hpp"
-#include "boost/date_time/time_defs.hpp"
-#include "boost/date_time/special_defs.hpp"
-#include "boost/date_time/compiler_config.hpp"
+#include <boost/cstdint.hpp>
+#include <boost/operators.hpp>
+#include <boost/date_time/time_defs.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/compiler_config.hpp>
 
 namespace boost {
 namespace date_time {
 
-  
+
   //! Represents some amount of elapsed time measure to a given resolution
   /*! This class represents a standard set of capabilities for all
       counted time durations.  Time duration implementations should derive
@@ -30,13 +31,13 @@ namespace date_time {
   */
   template<class T, typename rep_type>
   class time_duration : private
-      boost::less_than_comparable<T 
+      boost::less_than_comparable<T
     , boost::equality_comparable<T
     > >
   /* dividable, addable, and subtractable operator templates
-   * won't work with this class (MSVC++ 6.0). return type 
-   * from '+=' is different than expected return type 
-   * from '+'. multipliable probably wont work 
+   * won't work with this class (MSVC++ 6.0). return type
+   * from '+=' is different than expected return type
+   * from '+'. multipliable probably wont work
    * either (haven't tried) */
   {
   public:
@@ -50,12 +51,12 @@ namespace date_time {
     typedef typename rep_type::tick_type tick_type;
     typedef typename rep_type::impl_type impl_type;
 
-    time_duration() : ticks_(0) {} 
-    time_duration(hour_type hours_in, 
-                  min_type minutes_in, 
+    time_duration() : ticks_(0) {}
+    time_duration(hour_type hours_in,
+                  min_type minutes_in,
                   sec_type seconds_in=0,
                   fractional_seconds_type frac_sec_in = 0) :
-      ticks_(rep_type::to_tick_count(hours_in,minutes_in,seconds_in,frac_sec_in)) 
+      ticks_(rep_type::to_tick_count(hours_in,minutes_in,seconds_in,frac_sec_in))
     {}
     // copy constructor required for dividable<>
     //! Construct from another time_duration (Copy constructor)
@@ -136,17 +137,17 @@ namespace date_time {
     }
     duration_type invert_sign() const
     {
-      return duration_type(ticks_ * (-1)); 
-    }    
+      return duration_type(ticks_ * (-1));
+    }
     bool is_negative() const
     {
       return ticks_ < 0;
-    }    
-    bool operator<(const time_duration& rhs)  const 
+    }
+    bool operator<(const time_duration& rhs)  const
     {
       return ticks_ <  rhs.ticks_;
     }
-    bool operator==(const time_duration& rhs)  const 
+    bool operator==(const time_duration& rhs)  const
     {
       return ticks_ ==  rhs.ticks_;
     }
@@ -188,13 +189,13 @@ namespace date_time {
     {
       return duration_type(ticks_ * rhs);
     }
-    duration_type operator*=(int divisor) 
+    duration_type operator*=(int divisor)
     {
       ticks_ = ticks_ * divisor;
       return duration_type(ticks_);
     }
-    tick_type ticks() const 
-    { 
+    tick_type ticks() const
+    {
       return traits_type::as_number(ticks_);
     }
 
@@ -258,9 +259,9 @@ namespace date_time {
 
   //! Template for instantiating derived adjusting durations
   /* These templates are designed to work with multiples of
-   * 10 for frac_of_second and resoultion adjustment 
+   * 10 for frac_of_second and resoultion adjustment
    */
-   template<class base_duration, boost::int64_t frac_of_second>
+  template<class base_duration, boost::int64_t frac_of_second>
   class subsecond_duration : public base_duration
   {
   public:
@@ -270,8 +271,8 @@ namespace date_time {
     {}
   };
 
-  
-  
+
+
 } } //namespace date_time
 
 

data/ext/boost/date_time/time_facet.hpp

@@ -3,19 +3,31 @@
 #define _DATE_TIME_FACET__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:  Martin Andrian, Jeff Garland, Bart Garst
- * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ * $Date: 2010-01-10 14:17:23 -0500 (Sun, 10 Jan 2010) $
  */
 
-#include "boost/date_time/date_facet.hpp"
-#include "boost/date_time/string_convert.hpp"
-#include "boost/algorithm/string/erase.hpp"
+#include <cctype>
+#include <locale>
+#include <limits>
+#include <string>
 #include <sstream>
 #include <iomanip>
+#include <iterator> // i/ostreambuf_iterator
 #include <exception>
+#include <boost/assert.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/algorithm/string/erase.hpp>
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/date_facet.hpp>
+#include <boost/date_time/string_convert.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/time_resolution_traits.hpp> // absolute_value
 
 namespace boost {
 namespace date_time {
@@ -28,6 +40,8 @@ namespace date_time {
       static const char_type fractional_seconds_or_none_format[3];       // F
       static const char_type seconds_with_fractional_seconds_format[3];  // s
       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 standard_format[9];                         // x X
       static const char_type zone_abbrev_format[3];                      // z
       static const char_type zone_name_format[3];                        // Z
@@ -42,121 +56,129 @@ namespace date_time {
       static const char_type iso_time_format_specifier[18];
       static const char_type iso_time_format_extended_specifier[22];
       //default ptime format is YYYY-Mon-DD HH:MM:SS[.fff...][ zzz]
-      static const char_type default_time_format[23]; 
+      static const char_type default_time_format[23];
       // default_time_input_format uses a posix_time_zone_string instead of a time zone abbrev
-      static const char_type default_time_input_format[24]; 
+      static const char_type default_time_input_format[24];
       //default time_duration format is HH:MM:SS[.fff...]
       static const char_type default_time_duration_format[11];
   };
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::fractional_seconds_format[3] = {'%','f'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::fractional_seconds_or_none_format[3] = {'%','F'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
-  time_formats<CharT>::seconds_with_fractional_seconds_format[3] = 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
+  time_formats<CharT>::seconds_with_fractional_seconds_format[3] =
     {'%','s'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::seconds_format[3] =  {'%','S'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
+  time_formats<CharT>::hours_format[3] =  {'%','H'};
+
+  template <class CharT>
+  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>::standard_format[5] =  {'%','c',' ','%','z'};
   time_formats<CharT>::standard_format[9] =  {'%','x',' ','%','X',' ','%','z'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::zone_abbrev_format[3] =  {'%','z'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::zone_name_format[3] =  {'%','Z'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::zone_iso_format[3] =  {'%','q'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::zone_iso_extended_format[3] ={'%','Q'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::posix_zone_string_format[4] ={'%','Z','P'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::duration_seperator[2] =  {':'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::negative_sign[2] =  {'-'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::positive_sign[2] =  {'+'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::duration_sign_negative_only[3] ={'%','-'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
   time_formats<CharT>::duration_sign_always[3] ={'%','+'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
-  time_formats<CharT>::iso_time_format_specifier[18] =  
-    {'%', 'Y', '%', 'm', '%', 'd', 'T', 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
+  time_formats<CharT>::iso_time_format_specifier[18] =
+    {'%', 'Y', '%', 'm', '%', 'd', 'T',
      '%', 'H', '%', 'M', '%', 'S', '%', 'F', '%','q' };
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
-  time_formats<CharT>::iso_time_format_extended_specifier[22] =  
-    {'%', 'Y', '-', '%', 'm', '-', '%', 'd', ' ', 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
+  time_formats<CharT>::iso_time_format_extended_specifier[22] =
+    {'%', 'Y', '-', '%', 'm', '-', '%', 'd', ' ',
      '%', 'H', ':', '%', 'M', ':', '%', 'S', '%', 'F','%','Q'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
-  time_formats<CharT>::default_time_format[23] = 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
+  time_formats<CharT>::default_time_format[23] =
     {'%','Y','-','%','b','-','%','d',' ',
       '%','H',':','%','M',':','%','S','%','F',' ','%','z'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
-  time_formats<CharT>::default_time_input_format[24] = 
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
+  time_formats<CharT>::default_time_input_format[24] =
     {'%','Y','-','%','b','-','%','d',' ',
       '%','H',':','%','M',':','%','S','%','F',' ','%','Z','P'};
 
-  template <class CharT>  
-  const typename time_formats<CharT>::char_type 
-  time_formats<CharT>::default_time_duration_format[11] = 
-    {'%','H',':','%','M',':','%','S','%','F'};
+  template <class CharT>
+  const typename time_formats<CharT>::char_type
+  time_formats<CharT>::default_time_duration_format[11] =
+    {'%','O',':','%','M',':','%','S','%','F'};
 
 
 
-  /*! Facet used for format-based output of time types 
+  /*! Facet used for format-based output of time types
    * This class provides for the use of format strings to output times.  In addition
    * to the flags for formatting date elements, the following are the allowed format flags:
    *  - %x %X => default format - enables addition of more flags to default (ie. "%x %X %z")
    *  - %f => fractional seconds ".123456"
    *  - %F => fractional seconds or none: like frac sec but empty if frac sec == 0
-   *  - %s => seconds w/ fractional sec "02.123" (this is the same as "%S%f) 
+   *  - %s => seconds w/ fractional sec "02.123" (this is the same as "%S%f)
    *  - %S => seconds "02"
    *  - %z => abbreviated time zone "EDT"
    *  - %Z => full time zone name "Eastern Daylight Time"
    */
   template <class time_type,
-            class CharT, 
+            class CharT,
             class OutItrT = std::ostreambuf_iterator<CharT, std::char_traits<CharT> > >
-  class time_facet : 
+  class time_facet :
     public boost::date_time::date_facet<typename time_type::date_type , CharT, OutItrT> {
    public:
     typedef typename time_type::date_type date_type;
@@ -172,6 +194,8 @@ namespace date_time {
     static const char_type* fractional_seconds_or_none_format;        // %F
     static const char_type* seconds_with_fractional_seconds_format;   // %s
     static const char_type* seconds_format;                           // %S
+    static const char_type* hours_format;                             // %H
+    static const char_type* unrestricted_hours_format;                // %O
     static const char_type* standard_format;                          // %x X
     static const char_type* zone_abbrev_format;                       // %z
     static const char_type* zone_name_format;                         // %Z
@@ -187,7 +211,7 @@ namespace date_time {
     static const char_type* iso_time_format_extended_specifier;
 
     //default ptime format is YYYY-Mon-DD HH:MM:SS[.fff...][ zzz]
-    static const char_type* default_time_format; 
+    static const char_type* default_time_format;
     //default time_duration format is HH:MM:SS[.fff...]
     static const char_type* default_time_duration_format;
     static std::locale::id id;
@@ -197,28 +221,27 @@ namespace date_time {
 #endif
 
     //! sets default formats for ptime, local_date_time, and time_duration
-    explicit time_facet(::size_t /* a_ref */ = 0) 
-      //: base_type(standard_format),
-      : base_type(default_time_format), 
+    explicit time_facet(::size_t a_ref = 0)
+      : base_type(default_time_format, period_formatter_type(), special_values_formatter_type(), date_gen_formatter_type(), a_ref),
         m_time_duration_format(string_type(duration_sign_negative_only) + default_time_duration_format)
     {}
 
     //! Construct the facet with an explicitly specified format
     explicit time_facet(const char_type* a_format,
-                        period_formatter_type period_formatter = period_formatter_type(), 
-                        const special_values_formatter_type& special_value_formatter = special_values_formatter_type(), 
+                        period_formatter_type period_formatter = period_formatter_type(),
+                        const special_values_formatter_type& special_value_formatter = special_values_formatter_type(),
                         date_gen_formatter_type dg_formatter = date_gen_formatter_type(),
-                         ::size_t a_ref = 0) 
-      : base_type(a_format, 
+                         ::size_t a_ref = 0)
+      : base_type(a_format,
                   period_formatter,
-                  special_value_formatter, 
-                  dg_formatter, 
+                  special_value_formatter,
+                  dg_formatter,
                   a_ref),
         m_time_duration_format(string_type(duration_sign_negative_only) + default_time_duration_format)
     {}
 
     //! Changes format for time_duration
-    void time_duration_format(const char_type* const format) 
+    void time_duration_format(const char_type* const format)
     {
       m_time_duration_format = format;
     }
@@ -232,40 +255,39 @@ namespace date_time {
       this->m_format = iso_time_format_extended_specifier;
     }
 
-    OutItrT put(OutItrT a_next, 
-                std::ios_base& a_ios, 
-                char_type a_fill, 
-                const time_type& a_time) const 
+    OutItrT put(OutItrT a_next,
+                std::ios_base& a_ios,
+                char_type a_fill,
+                const time_type& a_time) const
     {
-      if (a_time.is_special()) { 
-        return this->do_put_special(a_next, a_ios, a_fill, 
+      if (a_time.is_special()) {
+        return this->do_put_special(a_next, a_ios, a_fill,
                               a_time.date().as_special());
       }
       string_type format(this->m_format);
+
       string_type frac_str;
       if (format.find(seconds_with_fractional_seconds_format) != string_type::npos) {
-        // replace %s with %S.nnn 
-        frac_str = 
+        // replace %s with %S.nnn
+        frac_str =
           fractional_seconds_as_string(a_time.time_of_day(), false);
         char_type sep = std::use_facet<std::numpunct<char_type> >(a_ios.getloc()).decimal_point();
-        
+
         string_type replace_string(seconds_format);
         replace_string += sep;
         replace_string += frac_str;
-        boost::algorithm::replace_all(format, 
-                                      seconds_with_fractional_seconds_format, 
+        boost::algorithm::replace_all(format,
+                                      seconds_with_fractional_seconds_format,
                                       replace_string);
       }
       /* NOTE: replacing posix_zone_string_format must be done BEFORE
-       * zone_name_format: "%ZP" & "%Z", if Z is checked first it will 
+       * zone_name_format: "%ZP" & "%Z", if Z is checked first it will
        * incorrectly replace a zone_name where a posix_string should go */
       if (format.find(posix_zone_string_format) != string_type::npos) {
         if(a_time.zone_abbrev().empty()) {
           // if zone_abbrev() returns an empty string, we want to
           // erase posix_zone_string_format from format
-          boost::algorithm::replace_all(format,
-                                        posix_zone_string_format,
-                                        "");
+          boost::algorithm::erase_all(format, posix_zone_string_format);
         }
         else{
           boost::algorithm::replace_all(format,
@@ -275,17 +297,15 @@ namespace date_time {
       }
       if (format.find(zone_name_format) != string_type::npos) {
         if(a_time.zone_name().empty()) {
-          /* TODO: this'll probably create problems if a user places 
-           * the zone_*_format flag in the format with a ptime. This 
+          /* TODO: this'll probably create problems if a user places
+           * the zone_*_format flag in the format with a ptime. This
            * code removes the flag from the default formats */
 
           // if zone_name() returns an empty string, we want to
           // erase zone_name_format & one preceeding space
           std::basic_ostringstream<char_type> ss;
           ss << ' ' << zone_name_format;
-          boost::algorithm::replace_all(format,
-                                        ss.str(),
-                                        "");
+          boost::algorithm::erase_all(format, ss.str());
         }
         else{
           boost::algorithm::replace_all(format,
@@ -295,17 +315,15 @@ namespace date_time {
       }
       if (format.find(zone_abbrev_format) != string_type::npos) {
         if(a_time.zone_abbrev(false).empty()) {
-          /* TODO: this'll probably create problems if a user places 
-           * the zone_*_format flag in the format with a ptime. This 
+          /* TODO: this'll probably create problems if a user places
+           * the zone_*_format flag in the format with a ptime. This
            * code removes the flag from the default formats */
 
           // if zone_abbrev() returns an empty string, we want to
           // erase zone_abbrev_format & one preceeding space
           std::basic_ostringstream<char_type> ss;
           ss << ' ' << zone_abbrev_format;
-          boost::algorithm::replace_all(format,
-                                        ss.str(),
-                                        "");
+          boost::algorithm::erase_all(format, ss.str());
         }
         else{
           boost::algorithm::replace_all(format,
@@ -315,15 +333,13 @@ namespace date_time {
       }
       if (format.find(zone_iso_extended_format) != string_type::npos) {
         if(a_time.zone_name(true).empty()) {
-          /* TODO: this'll probably create problems if a user places 
-           * the zone_*_format flag in the format with a ptime. This 
+          /* TODO: this'll probably create problems if a user places
+           * the zone_*_format flag in the format with a ptime. This
            * code removes the flag from the default formats */
 
           // if zone_name() returns an empty string, we want to
           // erase zone_iso_extended_format from format
-          boost::algorithm::replace_all(format,
-                                        zone_iso_extended_format,
-                                        "");
+          boost::algorithm::erase_all(format, zone_iso_extended_format);
         }
         else{
           boost::algorithm::replace_all(format,
@@ -334,15 +350,13 @@ namespace date_time {
 
       if (format.find(zone_iso_format) != string_type::npos) {
         if(a_time.zone_abbrev(true).empty()) {
-          /* TODO: this'll probably create problems if a user places 
-           * the zone_*_format flag in the format with a ptime. This 
+          /* TODO: this'll probably create problems if a user places
+           * the zone_*_format flag in the format with a ptime. This
            * code removes the flag from the default formats */
 
           // if zone_abbrev() returns an empty string, we want to
           // erase zone_iso_format from format
-          boost::algorithm::replace_all(format,
-                                        zone_iso_format,
-                                        "");
+          boost::algorithm::erase_all(format, zone_iso_format);
         }
         else{
           boost::algorithm::replace_all(format,
@@ -356,13 +370,13 @@ namespace date_time {
           frac_str = fractional_seconds_as_string(a_time.time_of_day(), false);
         }
         boost::algorithm::replace_all(format,
-                                      fractional_seconds_format, 
+                                      fractional_seconds_format,
                                       frac_str);
       }
 
       if (format.find(fractional_seconds_or_none_format) != string_type::npos) {
         // replace %F with nnnnnnn or nothing if fs == 0
-        frac_str = 
+        frac_str =
           fractional_seconds_as_string(a_time.time_of_day(), true);
         if (frac_str.size()) {
           char_type sep = std::use_facet<std::numpunct<char_type> >(a_ios.getloc()).decimal_point();
@@ -370,7 +384,7 @@ namespace date_time {
           replace_string += sep;
           replace_string += frac_str;
           boost::algorithm::replace_all(format,
-                                        fractional_seconds_or_none_format, 
+                                        fractional_seconds_or_none_format,
                                         replace_string);
         }
         else {
@@ -379,55 +393,76 @@ namespace date_time {
         }
       }
 
-      return this->do_put_tm(a_next, a_ios, a_fill, 
+      return this->do_put_tm(a_next, a_ios, a_fill,
                        to_tm(a_time), format);
     }
 
     //! put function for time_duration
-    OutItrT put(OutItrT a_next, 
-                std::ios_base& a_ios, 
-                char_type a_fill, 
-                const time_duration_type& a_time_dur) const 
+    OutItrT put(OutItrT a_next,
+                std::ios_base& a_ios,
+                char_type a_fill,
+                const time_duration_type& a_time_dur) const
     {
-      if (a_time_dur.is_special()) { 
-        return this->do_put_special(a_next, a_ios, a_fill, 
+      if (a_time_dur.is_special()) {
+        return this->do_put_special(a_next, a_ios, a_fill,
                               a_time_dur.get_rep().as_special());
       }
 
       string_type format(m_time_duration_format);
       if (a_time_dur.is_negative()) {
-          // replace %- with minus sign.  Should we use the numpunct facet?
-          boost::algorithm::replace_all(format, 
-                                        duration_sign_negative_only, 
-                                        negative_sign);
+        // replace %- with minus sign.  Should we use the numpunct facet?
+        boost::algorithm::replace_all(format,
+                                      duration_sign_negative_only,
+                                      negative_sign);
           // remove all the %+ in the string with '-'
-          boost::algorithm::replace_all(format, 
-                                        duration_sign_always, 
-                                        negative_sign);
+        boost::algorithm::replace_all(format,
+                                      duration_sign_always,
+                                      negative_sign);
       }
       else { //duration is positive
-          // remove all the %- combos from the string
-          boost::algorithm::replace_all(format, 
-                                        duration_sign_negative_only, 
-                                        "");
-          // remove all the %+ in the string with '+'
-          boost::algorithm::replace_all(format, 
-                                        duration_sign_always, 
-                                        positive_sign);
+        // remove all the %- combos from the string
+        boost::algorithm::erase_all(format, duration_sign_negative_only);
+        // remove all the %+ in the string with '+'
+        boost::algorithm::replace_all(format,
+                                      duration_sign_always,
+                                      positive_sign);
+      }
+
+      /*
+       * 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
+       * (See ISO 14882-2003 22.2.5.3.1 par. 1) and strftime's behavior is
+       * unspecified for the case when tm_hour field is outside 0-23 range
+       * (See ISO 9899-1999 7.23.3.5 par. 3). So we must output %H and %O
+       * here ourself.
+       */
+      string_type hours_str;
+      if (format.find(unrestricted_hours_format) != string_type::npos) {
+        hours_str = hours_as_string(a_time_dur);
+        boost::algorithm::replace_all(format, unrestricted_hours_format, hours_str);
+      }
+      // We still have to process restricted hours format specifier. In order to
+      // support parseability of durations in ISO format (%H%M%S), we'll have to
+      // restrict the stringified hours length to 2 characters.
+      if (format.find(hours_format) != string_type::npos) {
+        if (hours_str.empty())
+          hours_str = hours_as_string(a_time_dur);
+        BOOST_ASSERT(hours_str.length() <= 2);
+        boost::algorithm::replace_all(format, hours_format, hours_str);
       }
 
       string_type frac_str;
       if (format.find(seconds_with_fractional_seconds_format) != string_type::npos) {
-        // replace %s with %S.nnn 
-        frac_str = 
+        // replace %s with %S.nnn
+        frac_str =
           fractional_seconds_as_string(a_time_dur, false);
         char_type sep = std::use_facet<std::numpunct<char_type> >(a_ios.getloc()).decimal_point();
-        
+
         string_type replace_string(seconds_format);
         replace_string += sep;
         replace_string += frac_str;
-        boost::algorithm::replace_all(format, 
-                                      seconds_with_fractional_seconds_format, 
+        boost::algorithm::replace_all(format,
+                                      seconds_with_fractional_seconds_format,
                                       replace_string);
       }
       if (format.find(fractional_seconds_format) != string_type::npos) {
@@ -436,13 +471,13 @@ namespace date_time {
           frac_str = fractional_seconds_as_string(a_time_dur, false);
         }
         boost::algorithm::replace_all(format,
-                                      fractional_seconds_format, 
+                                      fractional_seconds_format,
                                       frac_str);
       }
 
       if (format.find(fractional_seconds_or_none_format) != string_type::npos) {
         // replace %F with nnnnnnn or nothing if fs == 0
-        frac_str = 
+        frac_str =
           fractional_seconds_as_string(a_time_dur, true);
         if (frac_str.size()) {
           char_type sep = std::use_facet<std::numpunct<char_type> >(a_ios.getloc()).decimal_point();
@@ -450,7 +485,7 @@ namespace date_time {
           replace_string += sep;
           replace_string += frac_str;
           boost::algorithm::replace_all(format,
-                                        fractional_seconds_or_none_format, 
+                                        fractional_seconds_or_none_format,
                                         replace_string);
         }
         else {
@@ -459,12 +494,12 @@ namespace date_time {
         }
       }
 
-      return this->do_put_tm(a_next, a_ios, a_fill, 
+      return this->do_put_tm(a_next, a_ios, a_fill,
                        to_tm(a_time_dur), format);
     }
-    
-    OutItrT put(OutItrT next, std::ios_base& a_ios, 
-                char_type fill, const period_type& p) const 
+
+    OutItrT put(OutItrT next, std::ios_base& a_ios,
+                char_type fill, const period_type& p) const
     {
       return this->m_period_formatter.put_period(next, a_ios, fill,p,*this);
     }
@@ -472,12 +507,12 @@ namespace date_time {
 
   protected:
 
-    static 
-    string_type 
+    static
+    string_type
     fractional_seconds_as_string(const time_duration_type& a_time,
-                                 bool null_when_zero) 
+                                 bool null_when_zero)
     {
-      typename time_duration_type::fractional_seconds_type frac_sec = 
+      typename time_duration_type::fractional_seconds_type frac_sec =
         a_time.fractional_seconds();
 
       if (null_when_zero && (frac_sec == 0)) {
@@ -485,17 +520,33 @@ namespace date_time {
       }
 
       //make sure there is no sign
-      frac_sec = date_time::absolute_value(frac_sec);
+      return integral_as_string(
+        date_time::absolute_value(frac_sec),
+        time_duration_type::num_fractional_digits());
+    }
+
+    static
+    string_type
+    hours_as_string(const time_duration_type& a_time, int width = 2)
+    {
+      return integral_as_string(date_time::absolute_value(a_time.hours()), width);
+    }
+
+    template< typename IntT >
+    static
+    string_type
+    integral_as_string(IntT val, int width = 2)
+    {
       std::basic_ostringstream<char_type> ss;
       ss.imbue(std::locale::classic()); // don't want any formatting
-      ss << std::setw(time_duration_type::num_fractional_digits())
-         << std::setfill(static_cast<char_type>('0'));
+      ss << std::setw(width)
+        << std::setfill(static_cast<char_type>('0'));
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
       // JDG [7/6/02 VC++ compatibility]
       char_type buff[34];
-      ss << _i64toa(static_cast<boost::int64_t>(frac_sec), buff, 10);
+      ss << _i64toa(static_cast<boost::int64_t>(val), buff, 10);
 #else
-      ss << frac_sec;
+      ss << val;
 #endif
       return ss.str();
     }
@@ -504,98 +555,106 @@ namespace date_time {
     string_type m_time_duration_format;
 
   };
-  
-  template <class time_type, class CharT, class OutItrT>  
+
+  template <class time_type, class CharT, class OutItrT>
   std::locale::id time_facet<time_type, CharT, OutItrT>::id;
 
-  template <class time_type, class CharT, class OutItrT>  
-  const typename time_facet<time_type, CharT, OutItrT>::char_type* 
+  template <class time_type, class CharT, class OutItrT>
+  const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::fractional_seconds_format = time_formats<CharT>::fractional_seconds_format;
 
-  template <class time_type, class CharT, class OutItrT>  
-  const typename time_facet<time_type, CharT, OutItrT>::char_type* 
+  template <class time_type, class CharT, class OutItrT>
+  const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::fractional_seconds_or_none_format = time_formats<CharT>::fractional_seconds_or_none_format;
 
-  template <class time_type, class CharT, class OutItrT>  
-  const typename time_facet<time_type, CharT, OutItrT>::char_type* 
-  time_facet<time_type, CharT, OutItrT>::seconds_with_fractional_seconds_format = 
+  template <class time_type, class CharT, class OutItrT>
+  const typename time_facet<time_type, CharT, OutItrT>::char_type*
+  time_facet<time_type, CharT, OutItrT>::seconds_with_fractional_seconds_format =
     time_formats<CharT>::seconds_with_fractional_seconds_format;
 
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::zone_name_format =  time_formats<CharT>::zone_name_format;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::zone_abbrev_format =  time_formats<CharT>::zone_abbrev_format;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::zone_iso_extended_format =time_formats<CharT>::zone_iso_extended_format;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::posix_zone_string_format =time_formats<CharT>::posix_zone_string_format;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::zone_iso_format =  time_formats<CharT>::zone_iso_format;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::seconds_format =  time_formats<CharT>::seconds_format;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
+  const typename time_facet<time_type, CharT, OutItrT>::char_type*
+  time_facet<time_type, CharT, OutItrT>::hours_format =  time_formats<CharT>::hours_format;
+
+  template <class time_type, class CharT, class OutItrT>
+  const typename time_facet<time_type, CharT, OutItrT>::char_type*
+  time_facet<time_type, CharT, OutItrT>::unrestricted_hours_format =  time_formats<CharT>::unrestricted_hours_format;
+
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::standard_format =  time_formats<CharT>::standard_format;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::duration_seperator =  time_formats<CharT>::duration_seperator;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::negative_sign =  time_formats<CharT>::negative_sign;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::positive_sign =  time_formats<CharT>::positive_sign;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::duration_sign_negative_only =  time_formats<CharT>::duration_sign_negative_only;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::duration_sign_always =  time_formats<CharT>::duration_sign_always;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type,CharT, OutItrT>::char_type*
   time_facet<time_type,CharT, OutItrT>::iso_time_format_specifier = time_formats<CharT>::iso_time_format_specifier;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
   time_facet<time_type, CharT, OutItrT>::iso_time_format_extended_specifier = time_formats<CharT>::iso_time_format_extended_specifier;
 
-  template <class time_type, class CharT, class OutItrT>  
+  template <class time_type, class CharT, class OutItrT>
   const typename time_facet<time_type, CharT, OutItrT>::char_type*
-  time_facet<time_type, CharT, OutItrT>::default_time_format = 
+  time_facet<time_type, CharT, OutItrT>::default_time_format =
     time_formats<CharT>::default_time_format;
 
-  template <class time_type, class CharT, class OutItrT>  
-  const typename time_facet<time_type, CharT, OutItrT>::char_type* 
-  time_facet<time_type, CharT, OutItrT>::default_time_duration_format = 
+  template <class time_type, class CharT, class OutItrT>
+  const typename time_facet<time_type, CharT, OutItrT>::char_type*
+  time_facet<time_type, CharT, OutItrT>::default_time_duration_format =
     time_formats<CharT>::default_time_duration_format;
 
 
-  //! Facet for format-based input.  
+  //! Facet for format-based input.
   /*!
    */
   template <class time_type,
-            class CharT, 
+            class CharT,
             class InItrT = std::istreambuf_iterator<CharT, std::char_traits<CharT> > >
-  class time_input_facet : 
+  class time_input_facet :
     public boost::date_time::date_input_facet<typename time_type::date_type , CharT, InItrT> {
     public:
       typedef typename time_type::date_type date_type;
@@ -628,13 +687,13 @@ namespace date_time {
       static const char_type* duration_seperator;
       static const char_type* iso_time_format_specifier;
       static const char_type* iso_time_format_extended_specifier;
-      static const char_type* default_time_input_format; 
+      static const char_type* default_time_input_format;
       static const char_type* default_time_duration_format;
       static std::locale::id id;
 
       //! Constructor that takes a format string for a ptime
-      explicit time_input_facet(const string_type& format, ::size_t a_ref = 0) 
-        : base_type(format, a_ref), 
+      explicit time_input_facet(const string_type& format, ::size_t a_ref = 0)
+        : base_type(format, a_ref),
           m_time_duration_format(default_time_duration_format)
       { }
 
@@ -649,16 +708,16 @@ namespace date_time {
                     sv_parser,
                     per_parser,
                     date_gen_parser,
-                    a_ref), 
+                    a_ref),
           m_time_duration_format(default_time_duration_format)
       {}
 
       //! sets default formats for ptime, local_date_time, and time_duration
-      explicit time_input_facet(::size_t a_ref = 0) 
-        : base_type(default_time_input_format, a_ref), 
+      explicit time_input_facet(::size_t a_ref = 0)
+        : base_type(default_time_input_format, a_ref),
           m_time_duration_format(default_time_duration_format)
       { }
-      
+
       //! Set the format for time_duration
       void time_duration_format(const char_type* const format) {
         m_time_duration_format = format;
@@ -671,94 +730,102 @@ namespace date_time {
       {
         this->m_format = iso_time_format_extended_specifier;
       }
-      
+
       InItrT get(InItrT& sitr,
                  InItrT& stream_end,
                  std::ios_base& a_ios,
                  period_type& p) const
       {
-        p = this->m_period_parser.get_period(sitr, 
-                                             stream_end, 
-                                             a_ios, 
-                                             p, 
-                                             time_duration_type::unit(), 
+        p = this->m_period_parser.get_period(sitr,
+                                             stream_end,
+                                             a_ios,
+                                             p,
+                                             time_duration_type::unit(),
                                              *this);
         return sitr;
       }
-      
+
       //default ptime format is YYYY-Mon-DD HH:MM:SS[.fff...][ zzz]
       //default time_duration format is %H:%M:%S%F HH:MM:SS[.fff...]
 
-      InItrT get(InItrT& sitr, 
-                 InItrT& stream_end, 
-                 std::ios_base& a_ios, 
+      InItrT get(InItrT& sitr,
+                 InItrT& stream_end,
+                 std::ios_base& a_ios,
                  time_duration_type& td) const
       {
         // skip leading whitespace
         while((sitr != stream_end) && std::isspace(*sitr)) { ++sitr; }
-        
+
         bool use_current_char = false;
-        
+
         // num_get will consume the +/-, we may need a copy if special_value
         char_type c = '\0';
         if((sitr != stream_end) && (*sitr == '-' || *sitr == '+')) {
           c = *sitr;
         }
-        
-        long hour = 0; 
-        long min = 0; 
-        long sec = 0; 
+
+        typedef typename time_duration_type::hour_type hour_type;
+        typedef typename time_duration_type::min_type min_type;
+        typedef typename time_duration_type::sec_type sec_type;
+
+        hour_type hour = 0;
+        min_type min = 0;
+        sec_type sec = 0;
         typename time_duration_type::fractional_seconds_type frac(0);
-        
+
         typedef std::num_get<CharT, InItrT> num_get;
         if(!std::has_facet<num_get>(a_ios.getloc())) {
           num_get* ng = new num_get();
           std::locale loc = std::locale(a_ios.getloc(), ng);
           a_ios.imbue(loc);
         }
-       
+
         const_itr itr(m_time_duration_format.begin());
         while (itr != m_time_duration_format.end() && (sitr != stream_end)) {
           if (*itr == '%') {
-            itr++;
+            ++itr;
             if (*itr != '%') {
               switch(*itr) {
-              case 'H': 
+              case 'O':
                 {
-                  match_results mr;
-                  hour = fixed_string_to_int<short, CharT>(sitr, stream_end, mr, 2);
+                  // A period may span more than 24 hours. In that case the format
+                  // string should be composed with the unrestricted hours specifier.
+                  hour = var_string_to_int<hour_type, CharT>(sitr, stream_end,
+                                      std::numeric_limits<hour_type>::digits10 + 1);
                   if(hour == -1){
                      return check_special_value(sitr, stream_end, td, c);
                   }
                   break;
                 }
-              case 'M': 
+              case 'H':
                 {
                   match_results mr;
-                  min = fixed_string_to_int<short, CharT>(sitr, stream_end, mr, 2);
-                  if(min == -1){
+                  hour = fixed_string_to_int<hour_type, CharT>(sitr, stream_end, mr, 2);
+                  if(hour == -1){
                      return check_special_value(sitr, stream_end, td, c);
                   }
                   break;
                 }
-              case 'S': 
+              case 'M':
                 {
                   match_results mr;
-                  sec = fixed_string_to_int<short, CharT>(sitr, stream_end, mr, 2);
-                  if(sec == -1){
+                  min = fixed_string_to_int<min_type, CharT>(sitr, stream_end, mr, 2);
+                  if(min == -1){
                      return check_special_value(sitr, stream_end, td, c);
                   }
                   break;
                 }
               case 's':
+              case 'S':
                 {
                   match_results mr;
-                  sec = fixed_string_to_int<short, CharT>(sitr, stream_end, mr, 2);
+                  sec = fixed_string_to_int<sec_type, CharT>(sitr, stream_end, mr, 2);
                   if(sec == -1){
                      return check_special_value(sitr, stream_end, td, c);
                   }
+                  if (*itr == 'S')
+                    break;
                   // %s is the same as %S%f so we drop through into %f
-                  //break;
                 }
               case 'f':
                 {
@@ -766,7 +833,7 @@ namespace date_time {
                   if(*sitr == '.') {
                     ++sitr;
                     parse_frac_type(sitr, stream_end, frac);
-                    // sitr will point to next expected char after this parsing 
+                    // sitr will point to next expected char after this parsing
                     // is complete so no need to advance it
                     use_current_char = true;
                   }
@@ -775,13 +842,13 @@ namespace date_time {
                   }
                   break;
                 }
-              case 'F': 
+              case 'F':
                 {
                   // check for decimal, skip if missing
                   if(*sitr == '.') {
                     ++sitr;
                     parse_frac_type(sitr, stream_end, frac);
-                    // sitr will point to next expected char after this parsing 
+                    // sitr will point to next expected char after this parsing
                     // is complete so no need to advance it
                     use_current_char = true;
                   }
@@ -796,20 +863,20 @@ namespace date_time {
               }// switch
             }
             else { // itr == '%', second consecutive
-              sitr++;
+              ++sitr;
             }
-        
-            itr++; //advance past format specifier
+
+            ++itr; //advance past format specifier
           }
           else {  //skip past chars in format and in buffer
-            itr++;
-            // set use_current_char when sitr is already 
+            ++itr;
+            // set use_current_char when sitr is already
             // pointing at the next character to process
             if (use_current_char) {
               use_current_char = false;
             }
             else {
-              sitr++;
+              ++sitr;
             }
           }
         }
@@ -817,21 +884,21 @@ namespace date_time {
         td = time_duration_type(hour, min, sec, frac);
         return sitr;
       }
-    
+
 
       //! Parses a time object from the input stream
-      InItrT get(InItrT& sitr, 
-                 InItrT& stream_end, 
-                 std::ios_base& a_ios, 
+      InItrT get(InItrT& sitr,
+                 InItrT& stream_end,
+                 std::ios_base& a_ios,
                  time_type& t) const
       {
         string_type tz_str;
         return get(sitr, stream_end, a_ios, t, tz_str, false);
       }
       //! Expects a time_zone in the input stream
-      InItrT get_local_time(InItrT& sitr, 
-                            InItrT& stream_end, 
-                            std::ios_base& a_ios, 
+      InItrT get_local_time(InItrT& sitr,
+                            InItrT& stream_end,
+                            std::ios_base& a_ios,
                             time_type& t,
                             string_type& tz_str) const
       {
@@ -840,51 +907,55 @@ namespace date_time {
 
     protected:
 
-      InItrT get(InItrT& sitr, 
-                 InItrT& stream_end, 
-                 std::ios_base& a_ios, 
+      InItrT get(InItrT& sitr,
+                 InItrT& stream_end,
+                 std::ios_base& a_ios,
                  time_type& t,
                  string_type& tz_str,
                  bool time_is_local) const
       {
         // skip leading whitespace
         while((sitr != stream_end) && std::isspace(*sitr)) { ++sitr; }
-        
+
         bool use_current_char = false;
         bool use_current_format_char = false; // used whith two character flags
-        
+
         // num_get will consume the +/-, we may need a copy if special_value
         char_type c = '\0';
         if((sitr != stream_end) && (*sitr == '-' || *sitr == '+')) {
           c = *sitr;
         }
-       
+
+        typedef typename time_duration_type::hour_type hour_type;
+        typedef typename time_duration_type::min_type min_type;
+        typedef typename time_duration_type::sec_type sec_type;
+
         // time elements
-        long hour = 0; 
-        long min = 0; 
-        long sec = 0; 
+        hour_type hour = 0;
+        min_type min = 0;
+        sec_type sec = 0;
         typename time_duration_type::fractional_seconds_type frac(0);
         // date elements
         short day_of_year(0);
-        /* Initialized the following to their minimum values. These intermediate 
-         * objects are used so we get specific exceptions when part of the input 
-         * is unparsable. 
+        /* Initialized the following to their minimum values. These intermediate
+         * objects are used so we get specific exceptions when part of the input
+         * is unparsable.
          * Ex: "205-Jan-15" will throw a bad_year, "2005-Jsn-15"- bad_month, etc.*/
         year_type t_year(1400);
         month_type t_month(1);
         day_type t_day(1);
-        
+
         typedef std::num_get<CharT, InItrT> num_get;
         if(!std::has_facet<num_get>(a_ios.getloc())) {
           num_get* ng = new num_get();
           std::locale loc = std::locale(a_ios.getloc(), ng);
           a_ios.imbue(loc);
         }
-       
+
         const_itr itr(this->m_format.begin());
         while (itr != this->m_format.end() && (sitr != stream_end)) {
           if (*itr == '%') {
-            itr++;
+            ++itr;
             if (*itr != '%') {
               // the cases are grouped by date & time flags - not alphabetical order
               switch(*itr) {
@@ -898,7 +969,7 @@ namespace date_time {
                     try {
                       t_year = this->m_parser.parse_year(sitr, stream_end, s, mr);
                     }
-                    catch(std::out_of_range bad_year) { // base class for bad_year exception
+                    catch(std::out_of_range&) { // base class for bad_year exception
                       if(this->m_sv_parser.match(sitr, stream_end, mr)) {
                         t = time_type(static_cast<special_values>(mr.current_match));
                         return sitr;
@@ -919,13 +990,13 @@ namespace date_time {
                     try {
                       t_month = this->m_parser.parse_month(sitr, stream_end, s, mr);
                     }
-                    catch(std::out_of_range bad_month) { // base class for bad_month exception
+                    catch(std::out_of_range&) { // base class for bad_month exception
                       if(this->m_sv_parser.match(sitr, stream_end, mr)) {
                         t = time_type(static_cast<special_values>(mr.current_match));
                         return sitr;
                       }
                       else {
-                        throw; // rethrow bad_year
+                        throw; // rethrow bad_month
                       }
                     }
                     // did m_parser already advance sitr to next char?
@@ -946,7 +1017,7 @@ namespace date_time {
                     try {
                       wd = this->m_parser.parse_weekday(sitr, stream_end, s, mr);
                     }
-                    catch(std::out_of_range bad_weekday) { // base class for bad_weekday exception
+                    catch(std::out_of_range&) { // base class for bad_weekday exception
                       if(this->m_sv_parser.match(sitr, stream_end, mr)) {
                         t = time_type(static_cast<special_values>(mr.current_match));
                         return sitr;
@@ -982,55 +1053,48 @@ namespace date_time {
                     try {
                       t_day = this->m_parser.parse_day_of_month(sitr, stream_end);
                     }
-                    catch(std::out_of_range bad_day_of_month) { // base class for exception
+                    catch(std::out_of_range&) { // base class for exception bad_day_of_month
                       match_results mr;
                       if(this->m_sv_parser.match(sitr, stream_end, mr)) {
                         t = time_type(static_cast<special_values>(mr.current_match));
                         return sitr;
                       }
                       else {
-                        throw; // rethrow bad_year
+                        throw; // rethrow bad_day_of_month
                       }
                     }
                     break;
                   }
                 // time flags
-                case 'H': 
+                case 'H':
                   {
                     match_results mr;
-                    hour = fixed_string_to_int<short, CharT>(sitr, stream_end, mr, 2);
+                    hour = fixed_string_to_int<hour_type, CharT>(sitr, stream_end, mr, 2);
                     if(hour == -1){
                        return check_special_value(sitr, stream_end, t, c);
                     }
                     break;
                   }
-                case 'M': 
+                case 'M':
                   {
                     match_results mr;
-                    min = fixed_string_to_int<short, CharT>(sitr, stream_end, mr, 2);
+                    min = fixed_string_to_int<min_type, CharT>(sitr, stream_end, mr, 2);
                     if(min == -1){
                        return check_special_value(sitr, stream_end, t, c);
                     }
                     break;
                   }
-                case 'S': 
-                  {
-                    match_results mr;
-                    sec = fixed_string_to_int<short, CharT>(sitr, stream_end, mr, 2);
-                    if(sec == -1){
-                       return check_special_value(sitr, stream_end, t, c);
-                    }
-                    break;
-                  }
                 case 's':
+                case 'S':
                   {
                     match_results mr;
-                    sec = fixed_string_to_int<short, CharT>(sitr, stream_end, mr, 2);
+                    sec = fixed_string_to_int<sec_type, CharT>(sitr, stream_end, mr, 2);
                     if(sec == -1){
                        return check_special_value(sitr, stream_end, t, c);
                     }
+                    if (*itr == 'S')
+                      break;
                     // %s is the same as %S%f so we drop through into %f
-                    //break;
                   }
                 case 'f':
                   {
@@ -1038,7 +1102,7 @@ namespace date_time {
                     if(*sitr == '.') {
                       ++sitr;
                       parse_frac_type(sitr, stream_end, frac);
-                      // sitr will point to next expected char after this parsing 
+                      // sitr will point to next expected char after this parsing
                       // is complete so no need to advance it
                       use_current_char = true;
                     }
@@ -1047,13 +1111,13 @@ namespace date_time {
                     }
                     break;
                   }
-                case 'F': 
+                case 'F':
                   {
                     // check for decimal, skip if missing
                     if(*sitr == '.') {
                       ++sitr;
                       parse_frac_type(sitr, stream_end, frac);
-                      // sitr will point to next expected char after this parsing 
+                      // sitr will point to next expected char after this parsing
                       // is complete so no need to advance it
                       use_current_char = true;
                     }
@@ -1083,44 +1147,44 @@ namespace date_time {
                       else {
                         use_current_format_char = true;
                       }
-                    
+
                     }
                     else {
                       // nothing was parsed so we don't want to advance sitr
                       use_current_char = true;
                     }
-                   
+
                     break;
                   }
                 default:
                 {} // ignore what we don't understand?
               }// switch
-            } 
+            }
             else { // itr == '%', second consecutive
-              sitr++;
+              ++sitr;
             }
-       
+
             if(use_current_format_char) {
               use_current_format_char = false;
             }
             else {
-              itr++; //advance past format specifier
+              ++itr; //advance past format specifier
             }
-             
+
           }
           else {  //skip past chars in format and in buffer
-            itr++;
-            // set use_current_char when sitr is already 
+            ++itr;
+            // set use_current_char when sitr is already
             // pointing at the next character to process
             if (use_current_char) {
               use_current_char = false;
             }
             else {
-              sitr++;
+              ++sitr;
             }
           }
         }
-        
+
         date_type d(not_a_date_time);
         if (day_of_year > 0) {
           d = date_type(static_cast<unsigned short>(t_year-1),12,31) + date_duration_type(day_of_year);
@@ -1135,8 +1199,8 @@ namespace date_time {
       }
 
       //! Helper function to check for special_value
-      /*! First character may have been consumed during original parse 
-       * attempt. Parameter 'c' should be a copy of that character. 
+      /*! First character may have been consumed during original parse
+       * attempt. Parameter 'c' should be a copy of that character.
        * Throws ios_base::failure if parse fails. */
       template<class temporal_type>
       inline
@@ -1149,15 +1213,16 @@ namespace date_time {
         this->m_sv_parser.match(sitr, stream_end, mr);
         if(mr.current_match == match_results::PARSE_ERROR) {
           std::string tmp = convert_string_type<char_type, char>(mr.cache);
-          throw std::ios_base::failure("Parse failed. No match found for '" + tmp + "'");
+          boost::throw_exception(std::ios_base::failure("Parse failed. No match found for '" + tmp + "'"));
+          BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(return sitr); // should never reach
         }
-        tt = temporal_type(static_cast<special_values>(mr.current_match)); 
+        tt = temporal_type(static_cast<special_values>(mr.current_match));
         return sitr;
       }
 
       //! Helper function for parsing a fractional second type from the stream
-      void parse_frac_type(InItrT& sitr, 
-                           InItrT& stream_end, 
+      void parse_frac_type(InItrT& sitr,
+                           InItrT& stream_end,
                            fracional_seconds_type& frac) const
       {
         string_type cache;
@@ -1178,7 +1243,7 @@ namespace date_time {
           }
         }
       }
-      
+
     private:
       string_type m_time_duration_format;
 
@@ -1199,60 +1264,60 @@ namespace date_time {
 template <class time_type, class CharT, class InItrT>
   std::locale::id time_input_facet<time_type, CharT, InItrT>::id;
 
-template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::fractional_seconds_format = time_formats<CharT>::fractional_seconds_format;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::fractional_seconds_or_none_format = time_formats<CharT>::fractional_seconds_or_none_format;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::seconds_with_fractional_seconds_format = time_formats<CharT>::seconds_with_fractional_seconds_format;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::seconds_format = time_formats<CharT>::seconds_format;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::standard_format = time_formats<CharT>::standard_format;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::zone_abbrev_format = time_formats<CharT>::zone_abbrev_format;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::zone_name_format = time_formats<CharT>::zone_name_format;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::zone_iso_format = time_formats<CharT>::zone_iso_format;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::zone_iso_extended_format = time_formats<CharT>::zone_iso_extended_format;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::duration_seperator = time_formats<CharT>::duration_seperator;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::iso_time_format_specifier = time_formats<CharT>::iso_time_format_specifier;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::iso_time_format_extended_specifier = time_formats<CharT>::iso_time_format_extended_specifier;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::default_time_input_format = time_formats<CharT>::default_time_input_format;
 
-  template <class time_type, class CharT, class InItrT>  
-  const typename time_input_facet<time_type, CharT, InItrT>::char_type* 
+  template <class time_type, class CharT, class InItrT>
+  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
   time_input_facet<time_type, CharT, InItrT>::default_time_duration_format = time_formats<CharT>::default_time_duration_format;