Update timezone data file to IANA 2025b

Ingested tooling from https://github.com/fmidev/smartmet-timezones
and updated timezone data README so we have a means to regenerate
the file that is documented.

Compared to IANA 2016c, the timezone information in 2025c no longer
has a distinction between short and long names.  For example in
2016c America/Denver used MST for short, Mountain Standard Time
for long, but America/Boise used MST for both.  With 2025c they
both use MST for short and long, which also means that the built-in
"Coordinated Universal Time" long form is now displayed as "UTC"
like the short form.

While this does not fully resolve #67, it does help us maintain
the time zone data file better.

.appveyor.yml

@@ -0,0 +1,116 @@
+# Copyright 2016, 2017 Peter Dimov
+# Copyright 2017 - 2019 James E. King III
+# Copyright 2019 - 2021 Alexander Grund
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+#
+# Generic Appveyor build script for boostorg repositories
+# See: https://github.com/boostorg/boost-ci/
+#
+# Instructions for customizing this script for your library:
+#
+# 1. Customize the compilers and language levels you want.
+# 2. If you have more than include/, src/, test/, example/, examples/,
+#    benchmark/ or tools/ directories, set the environment variable DEPINST.
+#    For example if your build uses code in "bench/" and "fog/" directories:
+#      - DEPINST: --include bench --include fog
+# 3. Enable pull request builds in your boostorg/<library> account.
+#
+# That's it - the script will do everything else for you.
+#
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+    - /bugfix\/.*/
+    - /feature\/.*/
+    - /fix\/.*/
+    - /pr\/.*/
+
+matrix:
+  fast_finish: false
+  # Adding MAYFAIL to any matrix job allows it to fail but the build stays green:
+  allow_failures:
+    - MAYFAIL: true
+
+environment:
+  global:
+    B2_CI_VERSION: 1
+    GIT_FETCH_JOBS: 4
+    # see: http://www.boost.org/build/doc/html/bbv2/overview/invocation.html#bbv2.overview.invocation.properties
+    # to use the default for a given environment, comment it out; recommend you build debug and release however:
+    # on Windows it is important to exercise all the possibilities, especially shared vs static, however most
+    # libraries that care about this exercise it in their Jamfiles...
+    B2_ADDRESS_MODEL: 32,64
+    B2_LINK: shared,static
+    # B2_THREADING: threading=multi,single
+    B2_VARIANT: release
+    BOOST_DATE_TIME_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS: 1
+
+  matrix:
+    - FLAVOR: Visual Studio 2017 C++2a Strict
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      B2_CXXFLAGS: -permissive-
+      B2_CXXSTD: 2a
+      B2_TOOLSET: msvc-14.1
+
+    - FLAVOR: Visual Studio 2017 C++14/17
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      B2_CXXSTD: 14,17
+      B2_TOOLSET: msvc-14.1
+
+    - FLAVOR: clang-cl
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      B2_ADDRESS_MODEL: 64
+      B2_CXXSTD: 11,14,17
+      B2_TOOLSET: clang-win
+
+    - FLAVOR: Visual Studio 2015, 2013
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      B2_TOOLSET: msvc-12.0,msvc-14.0
+
+    - FLAVOR: Visual Studio 2008, 2010, 2012
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      B2_TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
+      B2_ADDRESS_MODEL: 32 # No 64bit support
+
+    - FLAVOR: cygwin (32-bit)
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ADDPATH: C:\cygwin\bin;
+      B2_ADDRESS_MODEL: 32
+      B2_CXXSTD: 03,11,14,1z
+      B2_THREADING: threadapi=pthread
+      B2_TOOLSET: gcc
+
+    - FLAVOR: cygwin (64-bit)
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ADDPATH: C:\cygwin64\bin;
+      B2_ADDRESS_MODEL: 64
+      B2_CXXSTD: 03,11,14,1z
+      B2_THREADING: threadapi=pthread
+      B2_TOOLSET: gcc
+
+    - FLAVOR: mingw64
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      ADDPATH: C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin;
+      B2_ADDRESS_MODEL: 64
+      B2_CXXSTD: 03,11,14,17,2a
+      B2_TOOLSET: gcc
+
+install:
+  - git clone --depth 1 https://github.com/boostorg/boost-ci.git C:\boost-ci-cloned
+  # Copy ci folder if not testing Boost.CI
+  - if NOT "%APPVEYOR_PROJECT_NAME%" == "boost-ci" xcopy /s /e /q /i /y C:\boost-ci-cloned\ci .\ci
+  - rmdir /s /q C:\boost-ci-cloned
+  - ci\appveyor\install.bat
+
+build: off
+
+test_script: ci\build.bat
+

.codecov.yml

@@ -0,0 +1,23 @@
+# Copyright 2019 - 2021 Alexander Grund
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+#
+# Sample codecov configuration file. Edit as required
+
+codecov:
+  max_report_age: off
+  require_ci_to_pass: yes
+  notify:
+    # Increase this if you have multiple coverage collection jobs
+    after_n_builds: 2
+    wait_for_ci: yes
+
+# Change how pull request comments look
+comment:
+  layout: "reach,diff,flags,files,footer"
+
+# Ignore specific files or folders. Glob patterns are supported.
+# See https://docs.codecov.com/docs/ignoring-paths
+ignore:
+  - libs/date_time/test/
+  - test

.github/workflows/ci.yml

@@ -0,0 +1,50 @@
+#
+# Copyright 2020-2021 Peter Dimov
+# Copyright 2021 Andrey Semashev
+# Copyright 2021-2024 Alexander Grund
+# Copyright 2022-2025 James E. King III
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+#
+# This workflow uses the Boost.CI reusable workflow which builds a variety of
+# configurations of your project, runs tests, and generates code coverage reports.
+#
+# To use it, copy this file into your repository as `.github/workflows/ci.yml` and
+# customize it appropriately.
+# 
+---
+name: Boost.CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - bugfix/**
+      - feature/**
+      - fix/**
+      - pr/**
+    paths-ignore:
+      - LICENSE
+      - meta/**
+      - README.md
+
+jobs:
+  call-boost-ci:
+    name: Run Boost.CI
+    uses: boostorg/boost-ci/.github/workflows/reusable.yml@master
+    with:
+      # no endian branches
+      enable_multiarch: false
+      # serialization has issues, not enough time to add suppressions
+      enable_sanitizers: false
+      # these compilers fail
+      exclude_compiler: 'gcc-4.7,gcc-4.8,gcc-4.9,gcc-5,clang-3.5,clang-3.6,clang-3.7,clang-3.8'
+      # the tests take a while; this reduces the load a bit and there isn't any C++20 specific code
+      exclude_cxxstd: '98,03,0x,2a,20'
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      COVERITY_SCAN_NOTIFICATION_EMAIL: ${{ secrets.COVERITY_SCAN_NOTIFICATION_EMAIL }}
+      COVERITY_SCAN_TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}

.gitignore

@@ -0,0 +1,2 @@
+**/test_facet_file.out
+**/time_duration_serialization.*

.ubsan-ignorelist

@@ -0,0 +1,4 @@
+# https://github.com/boostorg/serialization/issues/122
+vptr:/usr/include/c++/*/bits/ios_base.h
+# https://github.com/boostorg/serialization/issues/193
+# could not figure out how to suppress it

CMakeLists.txt

@@ -0,0 +1,53 @@
+# Generated by `boostdep --cmake date_time`
+# Copyright 2020 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(boost_date_time VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_date_time
+  src/gregorian/greg_month.cpp
+)
+
+add_library(Boost::date_time ALIAS boost_date_time)
+
+target_include_directories(boost_date_time PUBLIC include)
+
+target_link_libraries(boost_date_time
+  PUBLIC
+    Boost::algorithm
+    Boost::assert
+    Boost::config
+    Boost::core
+    Boost::io
+    Boost::lexical_cast
+    Boost::numeric_conversion
+    Boost::range
+    Boost::smart_ptr
+    Boost::static_assert
+    Boost::throw_exception
+    Boost::tokenizer
+    Boost::type_traits
+    Boost::utility
+    Boost::winapi
+)
+
+target_compile_definitions(boost_date_time
+  PUBLIC BOOST_DATE_TIME_NO_LIB
+  PRIVATE BOOST_DATE_TIME_SOURCE
+)
+
+if(BUILD_SHARED_LIBS)
+  target_compile_definitions(boost_date_time PUBLIC BOOST_DATE_TIME_DYN_LINK)
+else()
+  target_compile_definitions(boost_date_time PUBLIC BOOST_DATE_TIME_STATIC_LINK)
+endif()
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()
+

LICENSE

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,40 @@
+DateTime, part of the collection of [Boost C++ Libraries](http://github.com/boostorg), makes programming with dates and times as simple and natural as programming with strings and integers. 
+
+### License
+
+Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
+
+### Properties
+
+* C++11
+* Header only
+
+### Build Status
+
+<!-- boost-ci/tools/makebadges.sh --repo date_time --appveyorbadge upf5c528fy09fudk --codecovbadge nDoh7t8f6g --coverity 14908 -->
+| Branch          | GHA CI | Appveyor | Coverity Scan | codecov.io | Deps | Docs | Tests |
+| :-------------: | ------ | -------- | ------------- | ---------- | ---- | ---- | ----- |
+| [`master`](https://github.com/boostorg/date_time/tree/master) | [![Build Status](https://github.com/boostorg/date_time/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/date_time/actions?query=branch:master) | [![Build status](https://ci.appveyor.com/api/projects/status/upf5c528fy09fudk/branch/master?svg=true)](https://ci.appveyor.com/project/cppalliance/date-time/branch/master) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/14908/badge.svg)](https://scan.coverity.com/projects/boostorg-date_time) | [![codecov](https://codecov.io/gh/boostorg/date_time/branch/master/graph/badge.svg?token=nDoh7t8f6g)](https://codecov.io/gh/boostorg/date_time/tree/master) | [![Deps](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/date_time.html) | [![Documentation](https://img.shields.io/badge/docs-master-brightgreen.svg)](https://www.boost.org/doc/libs/master/libs/date_time) | [![Enter the Matrix](https://img.shields.io/badge/matrix-master-brightgreen.svg)](https://www.boost.org/development/tests/master/developer/date_time.html) |
+| [`develop`](https://github.com/boostorg/date_time/tree/develop) | [![Build Status](https://github.com/boostorg/date_time/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/date_time/actions?query=branch:develop) | [![Build status](https://ci.appveyor.com/api/projects/status/upf5c528fy09fudk/branch/develop?svg=true)](https://ci.appveyor.com/project/cppalliance/date-time/branch/develop) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/14908/badge.svg)](https://scan.coverity.com/projects/boostorg-date_time) | [![codecov](https://codecov.io/gh/boostorg/date_time/branch/develop/graph/badge.svg?token=nDoh7t8f6g)](https://codecov.io/gh/boostorg/date_time/tree/develop) | [![Deps](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/date_time.html) | [![Documentation](https://img.shields.io/badge/docs-develop-brightgreen.svg)](https://www.boost.org/doc/libs/develop/libs/date_time) | [![Enter the Matrix](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](https://www.boost.org/development/tests/develop/developer/date_time.html) |
+
+### Directories
+
+Note that the built library is only for build backward compatibility and contains no symbols.  date_time is now header only.
+
+| Name      | Purpose                                 |
+| --------- | --------------------------------------- |
+| `build`   | build script for optional lib build     |
+| `data`    | timezone database                       |
+| `doc`     | documentation                           |
+| `example` | use case examples                       |
+| `include` | headers                                 |
+| `src`     | source code for optional link library   |
+| `test`    | unit tests                              |
+| `xmldoc`  | documentation source                    |
+
+### More information
+
+* [Ask questions](http://stackoverflow.com/questions/ask?tags=c%2B%2B,boost,boost-date_time): Be sure to read the documentation first to see if it answers your question.
+* [Report bugs](https://github.com/boostorg/date_time/issues): Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
+* [Submit Pull Requests](https://github.com/boostorg/date_time/pulls) against the **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).  Be sure to include tests proving your changes work properly.
+* Discussions about the library are held on the [Boost developers mailing list](http://www.boost.org/community/groups.html#main). Be sure to read the [discussion policy](http://www.boost.org/community/policy.html) before posting and add the `[date_time]` tag at the beginning of the subject line.

build.jam

@@ -0,0 +1,38 @@
+# Copyright René Ferdinand Rivera Morell 2023-2024
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/algorithm//boost_algorithm
+    /boost/assert//boost_assert
+    /boost/config//boost_config
+    /boost/core//boost_core
+    /boost/io//boost_io
+    /boost/lexical_cast//boost_lexical_cast
+    /boost/numeric_conversion//boost_numeric_conversion
+    /boost/range//boost_range
+    /boost/smart_ptr//boost_smart_ptr
+    /boost/static_assert//boost_static_assert
+    /boost/throw_exception//boost_throw_exception
+    /boost/tokenizer//boost_tokenizer
+    /boost/type_traits//boost_type_traits
+    /boost/utility//boost_utility
+    /boost/winapi//boost_winapi ;
+
+project /boost/date_time
+    : common-requirements
+        <include>include
+    ;
+
+explicit
+    [ alias boost_date_time : build//boost_date_time ]
+    [ alias all : boost_date_time example test ]
+    ;
+
+call-if : boost-library date_time
+    : install boost_date_time
+    ;
+

build/Jamfile.v2

@@ -1,34 +1,24 @@
 # Copyright (c) 2002-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)
 #
-# Boost.date_time build and test Jamfile
-#
-#  Based on boost.python Jamfile
-#
-# To run all tests quietly: jam test
-#
-# Declares the following targets:
-#   1. libboost_date_time, a static link library to be linked with all
-#      Boost.date_time modules
+# date_time is now header only -- this file provides a stub for backward compatibility
 #
 
 
-project boost/date_time
+project
+    : common-requirements <library>$(boost_dependencies)
     : requirements
         <define>DATE_TIME_INLINE
-	<link>shared:<define>BOOST_ALL_DYN_LINK=1	
-	<link>static:<define>BOOST_DATE_TIME_STATIC_LINK	
-    : usage-requirements 	
+        <link>shared:<define>BOOST_ALL_DYN_LINK=1
+    : usage-requirements
         <define>DATE_TIME_INLINE
         <link>shared:<define>BOOST_DATE_TIME_DYN_LINK=1
+        <define>BOOST_DATE_TIME_NO_LINK=1
     : source-location ../src
     ;
 
-# Base names of the source files for libboost_date_time
-CPP_SOURCES = greg_month greg_weekday date_generators ;
-
-lib boost_date_time : gregorian/$(CPP_SOURCES).cpp ;
-
-boost-install boost_date_time ;
+# greg_month.cpp is now just a stub so that there is
+# still a boost_date_time library to link for backward compatibility
+lib boost_date_time : gregorian/greg_month.cpp ;

data/README.zone_spec_csv_file

@@ -1,3 +1,23 @@
+# Generating
+
+https://github.com/fmidev/smartmet-timezones/tree/master/bin provided
+a method to generate the content, which uses an unlicence, so it was
+copied into this repository for posterity and future use.
+
+    ./create_date_time_zoneinfo.sh > date_time_zonespec.csv
+
+# Compatibility
+
+The current version is IANA 2025b.
+
+Previous versions of the data file (IANA 2016c) had short and long special
+names but only for America/Chicago, America/Denver, America/Los_Angeles,
+America/New_York, America/Phoenix, but time zones like America/Detroit,
+America/Fort_Wayne, America/Indiana/Petersburg, etc... did not; when
+regenerating for IANA 2025b the short and long names became identical
+for those previously mentions time zones.
+
+# File Format
 
 The csv file containing the zone_specs used by the 
 boost::local_time::tz_database is intended to be customized by the 

data/create_date_time_zoneinfo.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+
+# Header field
+echo '"ID","STD ABBR","STD NAME","DST ABBR","DST NAME","GMT offset","DST adjustment","DST Start Date rule","Start time","DST End date rule","End time"'
+
+# We ignore POSIX and leap-second files, Boost does not use them.
+
+for tz in $(find /usr/share/zoneinfo \
+    -path /usr/share/zoneinfo/right -prune -o \
+    -path /usr/share/zoneinfo/posix -prune -o \
+    -type f \
+    | grep -v "\.tab" \
+    | grep -v posix \
+    | grep -v right \
+    | grep -v leapseconds \
+    | grep -v tzdata \
+    | sed -e 's|/usr/share/zoneinfo/||g' \
+    | sort);
+do
+    perl tzinfo.pl $tz;
+done

data/date_time_zonespec.csv

@@ -3,7 +3,7 @@
 "Africa/Accra","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Addis_Ababa","EAT","EAT","","","+03:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Algiers","CET","CET","","","+01:00:00","+00:00:00","","","","+00:00:00"
-"Africa/Asmera","EAT","EAT","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Africa/Asmara","EAT","EAT","","","+03:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Bamako","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Bangui","WAT","WAT","","","+01:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Banjul","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
@@ -11,21 +11,22 @@
 "Africa/Blantyre","CAT","CAT","","","+02:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Brazzaville","WAT","WAT","","","+01:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Bujumbura","CAT","CAT","","","+02:00:00","+00:00:00","","","","+00:00:00"
-"Africa/Cairo","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;5;4","+00:00:00","-1;5;9","+00:00:00"
-"Africa/Casablanca","WET","WET","","","+00:00:00","+00:00:00","","","","+00:00:00"
+"Africa/Cairo","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;5;4","+00:00:00","-1;4;10","+00:00:00"
+"Africa/Casablanca","+01","+01","+00","+00","+01:00:00","-01:00:00","-1;0;2","+02:00:00","1;0;4","+03:00:00"
 "Africa/Ceuta","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Africa/Conakry","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Dakar","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Dar_es_Salaam","EAT","EAT","","","+03:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Djibouti","EAT","EAT","","","+03:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Douala","WAT","WAT","","","+01:00:00","+00:00:00","","","","+00:00:00"
-"Africa/El_Aaiun","WET","WET","","","+00:00:00","+00:00:00","","","","+00:00:00"
+"Africa/El_Aaiun","+01","+01","+00","+00","+01:00:00","-01:00:00","-1;0;2","+02:00:00","1;0;4","+03:00:00"
 "Africa/Freetown","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Gaborone","CAT","CAT","","","+02:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Harare","CAT","CAT","","","+02:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Johannesburg","SAST","SAST","","","+02:00:00","+00:00:00","","","","+00:00:00"
+"Africa/Juba","CAT","CAT","","","+02:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Kampala","EAT","EAT","","","+03:00:00","+00:00:00","","","","+00:00:00"
-"Africa/Khartoum","EAT","EAT","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Africa/Khartoum","CAT","CAT","","","+02:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Kigali","CAT","CAT","","","+02:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Kinshasa","WAT","WAT","","","+01:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Lagos","WAT","WAT","","","+01:00:00","+00:00:00","","","","+00:00:00"
@@ -47,336 +48,401 @@
 "Africa/Ouagadougou","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Porto-Novo","WAT","WAT","","","+01:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Sao_Tome","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
-"Africa/Timbuktu","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Tripoli","EET","EET","","","+02:00:00","+00:00:00","","","","+00:00:00"
 "Africa/Tunis","CET","CET","","","+01:00:00","+00:00:00","","","","+00:00:00"
-"Africa/Windhoek","WAT","WAT","WAST","WAST","+01:00:00","+01:00:00","1;0;9","+02:00:00","1;0;4","+02:00:00"
-"America/Adak","HAST","HAST","HADT","HADT","-10:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"Africa/Windhoek","CAT","CAT","","","+02:00:00","+00:00:00","","","","+00:00:00"
+"America/Adak","HST","HST","HDT","HDT","-10:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Anchorage","AKST","AKST","AKDT","AKDT","-09:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Anguilla","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/Antigua","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
-"America/Araguaina","BRT","BRT","BRST","BRST","-03:00:00","+01:00:00","2;0;10","+00:00:00","3;0;2","+00:00:00"
+"America/Araguaina","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/Buenos_Aires","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/Catamarca","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/Cordoba","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/Jujuy","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/La_Rioja","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/Mendoza","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/Rio_Gallegos","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/Salta","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/San_Juan","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/San_Luis","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/Tucuman","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Argentina/Ushuaia","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
 "America/Aruba","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
-"America/Asuncion","PYT","PYT","PYST","PYST","-04:00:00","+01:00:00","1;0;10","+00:00:00","1;0;3","+00:00:00"
+"America/Asuncion","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Atikokan","EST","EST","","","-05:00:00","+00:00:00","","","","+00:00:00"
+"America/Bahia","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Bahia_Banderas","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
 "America/Barbados","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
-"America/Belem","BRT","BRT","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Belem","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
 "America/Belize","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
-"America/Boa_Vista","AMT","AMT","","","-04:00:00","+00:00:00","","","","+00:00:00"
-"America/Bogota","COT","COT","","","-05:00:00","+00:00:00","","","","+00:00:00"
+"America/Blanc-Sablon","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
+"America/Boa_Vista","-04","-04","","","-04:00:00","+00:00:00","","","","+00:00:00"
+"America/Bogota","-05","-05","","","-05:00:00","+00:00:00","","","","+00:00:00"
 "America/Boise","MST","MST","MDT","MDT","-07:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Buenos_Aires","ART","ART","","","-03:00:00","+00:00:00","","","","+00:00:00"
 "America/Cambridge_Bay","MST","MST","MDT","MDT","-07:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Cancun","CST","CST","CDT","CDT","-06:00:00","+01:00:00","1;0;4","+02:00:00","-1;0;10","+02:00:00"
-"America/Caracas","VET","VET","","","-04:00:00","+00:00:00","","","","+00:00:00"
-"America/Catamarca","ART","ART","","","-03:00:00","+00:00:00","","","","+00:00:00"
-"America/Cayenne","GFT","GFT","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Campo_Grande","-04","-04","","","-04:00:00","+00:00:00","","","","+00:00:00"
+"America/Cancun","EST","EST","","","-05:00:00","+00:00:00","","","","+00:00:00"
+"America/Caracas","-04","-04","","","-04:00:00","+00:00:00","","","","+00:00:00"
+"America/Cayenne","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
 "America/Cayman","EST","EST","","","-05:00:00","+00:00:00","","","","+00:00:00"
-"America/Chicago","CST","Central Standard Time","CDT","Central Daylight Time","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Chihuahua","MST","MST","MDT","MDT","-07:00:00","+01:00:00","1;0;4","+02:00:00","-1;0;10","+02:00:00"
-"America/Cordoba","ART","ART","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Chicago","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Chihuahua","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
+"America/Ciudad_Juarez","MST","MST","MDT","MDT","-07:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Costa_Rica","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
-"America/Cuiaba","AMT","AMT","AMST","AMST","-04:00:00","+01:00:00","2;0;10","+00:00:00","3;0;2","+00:00:00"
+"America/Coyhaique","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Creston","MST","MST","","","-07:00:00","+00:00:00","","","","+00:00:00"
+"America/Cuiaba","-04","-04","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/Curacao","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/Danmarkshavn","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
-"America/Dawson","PST","PST","PDT","PDT","-08:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Dawson","MST","MST","","","-07:00:00","+00:00:00","","","","+00:00:00"
 "America/Dawson_Creek","MST","MST","","","-07:00:00","+00:00:00","","","","+00:00:00"
-"America/Denver","MST","Mountain Standard Time","MDT","Mountain Daylight Time","-07:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Denver","MST","MST","MDT","MDT","-07:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Detroit","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Dominica","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/Edmonton","MST","MST","MDT","MDT","-07:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Eirunepe","ACT","ACT","","","-05:00:00","+00:00:00","","","","+00:00:00"
+"America/Eirunepe","-05","-05","","","-05:00:00","+00:00:00","","","","+00:00:00"
 "America/El_Salvador","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
-"America/Fortaleza","BRT","BRT","BRST","BRST","-03:00:00","+01:00:00","2;0;10","+00:00:00","3;0;2","+00:00:00"
+"America/Fortaleza","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Fort_Nelson","MST","MST","","","-07:00:00","+00:00:00","","","","+00:00:00"
 "America/Glace_Bay","AST","AST","ADT","ADT","-04:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Godthab","WGT","WGT","WGST","WGST","-03:00:00","+01:00:00","-1;6;3","+22:00:00","-1;6;10","+23:00:00"
-"America/Goose_Bay","AST","AST","ADT","ADT","-04:00:00","+01:00:00","1;0;4","+00:01:00","-1;0;10","+00:01:00"
-"America/Grand_Turk","EST","EST","EDT","EDT","-05:00:00","+01:00:00","1;0;4","+00:00:00","-1;0;10","+00:00:00"
+"America/Goose_Bay","AST","AST","ADT","ADT","-04:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Grand_Turk","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Grenada","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/Guadeloupe","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/Guatemala","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
-"America/Guayaquil","ECT","ECT","","","-05:00:00","+00:00:00","","","","+00:00:00"
-"America/Guyana","GYT","GYT","","","-04:00:00","+00:00:00","","","","+00:00:00"
+"America/Guayaquil","-05","-05","","","-05:00:00","+00:00:00","","","","+00:00:00"
+"America/Guyana","-04","-04","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/Halifax","AST","AST","ADT","ADT","-04:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Havana","CST","CST","CDT","CDT","-05:00:00","+01:00:00","1;0;4","+00:00:00","-1;0;10","+01:00:00"
+"America/Havana","CST","CST","CDT","CDT","-05:00:00","+01:00:00","2;0;3","+00:00:00","1;0;11","+01:00:00"
 "America/Hermosillo","MST","MST","","","-07:00:00","+00:00:00","","","","+00:00:00"
-"America/Indiana/Indianapolis","EST","EST","","","-05:00:00","+00:00:00","2;0;3","","1;0;11","+00:00:00"
-"America/Indiana/Knox","EST","EST","","","-05:00:00","+00:00:00","2;0;3","","1;0;11","+00:00:00"
-"America/Indiana/Marengo","EST","EST","","","-05:00:00","+00:00:00","2;0;3","","1;0;11","+00:00:00"
-"America/Indiana/Vevay","EST","EST","","","-05:00:00","+00:00:00","2;0;3","","1;0;11","+00:00:00"
-"America/Indianapolis","EST","EST","","","-05:00:00","+00:00:00","2;0;3","","1;0;11","+00:00:00"
+"America/Indiana/Indianapolis","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Indiana/Knox","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Indiana/Marengo","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Indiana/Petersburg","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Indiana/Tell_City","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Indiana/Vevay","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Indiana/Vincennes","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Indiana/Winamac","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Inuvik","MST","MST","MDT","MDT","-07:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Iqaluit","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Jamaica","EST","EST","","","-05:00:00","+00:00:00","","","","+00:00:00"
-"America/Jujuy","ART","ART","","","-03:00:00","+00:00:00","","","","+00:00:00"
 "America/Juneau","AKST","AKST","AKDT","AKDT","-09:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Kentucky/Louisville","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Kentucky/Monticello","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/La_Paz","BOT","BOT","","","-04:00:00","+00:00:00","","","","+00:00:00"
-"America/Lima","PET","PET","","","-05:00:00","+00:00:00","","","","+00:00:00"
-"America/Los_Angeles","PST","Pacific Standard Time","PDT","Pacific Daylight Time","-08:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Louisville","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Maceio","BRT","BRT","BRST","BRST","-03:00:00","+01:00:00","2;0;10","+00:00:00","3;0;2","+00:00:00"
+"America/La_Paz","-04","-04","","","-04:00:00","+00:00:00","","","","+00:00:00"
+"America/Lima","-05","-05","","","-05:00:00","+00:00:00","","","","+00:00:00"
+"America/Los_Angeles","PST","PST","PDT","PDT","-08:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Maceio","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
 "America/Managua","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
-"America/Manaus","AMT","AMT","","","-04:00:00","+00:00:00","","","","+00:00:00"
+"America/Manaus","-04","-04","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/Martinique","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
-"America/Mazatlan","MST","MST","MDT","MDT","-07:00:00","+01:00:00","1;0;4","+02:00:00","-1;0;10","+02:00:00"
-"America/Mendoza","ART","ART","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Matamoros","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Mazatlan","MST","MST","","","-07:00:00","+00:00:00","","","","+00:00:00"
 "America/Menominee","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Merida","CST","CST","CDT","CDT","-06:00:00","+01:00:00","1;0;4","+02:00:00","-1;0;10","+02:00:00"
-"America/Mexico_City","CST","CST","CDT","CDT","-06:00:00","+01:00:00","1;0;4","+02:00:00","-1;0;10","+02:00:00"
-"America/Miquelon","PMST","PMST","PMDT","PMDT","-03:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Monterrey","CST","CST","CDT","CDT","-06:00:00","+01:00:00","1;0;4","+02:00:00","-1;0;10","+02:00:00"
-"America/Montevideo","UYT","UYT","","","-03:00:00","+00:00:00","","","","+00:00:00"
-"America/Montreal","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Merida","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
+"America/Metlakatla","AKST","AKST","AKDT","AKDT","-09:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Mexico_City","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
+"America/Miquelon","-03","-03","-02","-02","-03:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Moncton","AST","AST","ADT","ADT","-04:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Monterrey","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
+"America/Montevideo","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
 "America/Montserrat","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
-"America/Nassau","EST","EST","EDT","EDT","-05:00:00","+01:00:00","1;0;4","+02:00:00","-1;0;10","+02:00:00"
-"America/New_York","EST","Eastern Standard Time","EDT","Eastern Daylight Time","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Nipigon","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Nassau","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/New_York","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Nome","AKST","AKST","AKDT","AKDT","-09:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Noronha","FNT","FNT","","","-02:00:00","+00:00:00","","","","+00:00:00"
+"America/Noronha","-02","-02","","","-02:00:00","+00:00:00","","","","+00:00:00"
+"America/North_Dakota/Beulah","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/North_Dakota/Center","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/North_Dakota/New_Salem","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Nuuk","-02","-02","-01","-01","-02:00:00","+01:00:00","-1;0;3","+23:00:00","-1;0;10","+00:00:00"
+"America/Ojinaga","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Panama","EST","EST","","","-05:00:00","+00:00:00","","","","+00:00:00"
-"America/Pangnirtung","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Paramaribo","SRT","SRT","","","-03:00:00","+00:00:00","","","","+00:00:00"
-"America/Phoenix","MST","Mountain Standard Time","","","-07:00:00","+00:00:00","","","","+00:00:00"
-"America/Port-au-Prince","EST","EST","","","-05:00:00","+00:00:00","","","","+00:00:00"
+"America/Paramaribo","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Phoenix","MST","MST","","","-07:00:00","+00:00:00","","","","+00:00:00"
+"America/Port-au-Prince","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Port_of_Spain","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
-"America/Porto_Velho","AMT","AMT","","","-04:00:00","+00:00:00","","","","+00:00:00"
+"America/Porto_Velho","-04","-04","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/Puerto_Rico","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
-"America/Rainy_River","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Punta_Arenas","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
 "America/Rankin_Inlet","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Recife","BRT","BRT","BRST","BRST","-03:00:00","+01:00:00","2;0;10","+00:00:00","3;0;2","+00:00:00"
+"America/Recife","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
 "America/Regina","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
-"America/Rio_Branco","ACT","ACT","","","-05:00:00","+00:00:00","","","","+00:00:00"
-"America/Rosario","ART","ART","","","-03:00:00","+00:00:00","","","","+00:00:00"
-"America/Santiago","CLT","CLT","CLST","CLST","-04:00:00","+01:00:00","2;0;10","+00:00:00","2;0;3","+00:00:00"
+"America/Resolute","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Rio_Branco","-05","-05","","","-05:00:00","+00:00:00","","","","+00:00:00"
+"America/Santarem","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Santiago","-04","-04","-03","-03","-04:00:00","+01:00:00","1;0;9","+23:00:00","1;0;4","+01:00:00"
 "America/Santo_Domingo","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
-"America/Sao_Paulo","BRT","BRT","BRST","BRST","-03:00:00","+01:00:00","2;0;10","+00:00:00","3;0;2","+00:00:00"
-"America/Scoresbysund","EGT","EGT","EGST","EGST","-01:00:00","+01:00:00","-1;0;3","+00:00:00","-1;0;10","+01:00:00"
-"America/Shiprock","MST","MST","MDT","MDT","-07:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/St_Johns","NST","NST","NDT","NDT","-03:30:00","+01:00:00","1;0;4","+00:01:00","-1;0;10","+00:01:00"
+"America/Sao_Paulo","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"America/Scoresbysund","-02","-02","-01","-01","-02:00:00","+01:00:00","-1;0;3","+23:00:00","-1;0;10","+00:00:00"
+"America/Sitka","AKST","AKST","AKDT","AKDT","-09:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/St_Johns","NST","NST","NDT","NDT","-03:30:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/St_Kitts","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/St_Lucia","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/St_Thomas","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/St_Vincent","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/Swift_Current","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
 "America/Tegucigalpa","CST","CST","","","-06:00:00","+00:00:00","","","","+00:00:00"
-"America/Thule","AST","AST","","","-04:00:00","+00:00:00","2;0;3","","1;0;11","+00:00:00"
-"America/Thunder_Bay","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Tijuana","PST","PST","PDT","PDT","-08:00:00","+01:00:00","1;0;4","+02:00:00","-1;0;10","+02:00:00"
+"America/Thule","AST","AST","ADT","ADT","-04:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Tijuana","PST","PST","PDT","PDT","-08:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"America/Toronto","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Tortola","AST","AST","","","-04:00:00","+00:00:00","","","","+00:00:00"
 "America/Vancouver","PST","PST","PDT","PDT","-08:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Whitehorse","PST","PST","PDT","PDT","-08:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Winnipeg","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+03:00:00"
+"America/Whitehorse","MST","MST","","","-07:00:00","+00:00:00","","","","+00:00:00"
+"America/Winnipeg","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "America/Yakutat","AKST","AKST","AKDT","AKDT","-09:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"America/Yellowknife","MST","MST","MDT","MDT","-07:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
-"Antarctica/Casey","WST","WST","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Antarctica/Davis","DAVT","DAVT","","","+07:00:00","+00:00:00","","","","+00:00:00"
-"Antarctica/DumontDUrville","DDUT","DDUT","","","+10:00:00","+00:00:00","","","","+00:00:00"
-"Antarctica/Mawson","MAWT","MAWT","","","+06:00:00","+00:00:00","","","","+00:00:00"
-"Antarctica/McMurdo","NZST","NZST","NZDT","NZDT","+12:00:00","+01:00:00","1;0;10","+02:00:00","3;0;3","+03:00:00"
-"Antarctica/Palmer","CLT","CLT","CLST","CLST","-04:00:00","+01:00:00","2;0;10","+00:00:00","2;0;3","+00:00:00"
-"Antarctica/South_Pole","NZST","NZST","NZDT","NZDT","+12:00:00","+01:00:00","1;0;10","+02:00:00","3;0;3","+03:00:00"
-"Antarctica/Syowa","SYOT","SYOT","","","+03:00:00","+00:00:00","","","","+00:00:00"
-"Antarctica/Vostok","VOST","VOST","","","+06:00:00","+00:00:00","","","","+00:00:00"
-"Arctic/Longyearbyen","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Asia/Aden","AST","AST","","","+03:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Almaty","ALMT","ALMT","ALMST","ALMST","+06:00:00","+01:00:00","-1;0;3","+00:00:00","-1;0;10","+00:00:00"
-"Asia/Amman","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;4;3","+00:00:00","-1;4;9","+01:00:00"
-"Asia/Anadyr","ANAT","ANAT","ANAST","ANAST","+12:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Asia/Aqtau","AQTT","AQTT","AQTST","AQTST","+04:00:00","+01:00:00","-1;0;3","+00:00:00","-1;0;10","+00:00:00"
-"Asia/Aqtobe","AQTT","AQTT","AQTST","AQTST","+05:00:00","+01:00:00","-1;0;3","+00:00:00","-1;0;10","+00:00:00"
-"Asia/Ashgabat","TMT","TMT","","","+05:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Baghdad","AST","AST","ADT","ADT","+03:00:00","+01:00:00","1;0;4","+03:00:00","1;0;10","+04:00:00"
-"Asia/Bahrain","AST","AST","","","+03:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Baku","AZT","AZT","AZST","AZST","+04:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+01:00:00"
-"Asia/Bangkok","ICT","ICT","","","+07:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Beirut","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+00:00:00","-1;0;10","+00:00:00"
-"Asia/Bishkek","KGT","KGT","KGST","KGST","+05:00:00","+01:00:00","-1;0;3","+02:30:00","-1;0;10","+02:30:00"
-"Asia/Brunei","BNT","BNT","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Calcutta","IST","IST","","","+05:30:00","+00:00:00","","","","+00:00:00"
-"Asia/Choibalsan","CHOT","CHOT","","","+09:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Chongqing","CST","CST","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Colombo","LKT","LKT","","","+06:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Damascus","EET","EET","EEST","EEST","+02:00:00","+01:00:00","1;0;4","+00:00:00","1;0;10","+00:00:00"
-"Asia/Dhaka","BDT","BDT","","","+06:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Dili","TPT","TPT","","","+09:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Dubai","GST","GST","","","+04:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Dushanbe","TJT","TJT","","","+05:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Gaza","EET","EET","EEST","EEST","+02:00:00","+01:00:00","3;5;4","+00:00:00","3;5;10","+00:00:00"
-"Asia/Harbin","CST","CST","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Antarctica/Casey","+08","+08","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Antarctica/Davis","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Antarctica/DumontDUrville","+10","+10","","","+10:00:00","+00:00:00","","","","+00:00:00"
+"Antarctica/Macquarie","AEST","AEST","AEDT","AEDT","+10:00:00","+01:00:00","1;0;10","+02:00:00","1;0;4","+03:00:00"
+"Antarctica/Mawson","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Antarctica/McMurdo","NZST","NZST","NZDT","NZDT","+12:00:00","+01:00:00","-1;0;9","+02:00:00","1;0;4","+03:00:00"
+"Antarctica/Palmer","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"Antarctica/Rothera","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"Antarctica/Syowa","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Antarctica/Troll","+00","+00","+02","+02","+00:00:00","+02:00:00","-1;0;3","+01:00:00","-1;0;10","+03:00:00"
+"Antarctica/Vostok","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Aden","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Almaty","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Amman","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Anadyr","+12","+12","","","+12:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Aqtau","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Aqtobe","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Ashgabat","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Atyrau","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Baghdad","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Bahrain","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Baku","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Bangkok","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Barnaul","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Beirut","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+00:00:00","-1;6;10","+00:00:00"
+"Asia/Bishkek","+06","+06","","","+06:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Brunei","+08","+08","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Chita","+09","+09","","","+09:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Colombo","+0530","+0530","","","+05:30:00","+00:00:00","","","","+00:00:00"
+"Asia/Damascus","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Dhaka","+06","+06","","","+06:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Dili","+09","+09","","","+09:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Dubai","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Dushanbe","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Famagusta","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
+"Asia/Gaza","EET","EET","EEST","EEST","+02:00:00","+01:00:00","2;6;4","+02:00:00","-1;6;10","+02:00:00"
+"Asia/Hebron","EET","EET","EEST","EEST","+02:00:00","+01:00:00","2;6;4","+02:00:00","-1;6;10","+02:00:00"
+"Asia/Ho_Chi_Minh","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
 "Asia/Hong_Kong","HKT","HKT","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Hovd","HOVT","HOVT","","","+07:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Irkutsk","IRKT","IRKT","IRKST","IRKST","+08:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Asia/Istanbul","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
-"Asia/Jakarta","WIT","WIT","","","+07:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Jayapura","EIT","EIT","","","+09:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Jerusalem","IST","IST","IDT","IDT","+02:00:00","+01:00:00","1;0;4","+01:00:00","1;0;10","+01:00:00"
-"Asia/Kabul","AFT","AFT","","","+04:30:00","+00:00:00","","","","+00:00:00"
-"Asia/Kamchatka","PETT","PETT","PETST","PETST","+12:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
+"Asia/Hovd","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Irkutsk","+08","+08","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Jakarta","WIB","WIB","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Jayapura","WIT","WIT","","","+09:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Jerusalem","IST","IST","IDT","IDT","+02:00:00","+01:00:00","-1;5;3","+02:00:00","-1;0;10","+02:00:00"
+"Asia/Kabul","+0430","+0430","","","+04:30:00","+00:00:00","","","","+00:00:00"
+"Asia/Kamchatka","+12","+12","","","+12:00:00","+00:00:00","","","","+00:00:00"
 "Asia/Karachi","PKT","PKT","","","+05:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Kashgar","CST","CST","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Katmandu","NPT","NPT","","","+05:45:00","+00:00:00","","","","+00:00:00"
-"Asia/Krasnoyarsk","KRAT","KRAT","KRAST","KRAST","+07:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Asia/Kuala_Lumpur","MYT","MYT","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Kuching","MYT","MYT","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Kuwait","AST","AST","","","+03:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Macao","CST","CST","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Kathmandu","+0545","+0545","","","+05:45:00","+00:00:00","","","","+00:00:00"
+"Asia/Khandyga","+09","+09","","","+09:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Kolkata","IST","IST","","","+05:30:00","+00:00:00","","","","+00:00:00"
+"Asia/Krasnoyarsk","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Kuala_Lumpur","+08","+08","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Kuching","+08","+08","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Kuwait","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
 "Asia/Macau","CST","CST","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Magadan","MAGT","MAGT","MAGST","MAGST","+11:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Asia/Makassar","CIT","CIT","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Manila","PHT","PHT","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Muscat","GST","GST","","","+04:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Magadan","+11","+11","","","+11:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Makassar","WITA","WITA","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Manila","PST","PST","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Muscat","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
 "Asia/Nicosia","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
-"Asia/Novosibirsk","NOVT","NOVT","NOVST","NOVST","+06:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Asia/Omsk","OMST","OMST","OMSST","OMSST","+06:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Asia/Oral","WST","WST","","","+05:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Phnom_Penh","ICT","ICT","","","+07:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Pontianak","WIT","WIT","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Novokuznetsk","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Novosibirsk","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Omsk","+06","+06","","","+06:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Oral","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Phnom_Penh","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Pontianak","WIB","WIB","","","+07:00:00","+00:00:00","","","","+00:00:00"
 "Asia/Pyongyang","KST","KST","","","+09:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Qyzylorda","KST","KST","","","+06:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Qatar","AST","AST","","","+03:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Rangoon","MMT","MMT","","","+06:30:00","+00:00:00","","","","+00:00:00"
-"Asia/Riyadh","AST","AST","","","+03:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Saigon","ICT","ICT","","","+07:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Sakhalin","SAKT","SAKT","SAKST","SAKST","+10:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Asia/Samarkand","UZT","UZT","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Qatar","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Qostanay","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Qyzylorda","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Riyadh","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Sakhalin","+11","+11","","","+11:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Samarkand","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
 "Asia/Seoul","KST","KST","","","+09:00:00","+00:00:00","","","","+00:00:00"
 "Asia/Shanghai","CST","CST","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Singapore","SGT","SGT","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Singapore","+08","+08","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Srednekolymsk","+11","+11","","","+11:00:00","+00:00:00","","","","+00:00:00"
 "Asia/Taipei","CST","CST","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Tashkent","UZT","UZT","","","+05:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Tbilisi","GET","GET","GEST","GEST","+04:00:00","+01:00:00","-1;0;3","+00:00:00","-1;0;10","+00:00:00"
-"Asia/Tehran","IRT","IRT","","","+03:30:00","+00:00:00","","","","+00:00:00"
-"Asia/Thimphu","BTT","BTT","","","+06:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Tashkent","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Tbilisi","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Tehran","+0330","+0330","","","+03:30:00","+00:00:00","","","","+00:00:00"
+"Asia/Thimphu","+06","+06","","","+06:00:00","+00:00:00","","","","+00:00:00"
 "Asia/Tokyo","JST","JST","","","+09:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Ujung_Pandang","CIT","CIT","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Ulaanbaatar","ULAT","ULAT","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Urumqi","CST","CST","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Vientiane","ICT","ICT","","","+07:00:00","+00:00:00","","","","+00:00:00"
-"Asia/Vladivostok","VLAT","VLAT","VLAST","VLAST","+10:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Asia/Yakutsk","YAKT","YAKT","YAKST","YAKST","+09:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Asia/Yekaterinburg","YEKT","YEKT","YEKST","YEKST","+05:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Asia/Yerevan","AMT","AMT","AMST","AMST","+04:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Atlantic/Azores","AZOT","AZOT","AZOST","AZOST","-01:00:00","+01:00:00","-1;0;3","+00:00:00","-1;0;10","+01:00:00"
-"Atlantic/Bermuda","AST","AST","ADT","ADT","-04:00:00","+01:00:00","1;0;4","+02:00:00","-1;0;10","+02:00:00"
+"Asia/Tomsk","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Ulaanbaatar","+08","+08","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Urumqi","+06","+06","","","+06:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Ust-Nera","+10","+10","","","+10:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Vientiane","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Vladivostok","+10","+10","","","+10:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Yakutsk","+09","+09","","","+09:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Yangon","+0630","+0630","","","+06:30:00","+00:00:00","","","","+00:00:00"
+"Asia/Yekaterinburg","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Asia/Yerevan","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
+"Atlantic/Azores","-01","-01","+00","+00","-01:00:00","+01:00:00","-1;0;3","+00:00:00","-1;0;10","+01:00:00"
+"Atlantic/Bermuda","AST","AST","ADT","ADT","-04:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
 "Atlantic/Canary","WET","WET","WEST","WEST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"
-"Atlantic/Cape_Verde","CVT","CVT","","","-01:00:00","+00:00:00","","","","+00:00:00"
-"Atlantic/Faeroe","WET","WET","WEST","WEST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"
-"Atlantic/Jan_Mayen","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
+"Atlantic/Cape_Verde","-01","-01","","","-01:00:00","+00:00:00","","","","+00:00:00"
+"Atlantic/Faroe","WET","WET","WEST","WEST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"
 "Atlantic/Madeira","WET","WET","WEST","WEST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"
 "Atlantic/Reykjavik","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
-"Atlantic/South_Georgia","GST","GST","","","-02:00:00","+00:00:00","","","","+00:00:00"
+"Atlantic/South_Georgia","-02","-02","","","-02:00:00","+00:00:00","","","","+00:00:00"
+"Atlantic/Stanley","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
 "Atlantic/St_Helena","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
-"Atlantic/Stanley","FKT","FKT","FKST","FKST","-04:00:00","+01:00:00","1;0;9","+02:00:00","3;0;4","+02:00:00"
-"Australia/Adelaide","CST","CST","CST","CST","+09:30:00","+01:00:00","-1;0;10","+02:00:00","-1;0;3","+03:00:00"
-"Australia/Brisbane","EST","EST","","","+10:00:00","+00:00:00","","","","+00:00:00"
-"Australia/Broken_Hill","CST","CST","CST","CST","+09:30:00","+01:00:00","-1;0;10","+02:00:00","-1;0;3","+03:00:00"
-"Australia/Darwin","CST","CST","","","+09:30:00","+00:00:00","","","","+00:00:00"
-"Australia/Hobart","EST","EST","EST","EST","+10:00:00","+01:00:00","1;0;10","+02:00:00","-1;0;3","+03:00:00"
-"Australia/Lindeman","EST","EST","","","+10:00:00","+00:00:00","","","","+00:00:00"
-"Australia/Lord_Howe","LHST","LHST","LHST","LHST","+10:30:00","+00:30:00","-1;0;10","+02:00:00","-1;0;3","+02:00:00"
-"Australia/Melbourne","EST","EST","EST","EST","+10:00:00","+01:00:00","-1;0;10","+02:00:00","-1;0;3","+03:00:00"
-"Australia/Perth","WST","WST","","","+08:00:00","+00:00:00","","","","+00:00:00"
-"Australia/Sydney","EST","EST","EST","EST","+10:00:00","+01:00:00","-1;0;10","+02:00:00","-1;0;3","+03:00:00"
+"Australia/Adelaide","ACST","ACST","ACDT","ACDT","+09:30:00","+01:00:00","1;0;10","+02:00:00","1;0;4","+03:00:00"
+"Australia/Brisbane","AEST","AEST","","","+10:00:00","+00:00:00","","","","+00:00:00"
+"Australia/Broken_Hill","ACST","ACST","ACDT","ACDT","+09:30:00","+01:00:00","1;0;10","+02:00:00","1;0;4","+03:00:00"
+"Australia/Darwin","ACST","ACST","","","+09:30:00","+00:00:00","","","","+00:00:00"
+"Australia/Eucla","+0845","+0845","","","+08:45:00","+00:00:00","","","","+00:00:00"
+"Australia/Hobart","AEST","AEST","AEDT","AEDT","+10:00:00","+01:00:00","1;0;10","+02:00:00","1;0;4","+03:00:00"
+"Australia/Lindeman","AEST","AEST","","","+10:00:00","+00:00:00","","","","+00:00:00"
+"Australia/Lord_Howe","+1030","+1030","+11","+11","+10:30:00","+00:30:00","1;0;10","+02:00:00","1;0;4","+02:00:00"
+"Australia/Melbourne","AEST","AEST","AEDT","AEDT","+10:00:00","+01:00:00","1;0;10","+02:00:00","1;0;4","+03:00:00"
+"Australia/Perth","AWST","AWST","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Australia/Sydney","AEST","AEST","AEDT","AEDT","+10:00:00","+01:00:00","1;0;10","+02:00:00","1;0;4","+03:00:00"
+"CET","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
+"CST6CDT","CST","CST","CDT","CDT","-06:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"EET","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
+"EST","EST","EST","","","-05:00:00","+00:00:00","","","","+00:00:00"
+"EST5EDT","EST","EST","EDT","EDT","-05:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"Etc/GMT","GMT","GMT","","","+00:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+1","-01","-01","","","-01:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-1","+01","+01","","","+01:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+10","-10","-10","","","-10:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-10","+10","+10","","","+10:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+11","-11","-11","","","-11:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-11","+11","+11","","","+11:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+12","-12","-12","","","-12:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-12","+12","+12","","","+12:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-13","+13","+13","","","+13:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-14","+14","+14","","","+14:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+2","-02","-02","","","-02:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-2","+02","+02","","","+02:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+3","-03","-03","","","-03:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-3","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+4","-04","-04","","","-04:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-4","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+5","-05","-05","","","-05:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-5","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+6","-06","-06","","","-06:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-6","+06","+06","","","+06:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+7","-07","-07","","","-07:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-7","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+8","-08","-08","","","-08:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-8","+08","+08","","","+08:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT+9","-09","-09","","","-09:00:00","+00:00:00","","","","+00:00:00"
+"Etc/GMT-9","+09","+09","","","+09:00:00","+00:00:00","","","","+00:00:00"
+"Etc/UTC","UTC","UTC","","","+00:00:00","+00:00:00","","","","+00:00:00"
 "Europe/Amsterdam","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Andorra","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
+"Europe/Astrakhan","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
 "Europe/Athens","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
-"Europe/Belfast","GMT","GMT","BST","BST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"
 "Europe/Belgrade","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Berlin","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Bratislava","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Brussels","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Bucharest","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
 "Europe/Budapest","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Chisinau","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
+"Europe/Chisinau","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+02:00:00"
 "Europe/Copenhagen","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Dublin","GMT","GMT","IST","IST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"
+"Europe/Dublin","IST","IST","GMT","GMT","+01:00:00","-01:00:00","-1;0;10","+02:00:00","-1;0;3","+01:00:00"
 "Europe/Gibraltar","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
+"Europe/Guernsey","GMT","GMT","BST","BST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"
 "Europe/Helsinki","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
-"Europe/Istanbul","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
-"Europe/Kaliningrad","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Kiev","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
+"Europe/Isle_of_Man","GMT","GMT","BST","BST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"
+"Europe/Istanbul","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Europe/Jersey","GMT","GMT","BST","BST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"
+"Europe/Kaliningrad","EET","EET","","","+02:00:00","+00:00:00","","","","+00:00:00"
+"Europe/Kirov","MSK","MSK","","","+03:00:00","+00:00:00","","","","+00:00:00"
+"Europe/Kyiv","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
 "Europe/Lisbon","WET","WET","WEST","WEST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"
 "Europe/Ljubljana","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/London","GMT","GMT","BST","BST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"
 "Europe/Luxembourg","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Madrid","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Malta","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Minsk","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
+"Europe/Minsk","+03","+03","","","+03:00:00","+00:00:00","","","","+00:00:00"
 "Europe/Monaco","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Moscow","MSK","MSK","MSD","MSD","+03:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Nicosia","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
+"Europe/Moscow","MSK","MSK","","","+03:00:00","+00:00:00","","","","+00:00:00"
 "Europe/Oslo","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Paris","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Prague","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Riga","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
 "Europe/Rome","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Samara","SAMT","SAMT","SAMST","SAMST","+04:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/San_Marino","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
+"Europe/Samara","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
 "Europe/Sarajevo","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Simferopol","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
+"Europe/Saratov","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
+"Europe/Simferopol","MSK","MSK","","","+03:00:00","+00:00:00","","","","+00:00:00"
 "Europe/Skopje","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Sofia","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
 "Europe/Stockholm","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Tallinn","EET","EET","","","+02:00:00","+00:00:00","","","","+00:00:00"
+"Europe/Tallinn","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
 "Europe/Tirane","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Uzhgorod","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
+"Europe/Ulyanovsk","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
 "Europe/Vaduz","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Vatican","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Vienna","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Vilnius","EET","EET","","","+02:00:00","+00:00:00","","","","+00:00:00"
+"Europe/Vilnius","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
+"Europe/Volgograd","MSK","MSK","","","+03:00:00","+00:00:00","","","","+00:00:00"
 "Europe/Warsaw","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
 "Europe/Zagreb","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
-"Europe/Zaporozhye","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
 "Europe/Zurich","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
+"Factory","-00","-00","","","+00:00:00","+00:00:00","","","","+00:00:00"
+"HST","HST","HST","","","-10:00:00","+00:00:00","","","","+00:00:00"
 "Indian/Antananarivo","EAT","EAT","","","+03:00:00","+00:00:00","","","","+00:00:00"
-"Indian/Chagos","IOT","IOT","","","+06:00:00","+00:00:00","","","","+00:00:00"
-"Indian/Christmas","CXT","CXT","","","+07:00:00","+00:00:00","","","","+00:00:00"
-"Indian/Cocos","CCT","CCT","","","+06:30:00","+00:00:00","","","","+00:00:00"
+"Indian/Chagos","+06","+06","","","+06:00:00","+00:00:00","","","","+00:00:00"
+"Indian/Christmas","+07","+07","","","+07:00:00","+00:00:00","","","","+00:00:00"
+"Indian/Cocos","+0630","+0630","","","+06:30:00","+00:00:00","","","","+00:00:00"
 "Indian/Comoro","EAT","EAT","","","+03:00:00","+00:00:00","","","","+00:00:00"
-"Indian/Kerguelen","TFT","TFT","","","+05:00:00","+00:00:00","","","","+00:00:00"
-"Indian/Mahe","SCT","SCT","","","+04:00:00","+00:00:00","","","","+00:00:00"
-"Indian/Maldives","MVT","MVT","","","+05:00:00","+00:00:00","","","","+00:00:00"
-"Indian/Mauritius","MUT","MUT","","","+04:00:00","+00:00:00","","","","+00:00:00"
+"Indian/Kerguelen","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Indian/Mahe","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
+"Indian/Maldives","+05","+05","","","+05:00:00","+00:00:00","","","","+00:00:00"
+"Indian/Mauritius","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
 "Indian/Mayotte","EAT","EAT","","","+03:00:00","+00:00:00","","","","+00:00:00"
-"Indian/Reunion","RET","RET","","","+04:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Apia","WST","WST","","","-11:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Auckland","NZST","NZST","NZDT","NZDT","+12:00:00","+01:00:00","1;0;10","+02:00:00","3;0;3","+03:00:00"
-"Pacific/Chatham","CHAST","CHAST","CHADT","CHADT","+12:45:00","+01:00:00","1;0;10","+02:45:00","3;0;3","+03:45:00"
-"Pacific/Easter","EAST","EAST","EASST","EASST","-06:00:00","+01:00:00","2;6;10","+22:00:00","2;6;3","+22:00:00"
-"Pacific/Efate","VUT","VUT","","","+11:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Enderbury","PHOT","PHOT","","","+13:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Fakaofo","TKT","TKT","","","-10:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Fiji","FJT","FJT","","","+12:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Funafuti","TVT","TVT","","","+12:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Galapagos","GALT","GALT","","","-06:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Gambier","GAMT","GAMT","","","-09:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Guadalcanal","SBT","SBT","","","+11:00:00","+00:00:00","","","","+00:00:00"
+"Indian/Reunion","+04","+04","","","+04:00:00","+00:00:00","","","","+00:00:00"
+"MET","MET","MET","MEST","MEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
+"MST","MST","MST","","","-07:00:00","+00:00:00","","","","+00:00:00"
+"MST7MDT","MST","MST","MDT","MDT","-07:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"Pacific/Apia","+13","+13","","","+13:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Auckland","NZST","NZST","NZDT","NZDT","+12:00:00","+01:00:00","-1;0;9","+02:00:00","1;0;4","+03:00:00"
+"Pacific/Bougainville","+11","+11","","","+11:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Chatham","+1245","+1245","+1345","+1345","+12:45:00","+01:00:00","-1;0;9","+02:45:00","1;0;4","+03:45:00"
+"Pacific/Chuuk","+10","+10","","","+10:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Easter","-06","-06","-05","-05","-06:00:00","+01:00:00","1;0;9","+21:00:00","1;0;4","+23:00:00"
+"Pacific/Efate","+11","+11","","","+11:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Fakaofo","+13","+13","","","+13:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Fiji","+12","+12","","","+12:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Funafuti","+12","+12","","","+12:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Galapagos","-06","-06","","","-06:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Gambier","-09","-09","","","-09:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Guadalcanal","+11","+11","","","+11:00:00","+00:00:00","","","","+00:00:00"
 "Pacific/Guam","ChST","ChST","","","+10:00:00","+00:00:00","","","","+00:00:00"
 "Pacific/Honolulu","HST","HST","","","-10:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Johnston","HST","HST","","","-10:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Kiritimati","LINT","LINT","","","+14:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Kosrae","KOST","KOST","","","+11:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Kwajalein","MHT","MHT","","","+12:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Majuro","MHT","MHT","","","+12:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Marquesas","MART","MART","","","-09:30:00","+00:00:00","","","","+00:00:00"
+"Pacific/Kanton","+13","+13","","","+13:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Kiritimati","+14","+14","","","+14:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Kosrae","+11","+11","","","+11:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Kwajalein","+12","+12","","","+12:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Majuro","+12","+12","","","+12:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Marquesas","-0930","-0930","","","-09:30:00","+00:00:00","","","","+00:00:00"
 "Pacific/Midway","SST","SST","","","-11:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Nauru","NRT","NRT","","","+12:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Niue","NUT","NUT","","","-11:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Norfolk","NFT","NFT","","","+11:30:00","+00:00:00","","","","+00:00:00"
-"Pacific/Noumea","NCT","NCT","","","+11:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Nauru","+12","+12","","","+12:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Niue","-11","-11","","","-11:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Norfolk","+11","+11","+12","+12","+11:00:00","+01:00:00","1;0;10","+02:00:00","1;0;4","+03:00:00"
+"Pacific/Noumea","+11","+11","","","+11:00:00","+00:00:00","","","","+00:00:00"
 "Pacific/Pago_Pago","SST","SST","","","-11:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Palau","PWT","PWT","","","+09:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Pitcairn","PST","PST","","","-08:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Ponape","PONT","PONT","","","+11:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Port_Moresby","PGT","PGT","","","+10:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Rarotonga","CKT","CKT","","","-10:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Palau","+09","+09","","","+09:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Pitcairn","-08","-08","","","-08:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Pohnpei","+11","+11","","","+11:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Port_Moresby","+10","+10","","","+10:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Rarotonga","-10","-10","","","-10:00:00","+00:00:00","","","","+00:00:00"
 "Pacific/Saipan","ChST","ChST","","","+10:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Tahiti","TAHT","TAHT","","","-10:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Tarawa","GILT","GILT","","","+12:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Tongatapu","TOT","TOT","","","+13:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Truk","TRUT","TRUT","","","+10:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Wake","WAKT","WAKT","","","+12:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Wallis","WFT","WFT","","","+12:00:00","+00:00:00","","","","+00:00:00"
-"Pacific/Yap","YAPT","YAPT","","","+10:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Tahiti","-10","-10","","","-10:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Tarawa","+12","+12","","","+12:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Tongatapu","+13","+13","","","+13:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Wake","+12","+12","","","+12:00:00","+00:00:00","","","","+00:00:00"
+"Pacific/Wallis","+12","+12","","","+12:00:00","+00:00:00","","","","+00:00:00"
+"PST8PDT","PST","PST","PDT","PDT","-08:00:00","+01:00:00","2;0;3","+02:00:00","1;0;11","+02:00:00"
+"WET","WET","WET","WEST","WEST","+00:00:00","+01:00:00","-1;0;3","+01:00:00","-1;0;10","+02:00:00"

data/tzinfo.pl

@@ -0,0 +1,257 @@
+#!/usr/bin/perl -w
+
+# created based on tzdump.pl
+
+use strict;
+
+sub timeoffset
+{
+    my $value = shift;
+    my $seconds = $value % 60;
+    my $minutes = ($value / 60) % 60;
+    my $hours = $value / 3600;
+    sprintf "%+03d:%02d:%02d",$hours,$minutes,$seconds;
+}
+
+# mtwtfss mtwtfss 
+
+sub timerule
+{
+    my ($time,$isgmt,$offset) = @_;
+
+    # print "isgmt=$isgmt time=$time offset=$offset\n";
+
+    $time += $offset if(!$isgmt);
+    
+    my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$foo) = gmtime($time);
+    ++$mon;
+    my $nweek = int(($mday-1)/7) + 1;
+    $nweek = -1 if($nweek >= 4);
+    "$nweek;$wday;$mon";
+}
+
+sub dsttime
+{
+    my ($time,$isstd,$offset1,$offset2) = @_;
+    # print "isstd=$isstd time=$time offset1=$offset1 offset2=$offset2\n";
+
+    $time += ($isstd ? $offset1 : $offset2);
+
+    my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$foo) = gmtime($time);
+    sprintf "%+03d:%02d:%02d",$hour,$min,$sec;
+}
+
+sub tzinfo
+{
+    my $dir = "/usr/share/zoneinfo";
+    my $zone = shift;
+
+    if (not open (FILE, "$dir/$zone"))
+    {
+	warn "open $dir/$zone: $!\n";
+	return;
+    }
+
+    my $year = 1900 + (gmtime(time))[5];
+    
+    my $tzfile = {};
+    my $data;
+
+    sysread (FILE, $data, 44) or die;
+
+    my ($header, $reserved, $ttisgmtcnt, $ttisstdcnt, $leapcnt, $timecnt,
+	$typecnt, $charcnt) = unpack "a4 a16 N N N N N N", $data;
+
+    if ($header ne "TZif")
+    {
+	warn "$dir/$zone: Doesn't look like tzfile data\n";
+	close FILE;
+	return;
+    }
+
+    # print "ttisgmtcnt=$ttisgmtcnt, ttisstdcnt=$ttisstdcnt, leapcnt=$leapcnt, timecnt=$timecnt, typecnt=$typecnt, charcnt=$charcnt\n";
+
+    my $tzdata;
+    my $index = 0;
+
+    sysread (FILE, $tzdata, 5 * $timecnt + 6 * $typecnt + $charcnt +
+	     8 * $leapcnt + $ttisstdcnt + $ttisgmtcnt);
+
+    my $tzchunk = sub
+    {
+	my $howbig = shift;
+	my $chunk = substr ($tzdata, $index, $howbig);
+	$index += $howbig;
+	$chunk;
+    };
+
+    my %ttimes;
+    my @ttimes;
+    my @ttindexes;
+
+    my @dates;  # settings for current year
+    my @indexes;
+
+    my $lastindex = -1;
+    
+    if ($timecnt)
+    {
+	$data = &$tzchunk (4 * $timecnt);
+	@ttimes = unpack ("N" x $timecnt, $data);
+
+	$data = &$tzchunk ($timecnt);
+	@ttindexes = unpack "C" x $timecnt, $data;
+
+	for (my $i=0; $i<=$#ttimes; $i++)
+	{
+	    my $ruleyear = 1900 + (gmtime($ttimes[$i]))[5];
+
+	    $lastindex = $ttindexes[$i];
+	    
+	    if ($ruleyear == $year)
+	    {
+		push @dates, $ttimes[$i];
+		push @indexes, $ttindexes[$i];
+	    }
+	}
+    }
+
+    my @ttinfo;
+
+    foreach (0 .. $typecnt - 1)
+    {
+	$data = &$tzchunk (6);
+	my ($gmtoff, $isdst, $abbrind) = unpack ("N c C", $data);
+	$gmtoff = unpack ("l", pack ("L", $gmtoff));
+	push (@ttinfo, { gmtoff => $gmtoff, isdst => $isdst, abbrind => $abbrind });
+	# print "ttinfo[$_]: gmtoff=$gmtoff isdst=$isdst abbrind=$abbrind\n";
+    }
+
+ 
+    my $tznames;
+
+    if ($charcnt)
+    {
+	$tznames = &$tzchunk ($charcnt) or die;
+	# print "abbrevs: ", join (", ", split /\000/, $tznames), "\n";
+    }
+
+    my @leapsecs;
+
+    if ($leapcnt)
+    {
+	$data = &$tzchunk (8 * $leapcnt);
+	# print "leapsecs: ", join (", ", unpack ("NN" x $leapcnt, $data)), "\n";
+    }
+
+    my @stddata;
+    if ($ttisstdcnt)
+    {
+	$data = &$tzchunk ($ttisstdcnt);
+	@stddata = unpack ("C" x $ttisstdcnt, $data);
+	# print "isstd: ", join (", ", @stddata), "\n";
+    }
+
+    my @gmtdata;
+    if ($ttisgmtcnt)
+    {
+	$data = &$tzchunk ($ttisgmtcnt);
+	@gmtdata = unpack ("C" x $ttisgmtcnt, $data);
+	# print "isgmt: ", join(", ", @gmtdata), "\n";
+    }
+
+    close FILE;
+
+    # Print Boost date_time_zoneinfo line
+
+    # for(my $i=0; $i<=$#dates; $i++)
+    # {
+    #  print scalar gmtime ($dates[$i]), " => ", $indexes[$i], " ", $ttimes[$i], "\n";
+    # }
+
+    if ($#dates == 1)
+    {
+	# ID, STD ABBR, STD NAME, DST ABBR, DST NAME, GMT offset, DST adjustment, Rule1, Time1, Rule2, Time2
+	# "Europe/Helsinki","EET","EET","EEST","EEST","+02:00:00","+01:00:00","-1;0;3","+03:00:00","-1;0;10","+04:00:00"
+	# Rule = week,day,month
+	# week=1...5 or -1 if last week. We interpret week 4/5 to always imply last week
+	# day=0...6, 0=Sun
+	
+	my $isdst1 = $ttinfo[$indexes[0]]{isdst};
+	my $isdst2 = $ttinfo[$indexes[1]]{isdst};
+
+	my $abbrind1 = $ttinfo[$indexes[0]]{abbrind};
+	my $abbrind2 = $ttinfo[$indexes[1]]{abbrind};
+
+	my $isgmt1 = $gmtdata[$indexes[0]];
+	my $isgmt2 = $gmtdata[$indexes[1]];
+
+	my $isstd1 = $stddata[$indexes[0]];
+	my $isstd2 = $stddata[$indexes[1]];
+	
+	my $zname1 = substr($tznames,$abbrind1,index($tznames,"\000",$abbrind1)-$abbrind1);
+	my $zname2 = substr($tznames,$abbrind2,index($tznames,"\000",$abbrind2)-$abbrind2);
+
+	if($isdst1)
+	{
+	    my $tmp = $zname1;
+	    $zname1 = $zname2;
+	    $zname2 = $tmp;
+	}
+	
+	my $offset1 = $ttinfo[$indexes[0]]{gmtoff};
+	my $offset2 = $ttinfo[$indexes[1]]{gmtoff};
+
+	my $gmtoffset = ($isdst1 ? timeoffset($offset2) : timeoffset($offset1));
+	my $dstadjustment = timeoffset($isdst1 ? $offset1-$offset2 : $offset2-$offset1);
+
+	my $dststartrule = timerule($isdst1 ? $dates[0] : $dates[1], $isgmt1, $offset1);
+	my $dststarttime = ($isdst1 ? dsttime($dates[1],$isstd2,$offset2,$offset1) : dsttime($dates[0],$isstd1,$offset1,$offset2));
+	
+	my $dstendrule = timerule($isdst1 ? $dates[1] : $dates[0], $isgmt2, $offset2);
+	my $dstendtime = ($isdst1 ? dsttime($dates[0],$isstd1,$offset1,$offset2) : dsttime($dates[1],$isstd2,$offset2,$offset1));
+	
+	print "\"$zone\",\"$zname1\",\"$zname1\",\"$zname2\",\"$zname2\",\"$gmtoffset\",\"$dstadjustment\",\"$dststartrule\",\"$dststarttime\",\"$dstendrule\",\"$dstendtime\"\n";
+	
+    }
+    else
+    {
+	# Use the last row if everything fails (Asia/Calcutta, Europe/Moscow)
+
+	if($lastindex < 0)
+	{
+	    $lastindex = $#ttinfo;
+	}
+	
+	# ID, STD ABBR, STD NAME, DST ABBR, DST NAME, GMT offset, DST adjustment, Rule1, Time1, Rule2, Time2
+	# "Europe/Moscow","MSK","MSK","","","+03:00:00","+00:00:00","","","","+00:00:00"
+
+	my $isdst = $ttinfo[$lastindex]{isdst};
+	my $abbrind = $ttinfo[$lastindex]{abbrind};
+	my $isgmt = $gmtdata[$lastindex];
+	my $isstd = $stddata[$lastindex];
+	
+	my $zname = substr($tznames,$abbrind,index($tznames,"\000",$abbrind)-$abbrind);
+
+	my $offset = $ttinfo[$lastindex]{gmtoff};
+	my $gmtoffset = timeoffset($offset);
+	my $dstadjustment = "+00:00:00";
+
+	my $dststartrule = "";
+	my $dststarttime = "";
+	
+	my $dstendrule = "";
+	my $dstendtime = "+00:00:00"; # no idea why the Boost.Date_time does this
+
+	# print "$gmtoffset $offset\n";
+	
+	print "\"$zone\",\"$zname\",\"$zname\",\"\",\"\",\"$gmtoffset\",\"$dstadjustment\",\"$dststartrule\",\"$dststarttime\",\"$dstendrule\",\"$dstendtime\"\n";
+	
+    }
+}
+
+
+foreach my $filename (@ARGV)
+{
+    tzinfo ($filename);
+}

doc/build.jam

@@ -0,0 +1,18 @@
+# Copyright (c) 2016 Rene Rivera
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+require-b2 5.2 ;
+
+###############################################################################
+alias boostdoc
+    : ../xmldoc/date_time.xml
+    :
+    : <dependency>../xmldoc//date_time_autodoc <dependency>../xmldoc//gregorian_autodoc
+      <dependency>../xmldoc//posix_time_autodoc <dependency>../xmldoc//local_time_autodoc
+    : ;
+explicit boostdoc ;
+alias boostrelease ;
+explicit boostrelease ;

example/Jamfile

@@ -1,109 +1,47 @@
-subproject libs/date_time/example ;
+project : requirements <library>/boost/date_time//boost_date_time ;
 
-local DATE_TIME_PROPERTIES = <define>BOOST_DATE_TIME_STATIC_LINK ;
+exe dates_as_strings   : gregorian/dates_as_strings.cpp ;
+exe days_alive         : gregorian/days_alive.cpp ;
+exe days_till_new_year : gregorian/days_till_new_year.cpp ;
+
+exe days_between_new_years  : gregorian/days_between_new_years.cpp ;
+exe find_last_day_of_months : gregorian/find_last_day_of_months.cpp ;
+
+exe month_add : gregorian/month_add.cpp ;
+
+exe localization   : gregorian/localization.cpp ;
+exe print_holidays : gregorian/print_holidays.cpp ;
+exe print_month    : gregorian/print_month.cpp ;
+exe period_calc    : gregorian/period_calc.cpp ;
+
+exe days_since_year_start : gregorian/days_since_year_start.cpp ;
 
 
-exe dates_as_strings : <lib>../build/boost_date_time
-                    gregorian/dates_as_strings.cpp
-                  : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES)  
-                  ;
-
-exe days_alive : <lib>../build/boost_date_time
-                  gregorian/days_alive.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
+exe local_utc_conversion : posix_time/local_utc_conversion.cpp
+                : <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
                 ;
 
-exe days_till_new_year : <lib>../build/boost_date_time
-                  gregorian/days_till_new_year.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
+exe print_hours : posix_time/print_hours.cpp
+                : <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
                 ;
 
-exe days_between_new_years : <lib>../build/boost_date_time
-                  gregorian/days_between_new_years.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
+exe time_math   : posix_time/time_math.cpp
+                : <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
                 ;
 
-exe find_last_day_of_months : <lib>../build/boost_date_time
-                  gregorian/find_last_day_of_months.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
-                ;
+exe time_periods : posix_time/time_periods.cpp
+                 : <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+                 ;
 
-exe month_add : <lib>../build/boost_date_time
-                  gregorian/month_add.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
-                ;
-
-exe localization : gregorian/localization.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
-                ;
-
-exe print_holidays : <lib>../build/boost_date_time
-                  gregorian/print_holidays.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
-                ;
-
-exe print_month : <lib>../build/boost_date_time
-                  gregorian/print_month.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
-                ;
-
-exe period_calc : <lib>../build/boost_date_time
-                  gregorian/period_calc.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
-                ;
-
-exe days_since_year_start : <lib>../build/boost_date_time
-                  gregorian/days_since_year_start.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
-                ;
-
-exe local_utc_conversion : <lib>../build/boost_date_time
-                  posix_time/local_utc_conversion.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG  
-                ;
-
-exe print_hours : <lib>../build/boost_date_time
-                  posix_time/print_hours.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG  
-                ;
-
-exe time_math : <lib>../build/boost_date_time
-                  posix_time/time_math.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG  
-                ;
-
-exe time_periods : <lib>../build/boost_date_time
-                  posix_time/time_periods.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG  
-                ;
-
-exe simple_time_zone : <lib>../build/boost_date_time
-                  local_time/simple_time_zone.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
-                ;
-
-exe calc_rules : <lib>../build/boost_date_time
-                  local_time/calc_rules.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
-                ;
-
-exe seconds_since_epoch : <lib>../build/boost_date_time
-                  local_time/seconds_since_epoch.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
-                ;
-
-exe flight : <lib>../build/boost_date_time
-                  local_time/flight.cpp
-                : <include>$(BOOST_ROOT) $(DATE_TIME_PROPERTIES) 
-                ;
-
-exe io_tutorial : tutorial/io_tutorial.cpp
-                : <include>$(BOOST_ROOT)
-                ;
+exe simple_time_zone : local_time/simple_time_zone.cpp ;
+exe calc_rules       : local_time/calc_rules.cpp ;
+exe seconds_since_epoch : local_time/seconds_since_epoch.cpp ;
+exe flight      : local_time/flight.cpp ;
+exe io_tutorial : tutorial/io_tutorial.cpp ;
 
 # Copyright (c) 2002-2005
 # CrystalClear Software, Inc.
-# Subject to the Boost Software License, Version 1.0. 
-# (See accompanying file LICENSE_1_0.txt or 
+# 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)
 

example/gregorian/dates_as_strings.cpp

@@ -25,7 +25,7 @@ main()
     date d(from_simple_string(s));
     std::cout << to_simple_string(d) << std::endl;
     
-    //Read ISO Standard(CCYYMMDD) and output ISO Extended
+    //Read ISO 8601 Standard(CCYYMMDD) and output ISO 8601 Extended
     std::string ud("20011009"); //2001-Oct-09
     date d1(from_undelimited_string(ud));
     std::cout << to_iso_extended_string(d1) << std::endl;

example/gregorian/days_between_new_years.cpp

@@ -3,10 +3,11 @@
  * New Years day of this year, and days until next New Years day.
  *
  * Expected results:
- * Adding together both durations will produce 366 (365 in a leap year).
+ * Adding together both durations will produce 365 (366 in a leap year).
  */
-#include <iostream>
+
 #include "boost/date_time/gregorian/gregorian.hpp"
+#include <iostream>
 
 int
 main() 
@@ -25,7 +26,7 @@ main()
   std::cout << "Days until next Jan 1: " << days_until_year_start.days() 
             << std::endl;
   return 0;
-};
+}
 
 
 /*  Copyright 2001-2004: CrystalClear Software, Inc

example/gregorian/days_since_year_start.cpp

@@ -1,6 +1,6 @@
 
-#include <iostream>
 #include "boost/date_time/gregorian/gregorian.hpp"
+#include <iostream>
 
 int
 main() 
@@ -14,7 +14,7 @@ main()
   std::cout << "Days since Jan 1: " << days_since_year_start.days() 
             << std::endl;
   return 0;
-};
+}
 
 /*  Copyright 2001-2004: CrystalClear Software, Inc
  *  http://www.crystalclearsoftware.com

example/gregorian/days_till_new_year.cpp

@@ -15,7 +15,7 @@ main()
   
   std::cout << "Days till new year: " << dd.days() << std::endl;
   return 0;
-};
+}
 
 /*  Copyright 2001-2004: CrystalClear Software, Inc
  *  http://www.crystalclearsoftware.com

example/gregorian/find_last_day_of_months.cpp

@@ -15,7 +15,8 @@ main()
 
   // get a month and a year from the user
   try {
-    int y, m;
+    greg_year::value_type y;
+    greg_month::value_type m;
     std::cout << "   Enter Year(ex: 2002): ";
     std::cin >> y;
     year = greg_year(y);
@@ -23,11 +24,11 @@ main()
     std::cin >> m;
     month = greg_month(m);
   }
-  catch(bad_year by) {
+  catch(const bad_year& by) {
     std::cout << "Invalid Year Entered: " << by.what() << '\n'
       << "Using minimum values for month and year." << std::endl;
   }
-  catch(bad_month bm) {
+  catch(const bad_month& bm) {
     std::cout << "Invalid Month Entered" << bm.what() << '\n'
       << "Using minimum value for month. " << std::endl;
   }

example/gregorian/localization.cpp

@@ -83,7 +83,7 @@ int main()
   us_facet->format("%m/%d/%Y");
   std::cout << d1 << std::endl; //  10/01/2002
   
-  // English names, iso order (year-month-day), '-' separator
+  // English names, ISO 8601 order (year-month-day), '-' separator
   us_facet->format("%Y-%b-%d");
   std::cout << d1 << std::endl; //  2002-Oct-01
   

example/gregorian/month_add.cpp

@@ -17,7 +17,7 @@ main()
   date d2 = d + months(1); 
   date d3 = d - months(1);
   std::cout << "Today is: " << to_simple_string(d) << ".\n"
-            << "One month from today will be: " << to_simple_string(d2) 
+            << "One month from today will be: " << to_simple_string(d2) << ".\n"
             << "One month ago was: " << to_simple_string(d3)
             << std::endl;
   std::cout << "******** Warning read this ***********************\n";
@@ -31,14 +31,20 @@ main()
             << std::endl;
 
   std::cout << "\nSo what does this mean?  It means the result of adding months is order\n"
-            << "dependent, non-communitive, and may create problems for applications.\n"
+            << "dependent, non-commutative, and may create problems for applications.\n"
             << "Consider: \n"
-            << "Jan 30, 2004 + (1 month) + (1 month) != Jan 29, 2004 + (2 months)\n"
-            << "Why not? Because Jan 30, 2004 + 1 month is Feb 29 + 1 month is Mar 29th.\n"
-            << "while Jan 30, 2004 + 2 months is Mar 29th.\n"
+            << "Jan 30, 2004 + (1 month) + (1 month) != Jan 30, 2004 + (2 months)\n"
+            << "Why not? Because Jan 30, 2004 + 1 month is Feb 29 + 1 month is Mar 31st.\n"
+            << "while Jan 30, 2004 + 2 months is Mar 30th.\n"
             << "All of this clears up as long as all the starting dates before the 28th of\n"
             << "the month -- then all the behavior follows classical mathematical rules.\n";
   
+  date d6(2004, Jan, 30);
+  date d7 = d6 + months(1) + months(1);
+  date d8 = d6 + months(2);
+  std::cout << "2004-01-30 + (1 month) + (1 month) is: " << to_simple_string(d7) << ".\n"
+            << "2004-01-30 + (2 months) is: " << to_simple_string(d8)
+			<< std::endl;
 
   return 0;
 }

example/gregorian/print_holidays.cpp

@@ -33,12 +33,12 @@ print_date(boost::gregorian::date d)
 int
 main() {
 
-  std::cout << "Enter Year: ";
-  int year;
-  std::cin >> year;
-
   using namespace boost::gregorian;
 
+  std::cout << "Enter Year: ";
+  greg_year::value_type year;
+  std::cin >> year;
+
   //define a collection of holidays fixed by month and day
   std::vector<year_based_generator*> holidays;
   holidays.push_back(new partial_date(1,Jan)); //Western New Year

example/gregorian/print_month.cpp

@@ -19,16 +19,18 @@
 int
 main()
 {
+  using namespace boost::gregorian;
+
   std::cout << "Enter Year: ";
-  int year, month;
+  greg_year::value_type year;
+  greg_month::value_type month;
   std::cin >> year;
   std::cout << "Enter Month(1..12): ";
   std::cin >> month;
 
-  using namespace boost::gregorian;
   try {
     //Use the calendar to get the last day of the month
-    int eom_day = gregorian_calendar::end_of_month_day(year,month);
+    greg_day::value_type eom_day = gregorian_calendar::end_of_month_day(year,month);
     date endOfMonth(year,month,eom_day);
 
     //construct an iterator starting with firt day of the month

example/local_time/flight.cpp

@@ -5,7 +5,7 @@
 /* This example shows a program that calculates the arrival time of a plane
  * that flys from Phoenix to New York.  During the flight New York shifts
  * into daylight savings time (Phoenix doesn't because Arizona doesn't use
- * dst).  
+ * DST).  
  *
  * 
  */
@@ -20,24 +20,34 @@ int main()
   //setup some timezones for creating and adjusting local times
   //This user editable file can be found in libs/date_time/data.
   tz_database tz_db;
-  tz_db.load_from_file("date_time_zonespec.csv");
+  try {
+    tz_db.load_from_file("../../data/date_time_zonespec.csv");
+  }catch(const data_not_accessible& dna) {
+    std::cerr << "Error with time zone data file: " << dna.what() << std::endl;
+    exit(EXIT_FAILURE);
+  }catch(const bad_field_count& bfc) {
+    std::cerr << "Error with time zone data file: " << bfc.what() << std::endl;
+    exit(EXIT_FAILURE);
+  }
   time_zone_ptr nyc_tz = tz_db.time_zone_from_region("America/New_York");
-  //Use a 
+  //Use a newly created time zone rule
   time_zone_ptr phx_tz(new posix_time_zone("MST-07:00:00"));
 
-  //local departure time in phoenix is 11 pm on april 2 2005 
-  // (ny changes to dst on apr 3 at 2 am)
-  local_date_time phx_departure(date(2005, Apr, 2), hours(23), 
+  //local departure time in Phoenix is 11 pm on March 13 2010 
+  // (NY changes to DST on March 14 at 2 am)
+  local_date_time phx_departure(date(2010, Mar, 13), hours(23), 
                                 phx_tz, 
                                 local_date_time::NOT_DATE_TIME_ON_ERROR);
+  local_date_time nyc_departure = phx_departure.local_time_in(nyc_tz);
 
   time_duration flight_length = hours(4) + minutes(30);
   local_date_time phx_arrival = phx_departure + flight_length;
   local_date_time nyc_arrival = phx_arrival.local_time_in(nyc_tz);
 
-  std::cout << "departure phx time: " << phx_departure << std::endl;
-  std::cout << "arrival phx time:   " << phx_arrival << std::endl;
-  std::cout << "arrival nyc time:   " << nyc_arrival << std::endl;
+  std::cout << "departure PHX time: " << phx_departure << std::endl;
+  std::cout << "departure NYC time: " << nyc_departure << std::endl;
+  std::cout << "arrival PHX time:   " << phx_arrival << std::endl;
+  std::cout << "arrival NYC time:   " << nyc_arrival << std::endl;
 
 }
 

example/local_time/local_date_time.cpp

@@ -24,14 +24,14 @@ int main() {
   local_date_time ny_time(date(2004, Aug, 30), hours(10), nyc, true);
   
   typedef boost::date_time::time_facet<local_date_time, char> ldt_facet;
-  ldt_facet* timefacet = new ldt_facet("%Y-%b-%d %H:%M:%S%F %Z");
+  ldt_facet* timefacet = new ldt_facet("%Y-%b-%d %H:%M:%S""%F %Z");
   std::locale loc(std::locale::classic(), timefacet);
   
   std::cout << ny_time << std::endl;
-  // 2004-Aug-30 00:00:00 EDT
+  // 2004-Aug-30 10:00:00 EDT
   std::cout.imbue(loc);
   std::cout << ny_time << std::endl;
-  // 2004-Aug-30 00:00:00 Eastern Daylight Time
+  // 2004-Aug-30 10:00:00 Eastern Daylight Time
 
   return 0;
 }

example/local_time/seconds_since_epoch.cpp

@@ -24,10 +24,10 @@ int main()
   tz_database tz_db;
   try {
     tz_db.load_from_file("../data/date_time_zonespec.csv");
-  }catch(data_not_accessible dna) {
+  }catch(const data_not_accessible& dna) {
     std::cerr << "Error with time zone data file: " << dna.what() << std::endl;
     exit(EXIT_FAILURE);
-  }catch(bad_field_count bfc) {
+  }catch(const bad_field_count& bfc) {
     std::cerr << "Error with time zone data file: " << bfc.what() << std::endl;
     exit(EXIT_FAILURE);
   }

example/posix_time/print_hours.cpp

@@ -29,16 +29,16 @@ main()
   ptime now = second_clock::local_time();
   //Get the date part out of the time
   date today = now.date();
-  date tommorrow = today + days(1);
-  ptime tommorrow_start(tommorrow); //midnight 
+  date tomorrow = today + days(1);
+  ptime tomorrow_start(tomorrow); //midnight 
 
   //iterator adds by one hour
   time_iterator titr(now,hours(1)); 
-  for (; titr < tommorrow_start; ++titr) {
+  for (; titr < tomorrow_start; ++titr) {
     std::cout << to_simple_string(*titr) << std::endl;
   }
   
-  time_duration remaining = tommorrow_start - now;
+  time_duration remaining = tomorrow_start - now;
   std::cout << "Time left till midnight: " 
             << to_simple_string(remaining) << std::endl;
   return 0;

example/posix_time/time_math.cpp

@@ -13,7 +13,7 @@ main()
   using namespace boost::gregorian;
 
   date d(2002,Feb,1); //an arbitrary date
-  //construct a time by adding up some durations durations
+  //construct a time by adding up some durations
   ptime t1(d, hours(5)+minutes(4)+seconds(2)+milliseconds(1));
   //construct a new time by subtracting some times
   ptime t2 = t1 - hours(5)- minutes(4)- seconds(2)- milliseconds(1);

example/tutorial/io_tutorial.cpp

@@ -141,7 +141,7 @@ int main(){
   period_formatter per_formatter(period_formatter::AS_OPEN_RANGE, 
                                  " to ", "from ", " exclusive", " inclusive" );
   period_parser per_parser(period_parser::AS_OPEN_RANGE, 
-                           " to ", "from ", " exclusive" , "inclusive" );
+                           " to ", "from ", " exclusive" , " inclusive" );
   
   // default output
   ss.str("");

include/boost/date_time/adjust_functors.hpp

@@ -2,7 +2,7 @@
 #define _DATE_TIME_ADJUST_FUNCTORS_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
@@ -14,26 +14,21 @@
 
 namespace boost {
 namespace date_time {
-  
+
 
   //! Functor to iterate a fixed number of days
   template<class date_type>
-  class day_functor 
+  class day_functor
   {
   public:
     typedef typename date_type::duration_type duration_type;
     day_functor(int f) : f_(f) {}
-    duration_type get_offset(const date_type& d) const 
+    duration_type get_offset(const date_type&) const
     {
-      // why is 'd' a parameter???
-      // fix compiler warnings
-      d.year();
       return duration_type(f_);
     }
-    duration_type get_neg_offset(const date_type& d) const 
+    duration_type get_neg_offset(const date_type&) const
     {
-      // fix compiler warnings
-      d.year();
       return duration_type(-f_);
     }
   private:
@@ -43,7 +38,7 @@ namespace date_time {
 
   //! Provides calculation to find next nth month given a date
   /*! This adjustment function provides the logic for 'month-based'
-   *  advancement on a ymd based calendar.  The policy it uses 
+   *  advancement on a ymd based calendar.  The policy it uses
    *  to handle the non existant end of month days is to back
    *  up to the last day of the month.  Also, if the starting
    *  date is the last day of a month, this functor will attempt
@@ -51,7 +46,7 @@ namespace date_time {
 
    */
   template<class date_type>
-  class month_functor 
+  class month_functor
   {
   public:
     typedef typename date_type::duration_type duration_type;
@@ -60,7 +55,7 @@ namespace date_time {
     typedef typename cal_type::day_type day_type;
 
     month_functor(int f) : f_(f), origDayOfMonth_(0) {}
-    duration_type get_offset(const date_type& d) const 
+    duration_type get_offset(const date_type& d) const
     {
       ymd_type ymd(d.year_month_day());
       if (origDayOfMonth_ == 0) {
@@ -71,11 +66,9 @@ namespace date_time {
         }
       }
       typedef date_time::wrapping_int2<short,1,12> wrap_int2;
-      typedef typename wrap_int2::int_type int_type;
       wrap_int2 wi(ymd.month);
       //calc the year wrap around, add() returns 0 or 1 if wrapped
-      int_type year = wi.add(static_cast<int_type>(f_)); 
-      year = static_cast<int_type>(year + ymd.year); //calculate resulting year
+      const typename ymd_type::year_type year(static_cast<typename ymd_type::year_type::value_type>(ymd.year + wi.add(f_)));
 //       std::cout << "trace wi: " << wi.as_int() << std::endl;
 //       std::cout << "trace year: " << year << std::endl;
       //find the last day for the new month
@@ -91,7 +84,7 @@ namespace date_time {
       return date_type(year, wi.as_int(), dayOfMonth) - d;
     }
     //! Returns a negative duration_type
-    duration_type get_neg_offset(const date_type& d) const 
+    duration_type get_neg_offset(const date_type& d) const
     {
       ymd_type ymd(d.year_month_day());
       if (origDayOfMonth_ == 0) {
@@ -102,11 +95,9 @@ namespace date_time {
         }
       }
       typedef date_time::wrapping_int2<short,1,12> wrap_int2;
-      typedef typename wrap_int2::int_type int_type;
       wrap_int2 wi(ymd.month);
       //calc the year wrap around, add() returns 0 or 1 if wrapped
-      int_type year = wi.subtract(static_cast<int_type>(f_)); 
-      year = static_cast<int_type>(year + ymd.year); //calculate resulting year
+      const typename ymd_type::year_type year(static_cast<typename ymd_type::year_type::value_type>(ymd.year + wi.subtract(f_)));
       //find the last day for the new month
       day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));
       //original was the end of month -- force to last day of month
@@ -127,24 +118,19 @@ namespace date_time {
 
   //! Functor to iterate a over weeks
   template<class date_type>
-  class week_functor 
+  class week_functor
   {
   public:
     typedef typename date_type::duration_type duration_type;
     typedef typename date_type::calendar_type calendar_type;
     week_functor(int f) : f_(f) {}
-    duration_type get_offset(const date_type& d) const 
+    duration_type get_offset(const date_type&) const
     {
-      // why is 'd' a parameter???
-      // fix compiler warnings
-      d.year();
-      return duration_type(f_*calendar_type::days_in_week());
+      return duration_type(f_*static_cast<int>(calendar_type::days_in_week()));
     }
-    duration_type get_neg_offset(const date_type& d) const 
+    duration_type get_neg_offset(const date_type&) const
     {
-      // fix compiler warnings
-      d.year();
-      return duration_type(-f_*calendar_type::days_in_week());
+      return duration_type(-f_*static_cast<int>(calendar_type::days_in_week()));
     }
   private:
     int f_;
@@ -152,17 +138,17 @@ namespace date_time {
 
   //! Functor to iterate by a year adjusting for leap years
   template<class date_type>
-  class year_functor 
+  class year_functor
   {
   public:
     //typedef typename date_type::year_type year_type;
     typedef typename date_type::duration_type duration_type;
     year_functor(int f) : _mf(f * 12) {}
-    duration_type get_offset(const date_type& d) const 
+    duration_type get_offset(const date_type& d) const
     {
       return _mf.get_offset(d);
     }
-    duration_type get_neg_offset(const date_type& d) const 
+    duration_type get_neg_offset(const date_type& d) const
     {
       return _mf.get_neg_offset(d);
     }
@@ -170,7 +156,7 @@ namespace date_time {
     month_functor<date_type> _mf;
   };
 
-  
+
 } }//namespace date_time
 
 

include/boost/date_time/c_local_time_adjustor.hpp

@@ -14,7 +14,10 @@
 */
 
 #include <stdexcept>
-#include "boost/date_time/c_time.hpp"
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/c_time.hpp>
+#include <boost/numeric/conversion/cast.hpp>
 
 namespace boost {
 namespace date_time {
@@ -35,14 +38,19 @@ namespace date_time {
       date_type time_t_start_day(1970,1,1);
       time_type time_t_start_time(time_t_start_day,time_duration_type(0,0,0));
       if (t < time_t_start_time) {
-        throw std::out_of_range("Cannot convert dates prior to Jan 1, 1970");
+        boost::throw_exception(std::out_of_range("Cannot convert dates prior to Jan 1, 1970"));
+        BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(return time_t_start_time); // should never reach
       }
       date_duration_type dd = t.date() - time_t_start_day;
       time_duration_type td = t.time_of_day();
-      std::time_t t2 = dd.days()*86400 + td.hours()*3600 + td.minutes()*60 + td.seconds();
+      uint64_t t2 = static_cast<uint64_t>(dd.days())*86400 +
+                    static_cast<uint64_t>(td.hours())*3600 +
+                    static_cast<uint64_t>(td.minutes())*60 +
+                    td.seconds();
+      // detect y2038 issue and throw instead of proceed with bad time
+      std::time_t tv = boost::numeric_cast<std::time_t>(t2);
       std::tm tms, *tms_ptr;
-      tms_ptr = c_time::localtime(&t2, &tms);
-      //tms_ptr = std::localtime(&t2);
+      tms_ptr = c_time::localtime(&tv, &tms);
       date_type d(static_cast<unsigned short>(tms_ptr->tm_year + 1900),
                   static_cast<unsigned short>(tms_ptr->tm_mon + 1),
                   static_cast<unsigned short>(tms_ptr->tm_mday));

include/boost/date_time/c_time.hpp

@@ -2,10 +2,10 @@
 #define DATE_TIME_C_TIME_HPP___
 
 /* Copyright (c) 2002,2003,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 
+ * Author: Jeff Garland, Bart Garst
  * $Date$
  */
 
@@ -14,10 +14,13 @@
   Provide workarounds related to the ctime header
 */
 
-#include "boost/date_time/compiler_config.hpp"
 #include <ctime>
-//Work around libraries that don't put time_t and time in namespace std
+#include <string> // to be able to convert from string literals to exceptions
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/compiler_config.hpp>
 
+//Work around libraries that don't put time_t and time in namespace std
 #ifdef BOOST_NO_STDC_NAMESPACE
 namespace std { using ::time_t; using ::time; using ::localtime;
                 using ::tm;  using ::gmtime; }
@@ -35,12 +38,17 @@ namespace std { using ::time_t; using ::time; using ::localtime;
 namespace boost {
 namespace date_time {
   //! Provides a uniform interface to some 'ctime' functions
-  /*! Provides a uniform interface to some ctime functions and 
-   * their '_r' counterparts. The '_r' functions require a pointer to a 
-   * user created std::tm struct whereas the regular functions use a 
-   * staticly created struct and return a pointer to that. These wrapper 
-   * functions require the user to create a std::tm struct and send in a 
-   * pointer to it. A pointer to the user created struct will be returned. */
+  /*! Provides a uniform interface to some ctime functions and
+   * their '_r' counterparts. The '_r' functions require a pointer to a
+   * user created std::tm struct whereas the regular functions use a
+   * staticly created struct and return a pointer to that. These wrapper
+   * functions require the user to create a std::tm struct and send in a
+   * pointer to it. This struct may be used to store the resulting time.
+   * The returned pointer may or may not point to this struct, however,
+   * it will point to the result of the corresponding function.
+   * All functions do proper checking of the C function results and throw
+   * exceptions on error. Therefore the functions will never return NULL.
+   */
   struct c_time {
     public:
 #if defined(BOOST_DATE_TIME_HAS_REENTRANT_STD_FUNCTIONS)
@@ -49,7 +57,17 @@ namespace date_time {
       static std::tm* localtime(const std::time_t* t, std::tm* result)
       {
         // localtime_r() not in namespace std???
+#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64
+        std::tm tmp;
+        if(!localtime_r(t,&tmp))
+            result = 0;
+        else
+            *result = tmp;
+#else
         result = localtime_r(t, result);
+#endif
+        if (!result)
+          boost::throw_exception(std::runtime_error("could not convert calendar time to local time"));
         return result;
       }
       //! requires a pointer to a user created std::tm struct
@@ -57,20 +75,35 @@ namespace date_time {
       static std::tm* gmtime(const std::time_t* t, std::tm* result)
       {
         // gmtime_r() not in namespace std???
+#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64
+        std::tm tmp;
+        if(!gmtime_r(t,&tmp))
+          result = 0;
+        else
+          *result = tmp;
+#else
         result = gmtime_r(t, result);
+#endif
+        if (!result)
+          boost::throw_exception(std::runtime_error("could not convert calendar time to UTC time"));
         return result;
       }
-#else // BOOST_HAS_THREADS
+#else // BOOST_DATE_TIME_HAS_REENTRANT_STD_FUNCTIONS
 
-#if (defined(_MSC_VER) && (_MSC_VER >= 1400))
+#if defined(__clang__) // Clang has to be checked before MSVC
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#elif (defined(_MSC_VER) && (_MSC_VER >= 1400))
 #pragma warning(push) // preserve warning settings
 #pragma warning(disable : 4996) // disable depricated localtime/gmtime warning on vc8
-#endif // _MSC_VER >= 1400
+#endif
       //! requires a pointer to a user created std::tm struct
       inline
       static std::tm* localtime(const std::time_t* t, std::tm* result)
       {
         result = std::localtime(t);
+        if (!result)
+          boost::throw_exception(std::runtime_error("could not convert calendar time to local time"));
         return result;
       }
       //! requires a pointer to a user created std::tm struct
@@ -78,14 +111,18 @@ namespace date_time {
       static std::tm* gmtime(const std::time_t* t, std::tm* result)
       {
         result = std::gmtime(t);
+        if (!result)
+          boost::throw_exception(std::runtime_error("could not convert calendar time to UTC time"));
         return result;
       }
-#if (defined(_MSC_VER) && (_MSC_VER >= 1400))
+#if defined(__clang__) // Clang has to be checked before MSVC
+#pragma clang diagnostic pop
+#elif (defined(_MSC_VER) && (_MSC_VER >= 1400))
 #pragma warning(pop) // restore warnings to previous state
-#endif // _MSC_VER >= 1400
+#endif
 
-#endif // BOOST_HAS_THREADS
+#endif // BOOST_DATE_TIME_HAS_REENTRANT_STD_FUNCTIONS
   };
 }} // namespaces
-                
+
 #endif // DATE_TIME_C_TIME_HPP___

include/boost/date_time/compiler_config.hpp

@@ -8,25 +8,14 @@
  * $Date$
  */
 
- #include "boost/detail/workaround.hpp"
-
-// With boost release 1.33, date_time will be using a different,
-// more flexible, IO system. This new system is not compatible with
-// old compilers. The original date_time IO system remains for those
-// compilers. They must define this macro to use the legacy IO.
-//     (defined(__BORLANDC__) && (__BORLANDC__ <= 0x0581) ) )   &&
- #if(  BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) ) \
-    || BOOST_WORKAROUND( __GNUC__, < 3)                         \
-    || (BOOST_WORKAROUND( _MSC_VER, <= 1300) )                  \
-    )                                                           \
-    && !defined(USE_DATE_TIME_PRE_1_33_FACET_IO)
-# define USE_DATE_TIME_PRE_1_33_FACET_IO
-#endif
+#include <cstdlib>
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
 
 
 // This file performs some local compiler configurations
 
-#include "boost/date_time/locale_config.hpp" //set up locale configurations
+#include <boost/date_time/locale_config.hpp> //set up locale configurations
 
 //Set up a configuration parameter for platforms that have 
 //GetTimeOfDay
@@ -39,17 +28,13 @@
 
 // Include extensions to date_duration - comment out to remove this feature
 #define BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES
-// these extensions are known to cause problems with gcc295
-#if defined(__GNUC__) && (__GNUC__ < 3)
-#undef BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES
-#endif
 
-#if (defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) || BOOST_WORKAROUND( __BORLANDC__,  BOOST_TESTED_AT(0x581) ) )
+#if (defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) || BOOST_WORKAROUND( BOOST_BORLANDC,  BOOST_TESTED_AT(0x581) ) )
 #define BOOST_DATE_TIME_NO_MEMBER_INIT
 #endif
 
 // include these types before we try to re-define them
-#include "boost/cstdint.hpp"
+#include <boost/cstdint.hpp>
 
 //Define INT64_C for compilers that don't have it
 #if (!defined(INT64_C))
@@ -58,13 +43,13 @@
 
 
 /* Workaround for Borland iterator error. Error was "Cannot convert 'istream *' to 'wistream *' in function istream_iterator<>::istream_iterator() */
-#if defined(__BORLANDC__) && defined(BOOST_BCB_WITH_RW_LIB)
+#if defined(BOOST_BORLANDC) && defined(BOOST_BCB_WITH_RW_LIB)
 #define BOOST_DATE_TIME_NO_WISTREAM_ITERATOR
 #endif
 
 
 // Borland v5.64 does not have the following in std namespace; v5.5.1 does
-#if defined(__BORLANDC__) && defined(BOOST_BCB_WITH_STLPORT)
+#if defined(BOOST_BORLANDC) && defined(BOOST_BCB_WITH_STLPORT)
 #include <locale>
 namespace std {
   using stlport::tolower;
@@ -81,61 +66,59 @@ namespace std {
 #if (((defined(__GNUC__) && (__GNUC__ < 3)) || \
       (defined(_MSC_VER) && (_MSC_VER < 1300)) ) && \
       !defined(_STLP_OWN_IOSTREAMS) ) || \
-      BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
+      BOOST_WORKAROUND( BOOST_BORLANDC, BOOST_TESTED_AT(0x581) )
 #define BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS
 #endif
 
+// The macro marks up places where compiler complains for missing return statement or
+// uninitialized variables after calling to boost::throw_exception.
+// BOOST_UNREACHABLE_RETURN doesn't work since even compilers that support
+// unreachable statements detection emit such warnings.
+#if defined(_MSC_VER)
+// Use special MSVC extension to markup unreachable code
+#  define BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(x) __assume(false)
+#elif !defined(BOOST_NO_UNREACHABLE_RETURN_DETECTION)
+// Call to a non-returning function should suppress the warning
+#  if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std {
+    using ::abort;
+}
+#  endif // defined(BOOST_NO_STDC_NAMESPACE)
+#  define BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(x) std::abort()
+#else
+// For other poor compilers the specified expression is compiled. Usually, this would be a return statement.
+#  define BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(x) x
+#endif
+
 /* The following handles the definition of the necessary macros
  * for dll building on Win32 platforms.
  * 
  * For code that will be placed in the date_time .dll, 
  * it must be properly prefixed with BOOST_DATE_TIME_DECL.
- * The corresponding .cpp file must have BOOST_DATE_TIME_SOURCES
+ * The corresponding .cpp file must have BOOST_DATE_TIME_SOURCE
  * defined before including its header. For examples see:
  * greg_month.hpp & greg_month.cpp
  * 
  */
 
-#ifdef BOOST_HAS_DECLSPEC // defined in config system
-   // we need to import/export our code only if the user has specifically
-   // asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
-   // libraries to be dynamically linked, or BOOST_DATE_TIME_DYN_LINK
-   // if they want just this one to be dynamically liked:
-#  if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_DATE_TIME_DYN_LINK)
-      // export if this is our own source, otherwise import:
-#     ifdef BOOST_DATE_TIME_SOURCE
-#       define BOOST_DATE_TIME_DECL __declspec(dllexport)
-#     else
-#       define BOOST_DATE_TIME_DECL __declspec(dllimport)
-#     endif  // BOOST_DATE_TIME_SOURCE
-#  endif  // DYN_LINK
-#endif  // BOOST_HAS_DECLSPEC
+// we need to import/export our code only if the user has specifically
+// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
+// libraries to be dynamically linked, or BOOST_DATE_TIME_DYN_LINK
+// if they want just this one to be dynamically liked:
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_DATE_TIME_DYN_LINK)
+    // export if this is our own source, otherwise import:
+#   ifdef BOOST_DATE_TIME_SOURCE
+#     define BOOST_DATE_TIME_DECL BOOST_SYMBOL_EXPORT
+#   else
+#     define BOOST_DATE_TIME_DECL BOOST_SYMBOL_IMPORT
+#   endif  // BOOST_DATE_TIME_SOURCE
+#endif  // DYN_LINK
 //
 // if BOOST_WHATEVER_DECL isn't defined yet define it now:
 #ifndef BOOST_DATE_TIME_DECL
 #  define BOOST_DATE_TIME_DECL
 #endif
 
-//
-// Automatically link to the correct build variant where possible. 
-// 
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_DATE_TIME_NO_LIB) && !defined(BOOST_DATE_TIME_SOURCE)
-//
-// Set the name of our library, this will get undef'ed by auto_link.hpp
-// once it's done with it:
-//
-#define BOOST_LIB_NAME boost_date_time
-//
-// If we're importing code from a dll, then tell auto_link.hpp about it:
-//
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_DATE_TIME_DYN_LINK)
-#  define BOOST_DYN_LINK
-#endif
-//
-// And include the header that does the work:
-//
-#include <boost/config/auto_link.hpp>
-#endif  // auto-linking disabled
 
 #if defined(BOOST_HAS_THREADS) 
 #  if defined(_MSC_VER) || defined(__MWERKS__) || defined(__MINGW32__) ||  defined(__BORLANDC__)
@@ -145,5 +128,10 @@ namespace std {
 #  endif
 #endif
 
+#if defined(BOOST_NO_CXX11_NULLPTR)
+#  define BOOST_DATE_TIME_NULLPTR 0
+#else
+#  define BOOST_DATE_TIME_NULLPTR nullptr
+#endif
 
 #endif

include/boost/date_time/constrained_value.hpp

@@ -9,7 +9,12 @@
  * $Date$
  */
 
+#include <exception>
+#include <stdexcept>
 #include <boost/config.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/type_traits/is_base_of.hpp>
 
 namespace boost {
 
@@ -34,29 +39,33 @@ namespace CV {
    *
    */
   template<class value_policies>
-  class constrained_value {
+  class BOOST_SYMBOL_VISIBLE constrained_value {
   public:
     typedef typename value_policies::value_type value_type;
     //    typedef except_type exception_type;
-    constrained_value(value_type value) 
+    BOOST_CXX14_CONSTEXPR constrained_value(value_type value) : value_((min)())
     {
       assign(value);
-    };
-    constrained_value& operator=(value_type v) 
-    { 
+    }
+    BOOST_CXX14_CONSTEXPR constrained_value& operator=(value_type v)
+    {
       assign(v); 
       return *this;
-    }   
+    }
     //! Return the max allowed value (traits method)
-    static value_type max BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::max)();};
+    static BOOST_CONSTEXPR value_type
+    max BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::max)();}
+
     //! Return the min allowed value (traits method)
-    static value_type min BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::min)();};
+    static BOOST_CONSTEXPR value_type
+    min BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::min)();}
+
     //! Coerce into the representation type
-    operator value_type() const {return value_;};
+    BOOST_CXX14_CONSTEXPR operator value_type() const {return value_;}
   protected:
     value_type value_;
   private:
-    void assign(value_type value)
+    BOOST_CXX14_CONSTEXPR void assign(value_type value)
     {
       //adding 1 below gets rid of a compiler warning which occurs when the 
       //min_value is 0 and the type is unsigned....
@@ -69,22 +78,44 @@ namespace CV {
         return;
       }
       value_ = value;
-
     }
 };
 
   //! Template to shortcut the constrained_value policy creation process
   template<typename rep_type, rep_type min_value, 
            rep_type max_value, class exception_type>
-  class simple_exception_policy
+  class BOOST_SYMBOL_VISIBLE simple_exception_policy
   {
+    struct BOOST_SYMBOL_VISIBLE exception_wrapper : public exception_type
+    {
+      // In order to support throw_exception mechanism in the BOOST_NO_EXCEPTIONS mode,
+      // we'll have to provide a way to acquire std::exception from the exception being thrown.
+      // However, we cannot derive from it, since it would make it interceptable by this class,
+      // which might not be what the user wanted.
+      operator std::out_of_range () const
+      {
+        // TODO: Make the message more descriptive by using arguments to on_error
+        return std::out_of_range("constrained value boundary has been violated");
+      }
+    };
+
+    typedef typename conditional<
+      is_base_of< std::exception, exception_type >::value,
+      exception_type,
+      exception_wrapper
+    >::type actual_exception_type;
+
   public:
     typedef rep_type value_type;
-    static rep_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return min_value; };
-    static rep_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return max_value;};
+    static BOOST_CONSTEXPR rep_type
+    min BOOST_PREVENT_MACRO_SUBSTITUTION () { return min_value; }
+
+    static BOOST_CONSTEXPR rep_type
+    max BOOST_PREVENT_MACRO_SUBSTITUTION () { return max_value; }
+
     static void on_error(rep_type, rep_type, violation_enum)
     {
-      throw exception_type();
+      boost::throw_exception(actual_exception_type());
     }
   };
 

include/boost/date_time/date.hpp

@@ -2,43 +2,44 @@
 #define DATE_TIME_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, Bart Garst
  * $Date$
  */
 
-#include "boost/date_time/year_month_day.hpp"
-#include "boost/date_time/special_defs.hpp"
-#include "boost/operators.hpp"
+#include <boost/operators.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/year_month_day.hpp>
+#include <boost/date_time/special_defs.hpp>
 
 namespace boost {
 namespace date_time {
 
   //!Representation of timepoint at the one day level resolution.
-  /*! 
+  /*!
     The date template represents an interface shell for a date class
     that is based on a year-month-day system such as the gregorian
-    or iso systems.  It provides basic operations to enable calculation
-    and comparisons.  
+    or ISO 8601 systems.  It provides basic operations to enable calculation
+    and comparisons.
 
     <b>Theory</b>
 
-    This date representation fundamentally departs from the C tm struct 
+    This date representation fundamentally departs from the C tm struct
     approach.  The goal for this type is to provide efficient date
     operations (add, subtract) and storage (minimize space to represent)
     in a concrete class.  Thus, the date uses a count internally to
-    represent a particular date.  The calendar parameter defines 
+    represent a particular date.  The calendar parameter defines
     the policies for converting the the year-month-day and internal
     counted form here.  Applications that need to perform heavy
     formatting of the same date repeatedly will perform better
     by using the year-month-day representation.
-    
+
     Internally the date uses a day number to represent the date.
-    This is a monotonic time representation. This representation 
+    This is a monotonic time representation. This representation
     allows for fast comparison as well as simplifying
-    the creation of writing numeric operations.  Essentially, the 
+    the creation of writing numeric operations.  Essentially, the
     internal day number is like adjusted julian day.  The adjustment
     is determined by the Epoch date which is represented as day 1 of
     the calendar.  Day 0 is reserved for negative infinity so that
@@ -48,11 +49,11 @@ namespace date_time {
     day representations.
   */
 
-  
-  template<class T, class calendar, class duration_type_> 
-  class date : private 
-       boost::less_than_comparable<T 
-     , boost::equality_comparable<T 
+
+  template<class T, class calendar, class duration_type_>
+  class BOOST_SYMBOL_VISIBLE date : private
+       boost::less_than_comparable<T
+     , boost::equality_comparable<T
     > >
   {
   public:
@@ -67,128 +68,139 @@ namespace date_time {
     typedef typename calendar::date_rep_type date_rep_type;
     typedef typename calendar::date_int_type date_int_type;
     typedef typename calendar::day_of_week_type day_of_week_type;
-    date(year_type y, month_type m, day_type d) 
+    BOOST_CXX14_CONSTEXPR date(year_type y, month_type m, day_type d)
       : days_(calendar::day_number(ymd_type(y, m, d)))
     {}
-    date(const ymd_type& ymd) 
+    BOOST_CXX14_CONSTEXPR date(const ymd_type& ymd)
       : days_(calendar::day_number(ymd))
-      {}
+    {}
     //let the compiler write copy, assignment, and destructor
-    year_type        year() const
+    BOOST_CXX14_CONSTEXPR year_type        year() const
     {
-      ymd_type ymd = calendar::from_day_number(days_); 
+      ymd_type ymd = calendar::from_day_number(days_);
       return ymd.year;
     }
-    month_type       month() const
+    BOOST_CXX14_CONSTEXPR month_type       month() const
     {
-      ymd_type ymd = calendar::from_day_number(days_); 
+      ymd_type ymd = calendar::from_day_number(days_);
       return ymd.month;
     }
-    day_type         day() const
+    BOOST_CXX14_CONSTEXPR day_type         day() const
     {
-      ymd_type ymd = calendar::from_day_number(days_); 
+      ymd_type ymd = calendar::from_day_number(days_);
       return ymd.day;
     }
-    day_of_week_type day_of_week() const
+    BOOST_CXX14_CONSTEXPR day_of_week_type day_of_week() const
     {
       ymd_type ymd = calendar::from_day_number(days_);
       return calendar::day_of_week(ymd);
     }
-    ymd_type         year_month_day() const
+    BOOST_CXX14_CONSTEXPR ymd_type         year_month_day() const
     {
       return calendar::from_day_number(days_);
     }
-    bool operator<(const date_type& rhs)  const
+    BOOST_CONSTEXPR bool operator<(const date_type& rhs)  const
     {
       return days_ < rhs.days_;
     }
-    bool operator==(const date_type& rhs) const
+    BOOST_CONSTEXPR bool operator==(const date_type& rhs) const
     {
       return days_ == rhs.days_;
     }
     //! check to see if date is a special value
-    bool is_special()const
+    BOOST_CONSTEXPR bool is_special()const
     {
       return(is_not_a_date() || is_infinity());
     }
     //! check to see if date is not a value
-    bool is_not_a_date()  const
+    BOOST_CONSTEXPR bool is_not_a_date()  const
     {
       return traits_type::is_not_a_number(days_);
     }
     //! check to see if date is one of the infinity values
-    bool is_infinity()  const
+    BOOST_CONSTEXPR bool is_infinity()  const
     {
       return traits_type::is_inf(days_);
     }
     //! check to see if date is greater than all possible dates
-    bool is_pos_infinity()  const
+    BOOST_CONSTEXPR bool is_pos_infinity()  const
     {
       return traits_type::is_pos_inf(days_);
     }
     //! check to see if date is greater than all possible dates
-    bool is_neg_infinity()  const
+    BOOST_CONSTEXPR bool is_neg_infinity()  const
     {
       return traits_type::is_neg_inf(days_);
     }
     //! return as a special value or a not_special if a normal date
-    special_values as_special()  const
+    BOOST_CXX14_CONSTEXPR special_values as_special()  const
     {
       return traits_type::to_special(days_);
     }
-    duration_type operator-(const date_type& d) const
+    BOOST_CXX14_CONSTEXPR duration_type operator-(const date_type& d) const
     {
-      date_rep_type val = date_rep_type(days_) - date_rep_type(d.days_);
-      return duration_type(val.as_number());
+      if (!this->is_special() && !d.is_special())
+      {
+        // The duration underlying type may be wider than the date underlying type.
+        // Thus we calculate the difference in terms of two durations from some common fixed base date.
+        typedef typename duration_type::duration_rep_type duration_rep_type;
+        return duration_type(static_cast< duration_rep_type >(days_) - static_cast< duration_rep_type >(d.days_));
+      }
+      else
+      {
+        // In this case the difference will be a special value, too
+        date_rep_type val = date_rep_type(days_) - date_rep_type(d.days_);
+        return duration_type(val.as_special());
+      }
     }
-    
-    date_type operator-(const duration_type& dd) const
+
+    BOOST_CXX14_CONSTEXPR date_type operator-(const duration_type& dd) const
     {
       if(dd.is_special())
       {
         return date_type(date_rep_type(days_) - dd.get_rep());
       }
-      return date_type(date_rep_type(days_) - dd.days());
+      return date_type(date_rep_type(days_) - static_cast<date_int_type>(dd.days()));
     }
-    date_type operator-=(const duration_type& dd)
+    BOOST_CXX14_CONSTEXPR date_type operator-=(const duration_type& dd)
     {
       *this = *this - dd;
       return date_type(days_);
     }
-    date_rep_type day_count() const 
+    BOOST_CONSTEXPR date_rep_type day_count() const
     {
       return days_;
-    };
+    }
     //allow internal access from operators
-    date_type operator+(const duration_type& dd) const
+    BOOST_CXX14_CONSTEXPR date_type operator+(const duration_type& dd) const
     {
       if(dd.is_special())
       {
         return date_type(date_rep_type(days_) + dd.get_rep());
       }
-      return date_type(date_rep_type(days_) + dd.days());
+      return date_type(date_rep_type(days_) + static_cast<date_int_type>(dd.days()));
     }
-    date_type operator+=(const duration_type& dd)
+    BOOST_CXX14_CONSTEXPR date_type operator+=(const duration_type& dd)
     {
-      *this = *this + dd; 
+      *this = *this + dd;
       return date_type(days_);
     }
 
     //see reference
   protected:
-    /*! This is a private constructor which allows for the creation of new 
-      dates.  It is not exposed to users since that would require class 
+    /*! This is a private constructor which allows for the creation of new
+      dates.  It is not exposed to users since that would require class
       users to understand the inner workings of the date class.
     */
-    explicit date(date_int_type days) : days_(days) {};
-    explicit date(date_rep_type days) : days_(days.as_number()) {};
+    BOOST_CONSTEXPR explicit date(date_int_type days) : days_(days) {}
+    BOOST_CXX14_CONSTEXPR explicit date(date_rep_type days) : days_(days.as_number()) {}
     date_int_type days_;
-    
+
   };
 
 
 
-  
+
 } } // namespace date_time
 
 

include/boost/date_time/date_clock_device.hpp

@@ -36,18 +36,18 @@ namespace date_time {
     {
       ::std::tm result;
       ::std::tm* curr = get_local_time(result);
-      return ymd_type(curr->tm_year + 1900, 
-                      curr->tm_mon + 1, 
-                      curr->tm_mday);
+      return ymd_type(static_cast<unsigned short>(curr->tm_year + 1900),
+                      static_cast<unsigned short>(curr->tm_mon + 1),
+                      static_cast<unsigned short>(curr->tm_mday));
     }
     //! Get the current day in universal date as a ymd_type
     static typename date_type::ymd_type universal_day_ymd() 
     {
       ::std::tm result;
       ::std::tm* curr = get_universal_time(result);
-      return ymd_type(curr->tm_year + 1900, 
-                      curr->tm_mon + 1, 
-                      curr->tm_mday);
+      return ymd_type(static_cast<unsigned short>(curr->tm_year + 1900),
+                      static_cast<unsigned short>(curr->tm_mon + 1),
+                      static_cast<unsigned short>(curr->tm_mday));
     }
     //! Get the UTC day as a date type
     static date_type universal_day() 

include/boost/date_time/date_duration.hpp

@@ -2,7 +2,7 @@
 #define DATE_TIME_DATE_DURATION__
 
 /* 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
@@ -11,6 +11,9 @@
 
 
 #include <boost/operators.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/int_adapter.hpp>
 
 namespace boost {
 namespace date_time {
@@ -18,58 +21,57 @@ namespace date_time {
 
   //! Duration type with date level resolution
   template<class duration_rep_traits>
-  class date_duration : private
-              boost::less_than_comparable<date_duration< duration_rep_traits>
-            , boost::equality_comparable< date_duration< duration_rep_traits>
-            , boost::addable< date_duration< duration_rep_traits>
-            , boost::subtractable< date_duration< duration_rep_traits>
-            > > > >
-  { 
+  class BOOST_SYMBOL_VISIBLE date_duration : private
+              boost::less_than_comparable1< date_duration< duration_rep_traits >
+            , boost::equality_comparable1< date_duration< duration_rep_traits >
+            , boost::addable1< date_duration< duration_rep_traits >
+            , boost::subtractable1< date_duration< duration_rep_traits >
+            , boost::dividable2< date_duration< duration_rep_traits >, int
+            > > > > >
+  {
   public:
     typedef typename duration_rep_traits::int_type duration_rep_type;
     typedef typename duration_rep_traits::impl_type duration_rep;
-    
+
     //! Construct from a day count
-    explicit date_duration(duration_rep day_count) : days_(day_count) {};
-    
+    BOOST_CXX14_CONSTEXPR explicit date_duration(duration_rep day_count) : days_(day_count) {}
+
     /*! construct from special_values - only works when
      * instantiated with duration_traits_adapted */
-    date_duration(special_values sv) :
+    BOOST_CXX14_CONSTEXPR date_duration(special_values sv) :
             days_(duration_rep::from_special(sv))
     {}
 
-    // copy constructor required for addable<> & subtractable<>
-    //! Construct from another date_duration (Copy Constructor)
-    date_duration(const date_duration<duration_rep_traits>& other) :
-            days_(other.days_)
-    {}
-
     //! returns days_ as it's instantiated type - used for streaming
-    duration_rep get_rep()const
+    BOOST_CXX14_CONSTEXPR duration_rep get_rep()const
     {
         return days_;
     }
-    bool is_special()const
+    BOOST_CXX14_CONSTEXPR special_values as_special() const
+    {
+        return days_.as_special();
+    }
+    BOOST_CXX14_CONSTEXPR bool is_special()const
     {
         return days_.is_special();
     }
     //! returns days as value, not object.
-    duration_rep_type days() const
+    BOOST_CXX14_CONSTEXPR duration_rep_type days() const
     {
         return duration_rep_traits::as_number(days_);
     }
     //! Returns the smallest duration -- used by to calculate 'end'
-    static date_duration unit()
+    static BOOST_CXX14_CONSTEXPR date_duration unit()
     {
         return date_duration<duration_rep_traits>(1);
     }
     //! Equality
-    bool operator==(const date_duration& rhs) const
+    BOOST_CXX14_CONSTEXPR bool operator==(const date_duration& rhs) const
     {
         return days_ == rhs.days_;
     }
     //! Less
-    bool operator<(const date_duration& rhs) const
+    BOOST_CXX14_CONSTEXPR bool operator<(const date_duration& rhs) const
     {
         return days_ < rhs.days_;
     }
@@ -80,40 +82,37 @@ namespace date_time {
      * so this will not compile */
 
     //! Subtract another duration -- result is signed
-    date_duration operator-=(const date_duration& rhs)
+    BOOST_CXX14_CONSTEXPR date_duration& operator-=(const date_duration& rhs)
     {
         //days_ -= rhs.days_;
         days_ = days_ - rhs.days_;
         return *this;
     }
     //! Add a duration -- result is signed
-    date_duration operator+=(const date_duration& rhs)
+    BOOST_CXX14_CONSTEXPR date_duration& operator+=(const date_duration& rhs)
     {
         days_ = days_ + rhs.days_;
         return *this;
     }
 
     //! unary- Allows for dd = -date_duration(2); -> dd == -2
-    date_duration operator-()const
+    BOOST_CXX14_CONSTEXPR date_duration operator-() const
     {
         return date_duration<duration_rep_traits>(get_rep() * (-1));
     }
     //! Division operations on a duration with an integer.
-    date_duration<duration_rep_traits> operator/=(int divisor)
+    BOOST_CXX14_CONSTEXPR date_duration& operator/=(int divisor)
     {
         days_ = days_ / divisor;
         return *this;
     }
-    date_duration<duration_rep_traits> operator/(int divisor)
-    {
-        return date_duration<duration_rep_traits>(days_ / divisor);
-    }
 
     //! return sign information
-    bool is_negative() const
+    BOOST_CXX14_CONSTEXPR bool is_negative() const
     {
         return days_ < 0;
     }
+
   private:
     duration_rep days_;
   };
@@ -122,23 +121,23 @@ namespace date_time {
   /*! Struct for instantiating date_duration with <b>NO</b> special values
    * functionality. Allows for transparent implementation of either
    * date_duration<long> or date_duration<int_adapter<long> > */
-  struct duration_traits_long
+  struct BOOST_SYMBOL_VISIBLE duration_traits_long
   {
     typedef long int_type;
     typedef long impl_type;
-    static int_type as_number(impl_type i) { return i; };
+    static BOOST_CXX14_CONSTEXPR int_type as_number(impl_type i) { return i; }
   };
 
   /*! Struct for instantiating date_duration <b>WITH</b> special values
    * functionality. Allows for transparent implementation of either
    * date_duration<long> or date_duration<int_adapter<long> > */
-  struct duration_traits_adapted
+  struct BOOST_SYMBOL_VISIBLE duration_traits_adapted
   {
     typedef long int_type;
     typedef boost::date_time::int_adapter<long> impl_type;
-    static int_type as_number(impl_type i) { return i.as_number(); };
+    static BOOST_CXX14_CONSTEXPR int_type as_number(impl_type i) { return i.as_number(); }
   };
-  
+
 
 } } //namspace date_time
 

include/boost/date_time/date_duration_types.hpp

@@ -8,7 +8,8 @@
  * Author: Jeff Garland, Bart Garst
  * $Date$
  */
-                                                                                
+
+#include <boost/date_time/compiler_config.hpp>
 #include <boost/date_time/int_adapter.hpp>
 #include <boost/date_time/special_defs.hpp>
 #include <boost/date_time/date_duration.hpp>
@@ -19,17 +20,17 @@ namespace date_time {
 
   //! Additional duration type that represents a number of n*7 days
   template <class duration_config>
-  class weeks_duration : public date_duration<duration_config> {
+  class BOOST_SYMBOL_VISIBLE weeks_duration : public date_duration<duration_config> {
   public:
-    weeks_duration(typename duration_config::impl_type w) 
+    BOOST_CXX14_CONSTEXPR weeks_duration(typename duration_config::impl_type w) 
       : date_duration<duration_config>(w * 7) {}
-    weeks_duration(special_values sv) 
+    BOOST_CXX14_CONSTEXPR weeks_duration(special_values sv) 
       : date_duration<duration_config>(sv) {}
   };
 
   // predeclare
   template<class t>
-  class years_duration;
+  class BOOST_SYMBOL_VISIBLE years_duration;
 
   //! additional duration type that represents a logical month
   /*! A logical month enables things like: "date(2002,Mar,2) + months(2) -> 
@@ -37,7 +38,7 @@ namespace date_time {
    * also be a last-day-of-the-month.
    */
   template<class base_config>
-  class months_duration 
+  class BOOST_SYMBOL_VISIBLE months_duration
   {
     private:
       typedef typename base_config::int_rep int_rep;
@@ -48,106 +49,104 @@ namespace date_time {
       typedef months_duration<base_config> months_type;
       typedef years_duration<base_config> years_type;
     public:
-      months_duration(int_rep num) : _m(num) {}
-      months_duration(special_values sv) : _m(sv) 
+      BOOST_CXX14_CONSTEXPR months_duration(int_rep num) : _m(num) {}
+      BOOST_CXX14_CONSTEXPR months_duration(special_values sv) : _m(sv) 
       {
         _m = int_rep::from_special(sv);
       }
       int_rep number_of_months() const { return _m; }
       //! returns a negative duration
-      duration_type get_neg_offset(const date_type& d) const
+      BOOST_CXX14_CONSTEXPR duration_type get_neg_offset(const date_type& d) const
       {
         month_adjustor_type m_adj(_m.as_number());
         return duration_type(m_adj.get_neg_offset(d));
       }
-      duration_type get_offset(const date_type& d) const
+      BOOST_CXX14_CONSTEXPR duration_type get_offset(const date_type& d) const
       {
         month_adjustor_type m_adj(_m.as_number());
         return duration_type(m_adj.get_offset(d));
       }
-      bool operator==(const months_type& rhs) const
+      BOOST_CONSTEXPR bool operator==(const months_type& rhs) const
       {
         return(_m == rhs._m);
       }
-      bool operator!=(const months_type& rhs) const
+      BOOST_CONSTEXPR bool operator!=(const months_type& rhs) const
       {
         return(_m != rhs._m);
       }
-      months_type operator+(const months_type& rhs)const
+      BOOST_CXX14_CONSTEXPR months_type operator+(const months_type& rhs)const
       {
         return months_type(_m + rhs._m);
       }
-      months_type& operator+=(const months_type& rhs)
+      BOOST_CXX14_CONSTEXPR months_type& operator+=(const months_type& rhs)
       {
         _m = _m + rhs._m;
         return *this;
       }
-      months_type operator-(const months_type& rhs)const
+      BOOST_CXX14_CONSTEXPR months_type operator-(const months_type& rhs)const
       {
         return months_type(_m - rhs._m);
       }
-      months_type& operator-=(const months_type& rhs)
+      BOOST_CXX14_CONSTEXPR months_type& operator-=(const months_type& rhs)
       {
         _m = _m - rhs._m;
         return *this;
       }
-      months_type operator*(const int_type rhs)const
+      BOOST_CXX14_CONSTEXPR months_type operator*(const int_type rhs)const
       {
         return months_type(_m * rhs);
       }
-      months_type& operator*=(const int_type rhs)
+      BOOST_CXX14_CONSTEXPR months_type& operator*=(const int_type rhs)
       {
         _m = _m * rhs;
         return *this;
       }
-      months_type operator/(const int_type rhs)const
+      BOOST_CXX14_CONSTEXPR months_type operator/(const int_type rhs)const
       {
         return months_type(_m / rhs);
       }
-      months_type& operator/=(const int_type rhs)
+      BOOST_CXX14_CONSTEXPR months_type& operator/=(const int_type rhs)
       {
         _m = _m / rhs;
         return *this;
       }
-      months_type operator+(const years_type& y)const
+      BOOST_CXX14_CONSTEXPR months_type operator+(const years_type& y)const
       {
         return months_type(y.number_of_years() * 12 + _m);
       }
-      months_type& operator+=(const years_type& y)
+      BOOST_CXX14_CONSTEXPR months_type& operator+=(const years_type& y)
       {
         _m = y.number_of_years() * 12 + _m;
         return *this;
       }
-      months_type operator-(const years_type& y) const
+      BOOST_CXX14_CONSTEXPR months_type operator-(const years_type& y) const
       {
         return months_type(_m - y.number_of_years() * 12);
       }
-      months_type& operator-=(const years_type& y)
+      BOOST_CXX14_CONSTEXPR months_type& operator-=(const years_type& y)
       {
         _m = _m - y.number_of_years() * 12;
         return *this;
       }
-
       //
-      friend date_type operator+(const date_type& d, const months_type& m)
+      BOOST_CXX14_CONSTEXPR friend date_type operator+(const date_type& d, const months_type& m)
       {
         return d + m.get_offset(d);
       }
-      friend date_type operator+=(date_type& d, const months_type& m)
+      BOOST_CXX14_CONSTEXPR friend date_type operator+=(date_type& d, const months_type& m)
       {
         return d += m.get_offset(d);
       }
-      friend date_type operator-(const date_type& d, const months_type& m)
+      BOOST_CXX14_CONSTEXPR friend date_type operator-(const date_type& d, const months_type& m)
       {
         // get_neg_offset returns a negative duration, so we add
         return d + m.get_neg_offset(d);
       }
-      friend date_type operator-=(date_type& d, const months_type& m)
+      BOOST_CXX14_CONSTEXPR friend date_type operator-=(date_type& d, const months_type& m)
       {
         // get_neg_offset returns a negative duration, so we add
         return d += m.get_neg_offset(d);
       }
-        
     private:
       int_rep _m;
   };
@@ -159,7 +158,7 @@ namespace date_time {
    * 2004-Feb-29).
    */
   template<class base_config>
-  class years_duration 
+  class BOOST_SYMBOL_VISIBLE years_duration
   {
     private:
       typedef typename base_config::int_rep int_rep;
@@ -170,24 +169,24 @@ namespace date_time {
       typedef years_duration<base_config> years_type;
       typedef months_duration<base_config> months_type;
     public:
-      years_duration(int_rep num) : _y(num) {}
-      years_duration(special_values sv) : _y(sv) 
+      BOOST_CXX14_CONSTEXPR years_duration(int_rep num) : _y(num) {}
+      BOOST_CXX14_CONSTEXPR years_duration(special_values sv) : _y(sv) 
       {
         _y = int_rep::from_special(sv);
       }
-      int_rep number_of_years() const { return _y; }
+      BOOST_CXX14_CONSTEXPR int_rep number_of_years() const { return _y; }
       //! returns a negative duration
-      duration_type get_neg_offset(const date_type& d) const
+      BOOST_CXX14_CONSTEXPR duration_type get_neg_offset(const date_type& d) const
       {
         month_adjustor_type m_adj(_y.as_number() * 12);
         return duration_type(m_adj.get_neg_offset(d));
       }
-      duration_type get_offset(const date_type& d) const
+      BOOST_CXX14_CONSTEXPR duration_type get_offset(const date_type& d) const
       {
         month_adjustor_type m_adj(_y.as_number() * 12);
         return duration_type(m_adj.get_offset(d));
       }
-      bool operator==(const years_type& rhs) const
+      BOOST_CXX14_CONSTEXPR bool operator==(const years_type& rhs) const
       {
         return(_y == rhs._y);
       }
@@ -195,75 +194,72 @@ namespace date_time {
       {
         return(_y != rhs._y);
       }
-      years_type operator+(const years_type& rhs)const
+      BOOST_CXX14_CONSTEXPR years_type operator+(const years_type& rhs)const
       {
         return years_type(_y + rhs._y);
       }
-      years_type& operator+=(const years_type& rhs)
+      BOOST_CXX14_CONSTEXPR years_type& operator+=(const years_type& rhs)
       {
         _y = _y + rhs._y;
         return *this;
       }
-      years_type operator-(const years_type& rhs)const
+      BOOST_CXX14_CONSTEXPR years_type operator-(const years_type& rhs)const
       {
         return years_type(_y - rhs._y);
       }
-      years_type& operator-=(const years_type& rhs)
+      BOOST_CXX14_CONSTEXPR years_type& operator-=(const years_type& rhs)
       {
         _y = _y - rhs._y;
         return *this;
       }
-      years_type operator*(const int_type rhs)const
+      BOOST_CXX14_CONSTEXPR years_type operator*(const int_type rhs)const
       {
         return years_type(_y * rhs);
       }
-      years_type& operator*=(const int_type rhs)
+      BOOST_CXX14_CONSTEXPR years_type& operator*=(const int_type rhs)
       {
         _y = _y * rhs;
         return *this;
       }
-      years_type operator/(const int_type rhs)const
+      BOOST_CXX14_CONSTEXPR years_type operator/(const int_type rhs)const
       {
         return years_type(_y / rhs);
       }
-      years_type& operator/=(const int_type rhs)
+      BOOST_CXX14_CONSTEXPR years_type& operator/=(const int_type rhs)
       {
         _y = _y / rhs;
         return *this;
       }
-      months_type operator+(const months_type& m) const
+      BOOST_CXX14_CONSTEXPR months_type operator+(const months_type& m) const
       {
         return(months_type(_y * 12 + m.number_of_months()));
       }
-      months_type operator-(const months_type& m) const
+      BOOST_CXX14_CONSTEXPR months_type operator-(const months_type& m) const
       {
         return(months_type(_y * 12 - m.number_of_months()));
       }
-
       //
-      friend date_type operator+(const date_type& d, const years_type& y)
+      BOOST_CXX14_CONSTEXPR friend date_type operator+(const date_type& d, const years_type& y)
       {
         return d + y.get_offset(d);
       }
-      friend date_type operator+=(date_type& d, const years_type& y)
+      BOOST_CXX14_CONSTEXPR friend date_type operator+=(date_type& d, const years_type& y)
       {
         return d += y.get_offset(d);
       }
-      friend date_type operator-(const date_type& d, const years_type& y)
+      BOOST_CXX14_CONSTEXPR friend date_type operator-(const date_type& d, const years_type& y)
       {
         // get_neg_offset returns a negative duration, so we add
         return d + y.get_neg_offset(d);
       }
-      friend date_type operator-=(date_type& d, const years_type& y)
+      BOOST_CXX14_CONSTEXPR friend date_type operator-=(date_type& d, const years_type& y)
       {
         // get_neg_offset returns a negative duration, so we add
         return d += y.get_neg_offset(d);
       }
-
     private:
       int_rep _y;
   };
-
 }} // namespace boost::date_time
 
 #endif // DATE_DURATION_TYPES_HPP___

include/boost/date_time/date_facet.hpp

@@ -2,28 +2,32 @@
 #define _DATE_TIME_DATE_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$
  */
 
-
-#include "boost/algorithm/string/replace.hpp"
-#include "boost/date_time/period.hpp"
-#include "boost/date_time/special_values_formatter.hpp"
-#include "boost/date_time/period_formatter.hpp"
-#include "boost/date_time/period_parser.hpp"
-#include "boost/date_time/date_generator_formatter.hpp"
-#include "boost/date_time/date_generator_parser.hpp"
-#include "boost/date_time/format_date_parser.hpp"
+#include <iterator> // ostreambuf_iterator
+#include <locale>
 #include <string>
 #include <vector>
+#include <boost/throw_exception.hpp>
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/period.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/special_values_formatter.hpp>
+#include <boost/date_time/period_formatter.hpp>
+#include <boost/date_time/period_parser.hpp>
+#include <boost/date_time/date_generator_formatter.hpp>
+#include <boost/date_time/date_generator_parser.hpp>
+#include <boost/date_time/format_date_parser.hpp>
 
 namespace boost { namespace date_time {
 
-  
+
   /*! Class that provides format based I/O facet for date types.
    *
    * This class allows the formatting of dates by using format string.
@@ -40,9 +44,9 @@ namespace boost { namespace date_time {
    * Default weekday format == %a
    */
   template <class date_type,
-            class CharT, 
+            class CharT,
             class OutItrT = std::ostreambuf_iterator<CharT, std::char_traits<CharT> > >
-  class date_facet : public std::locale::facet {
+  class BOOST_SYMBOL_VISIBLE date_facet : public std::locale::facet {
   public:
     typedef typename date_type::duration_type duration_type;
     // greg_weekday is gregorian_calendar::day_of_week_type
@@ -77,9 +81,9 @@ namespace boost { namespace date_time {
 #if defined (__SUNPRO_CC) && defined (_RWSTD_VER)
       std::locale::id& __get_id (void) const { return id; }
 #endif
-    
-    explicit date_facet(::size_t a_ref = 0) 
-      : std::locale::facet(a_ref), 
+
+    explicit date_facet(::size_t a_ref = 0)
+      : std::locale::facet(a_ref),
         //m_format(standard_format_specifier)
         m_format(default_date_format),
         m_month_format(short_month_format),
@@ -88,22 +92,22 @@ namespace boost { namespace date_time {
 
     explicit date_facet(const char_type* format_str,
                         const input_collection_type& short_names,
-                        ::size_t ref_count = 0) 
-      : std::locale::facet(ref_count), 
+                        ::size_t ref_count = 0)
+      : std::locale::facet(ref_count),
         m_format(format_str),
         m_month_format(short_month_format),
         m_weekday_format(short_weekday_format),
-        m_month_short_names(short_names) 
+        m_month_short_names(short_names)
     {}
 
-     
-    explicit date_facet(const char_type* format_str, 
-                        period_formatter_type per_formatter = period_formatter_type(), 
+
+    explicit date_facet(const char_type* format_str,
+                        period_formatter_type per_formatter = period_formatter_type(),
                         special_values_formatter_type sv_formatter = special_values_formatter_type(),
                         date_gen_formatter_type dg_formatter = date_gen_formatter_type(),
                         ::size_t ref_count = 0)
-      : std::locale::facet(ref_count), 
-        m_format(format_str), 
+      : std::locale::facet(ref_count),
+        m_format(format_str),
         m_month_format(short_month_format),
         m_weekday_format(short_weekday_format),
         m_period_formatter(per_formatter),
@@ -127,11 +131,11 @@ namespace boost { namespace date_time {
     void weekday_format(const char_type* const format_str) {
       m_weekday_format = format_str;
     }
-    
+
     void period_formatter(period_formatter_type per_formatter) {
       m_period_formatter= per_formatter;
     }
-    void special_values_formatter(const special_values_formatter_type& svf) 
+    void special_values_formatter(const special_values_formatter_type& svf)
     {
       m_special_values_formatter = svf;
     }
@@ -160,24 +164,24 @@ namespace boost { namespace date_time {
       m_date_gen_formatter.elements(new_strings, beg_pos);
     }
 
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const date_type& d) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const date_type& d) const
     {
-      if (d.is_special()) { 
+      if (d.is_special()) {
         return do_put_special(next, a_ios, fill_char, d.as_special());
       }
       //The following line of code required the date to support a to_tm function
       return do_put_tm(next, a_ios, fill_char, to_tm(d), m_format);
     }
 
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const duration_type& dd) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const duration_type& dd) const
     {
-      if (dd.is_special()) { 
+      if (dd.is_special()) {
         return do_put_special(next, a_ios, fill_char, dd.get_rep().as_special());
       }
 
@@ -195,164 +199,151 @@ namespace boost { namespace date_time {
     }
 
 
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const month_type& m) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const month_type& m) const
     {
-      //if (d.is_special()) { 
+      //if (d.is_special()) {
       //  return do_put_special(next, a_ios, fill_char, d.as_special());
       //}
       //The following line of code required the date to support a to_tm function
-      tm dtm;
-      init_tm(dtm);
-      dtm.tm_mon = m -1;
+      std::tm dtm;
+      std::memset(&dtm, 0, sizeof(dtm));
+      dtm.tm_mon = m - 1;
       return do_put_tm(next, a_ios, fill_char, dtm, m_month_format);
     }
 
     //! puts the day of month
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const day_type& day) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const day_type& day) const
     {
-      tm dtm;
-      init_tm(dtm);
+      std::tm dtm;
+      std::memset(&dtm, 0, sizeof(dtm));
       dtm.tm_mday = day.as_number();
       char_type tmp[3] = {'%','d'};
       string_type temp_format(tmp);
       return do_put_tm(next, a_ios, fill_char, dtm, temp_format);
     }
 
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const day_of_week_type& dow) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const day_of_week_type& dow) const
     {
-      //if (d.is_special()) { 
+      //if (d.is_special()) {
       //  return do_put_special(next, a_ios, fill_char, d.as_special());
       //}
       //The following line of code required the date to support a to_tm function
-      tm dtm;
-      init_tm(dtm);
+      std::tm dtm;
+      std::memset(&dtm, 0, sizeof(dtm));
       dtm.tm_wday = dow;
       return do_put_tm(next, a_ios, fill_char, dtm, m_weekday_format);
     }
 
 
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const period_type& p) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const period_type& p) const
     {
       return m_period_formatter.put_period(next, a_ios, fill_char, p, *this);
     }
 
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const partial_date_type& pd) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const partial_date_type& pd) const
     {
       return m_date_gen_formatter.put_partial_date(next, a_ios, fill_char, pd, *this);
     }
 
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const nth_kday_type& nkd) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const nth_kday_type& nkd) const
     {
       return m_date_gen_formatter.put_nth_kday(next, a_ios, fill_char, nkd, *this);
     }
 
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const first_kday_type& fkd) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const first_kday_type& fkd) const
     {
       return m_date_gen_formatter.put_first_kday(next, a_ios, fill_char, fkd, *this);
     }
 
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const last_kday_type& lkd) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const last_kday_type& lkd) const
     {
       return m_date_gen_formatter.put_last_kday(next, a_ios, fill_char, lkd, *this);
     }
 
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const kday_before_type& fkb) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const kday_before_type& fkb) const
     {
       return m_date_gen_formatter.put_kday_before(next, a_ios, fill_char, fkb, *this);
     }
 
-    OutItrT put(OutItrT next, 
-                std::ios_base& a_ios, 
-                char_type fill_char, 
-                const kday_after_type& fka) const 
+    OutItrT put(OutItrT next,
+                std::ios_base& a_ios,
+                char_type fill_char,
+                const kday_after_type& fka) const
     {
       return m_date_gen_formatter.put_kday_after(next, a_ios, fill_char, fka, *this);
     }
-    
+
   protected:
-    //! Helper function to initialize all fields in a tm struct
-    tm init_tm(tm& tm_value) const
-    {
-      tm_value.tm_sec = 0;         /* seconds */
-      tm_value.tm_min = 0;         /* minutes */
-      tm_value.tm_hour = 0;        /* hours */
-      tm_value.tm_mday = 0;        /* day of the month */
-      tm_value.tm_mon = 0;         /* month */
-      tm_value.tm_year = 0;        /* year */
-      tm_value.tm_wday = 0;        /* day of the week */
-      tm_value.tm_yday = 0;        /* day in the year */
-      tm_value.tm_isdst = 0;       /* daylight saving time */
-      return tm_value;
-    }
-    virtual OutItrT do_put_special(OutItrT next, 
-                                   std::ios_base& /*a_ios*/, 
-                                   char_type /*fill_char*/, 
-                                   const boost::date_time::special_values sv) const 
+    virtual OutItrT do_put_special(OutItrT next,
+                                   std::ios_base& /*a_ios*/,
+                                   char_type /*fill_char*/,
+                                   const boost::date_time::special_values sv) const
     {
       m_special_values_formatter.put_special(next, sv);
       return next;
     }
-    virtual OutItrT do_put_tm(OutItrT next, 
-                              std::ios_base& a_ios, 
-                              char_type fill_char, 
+    virtual OutItrT do_put_tm(OutItrT next,
+                              std::ios_base& a_ios,
+                              char_type fill_char,
                               const tm& tm_value,
-                              string_type a_format) const 
+                              string_type a_format) const
     {
       // update format string with custom names
-      if (m_weekday_long_names.size()) {
-        boost::algorithm::replace_all(a_format, 
-                                      long_weekday_format, 
+      if (!m_weekday_long_names.empty()) {
+        boost::algorithm::replace_all(a_format,
+                                      long_weekday_format,
                                       m_weekday_long_names[tm_value.tm_wday]);
       }
-      if (m_weekday_short_names.size()) {
-        boost::algorithm::replace_all(a_format, 
-                                      short_weekday_format, 
+      if (!m_weekday_short_names.empty()) {
+        boost::algorithm::replace_all(a_format,
+                                      short_weekday_format,
                                       m_weekday_short_names[tm_value.tm_wday]);
 
       }
-      if (m_month_long_names.size()) {
-        boost::algorithm::replace_all(a_format, 
-                                      long_month_format, 
+      if (!m_month_long_names.empty()) {
+        boost::algorithm::replace_all(a_format,
+                                      long_month_format,
                                       m_month_long_names[tm_value.tm_mon]);
       }
-      if (m_month_short_names.size()) {
-        boost::algorithm::replace_all(a_format, 
-                                      short_month_format, 
+      if (!m_month_short_names.empty()) {
+        boost::algorithm::replace_all(a_format,
+                                      short_month_format,
                                       m_month_short_names[tm_value.tm_mon]);
       }
       // use time_put facet to create final string
-      return std::use_facet<std::time_put<CharT> >(a_ios.getloc()).put(next, a_ios, 
-                                                                       fill_char, 
+      const char_type* p_format = a_format.c_str();
+      return std::use_facet<std::time_put<CharT> >(a_ios.getloc()).put(next, a_ios,
+                                                                       fill_char,
                                                                        &tm_value,
-                                                                       &*a_format.begin(), 
-                                                                       &*a_format.begin()+a_format.size());
+                                                                       p_format,
+                                                                       p_format + a_format.size());
     }
   protected:
     string_type                   m_format;
@@ -371,53 +362,53 @@ namespace boost { namespace date_time {
   template <class date_type, class CharT, class OutItrT>
   std::locale::id date_facet<date_type, CharT, OutItrT>::id;
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_facet<date_type, CharT, OutItrT>::char_type
   date_facet<date_type, CharT, OutItrT>::long_weekday_format[3] = {'%','A'};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_facet<date_type, CharT, OutItrT>::char_type
   date_facet<date_type, CharT, OutItrT>::short_weekday_format[3] = {'%','a'};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_facet<date_type, CharT, OutItrT>::char_type
   date_facet<date_type, CharT, OutItrT>::long_month_format[3] = {'%','B'};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_facet<date_type, CharT, OutItrT>::char_type
   date_facet<date_type, CharT, OutItrT>::short_month_format[3] = {'%','b'};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_facet<date_type, CharT, OutItrT>::char_type
   date_facet<date_type, CharT, OutItrT>::default_period_separator[4] = { ' ', '/', ' '};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_facet<date_type, CharT, OutItrT>::char_type 
-  date_facet<date_type, CharT, OutItrT>::standard_format_specifier[3] = 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_facet<date_type, CharT, OutItrT>::char_type
+  date_facet<date_type, CharT, OutItrT>::standard_format_specifier[3] =
     {'%', 'x' };
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_facet<date_type, CharT, OutItrT>::char_type 
-  date_facet<date_type, CharT, OutItrT>::iso_format_specifier[7] = 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_facet<date_type, CharT, OutItrT>::char_type
+  date_facet<date_type, CharT, OutItrT>::iso_format_specifier[7] =
     {'%', 'Y', '%', 'm', '%', 'd' };
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_facet<date_type, CharT, OutItrT>::char_type 
-  date_facet<date_type, CharT, OutItrT>::iso_format_extended_specifier[9] = 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_facet<date_type, CharT, OutItrT>::char_type
+  date_facet<date_type, CharT, OutItrT>::iso_format_extended_specifier[9] =
     {'%', 'Y', '-', '%', 'm', '-', '%', 'd' };
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_facet<date_type, CharT, OutItrT>::char_type 
-  date_facet<date_type, CharT, OutItrT>::default_date_format[9] = 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_facet<date_type, CharT, OutItrT>::char_type
+  date_facet<date_type, CharT, OutItrT>::default_date_format[9] =
     {'%','Y','-','%','b','-','%','d'};
 
 
 
   //! Input facet
   template <class date_type,
-            class CharT, 
+            class CharT,
             class InItrT = std::istreambuf_iterator<CharT, std::char_traits<CharT> > >
-  class date_input_facet : public std::locale::facet {
+  class BOOST_SYMBOL_VISIBLE date_input_facet : public std::locale::facet {
   public:
     typedef typename date_type::duration_type duration_type;
     // greg_weekday is gregorian_calendar::day_of_week_type
@@ -429,7 +420,7 @@ namespace boost { namespace date_time {
     typedef std::basic_string<CharT> string_type;
     typedef CharT                    char_type;
     typedef boost::date_time::period_parser<date_type, CharT>  period_parser_type;
-    typedef boost::date_time::special_values_parser<date_type,CharT> special_values_parser_type; 
+    typedef boost::date_time::special_values_parser<date_type,CharT> special_values_parser_type;
     typedef std::vector<std::basic_string<CharT> > input_collection_type;
     typedef format_date_parser<date_type, CharT> format_date_parser_type;
     // date_generators stuff goes here
@@ -453,9 +444,9 @@ namespace boost { namespace date_time {
     static const char_type iso_format_extended_specifier[9];
     static const char_type default_date_format[9]; // YYYY-Mon-DD
     static std::locale::id id;
-    
-    explicit date_input_facet(::size_t a_ref = 0) 
-      : std::locale::facet(a_ref), 
+
+    explicit date_input_facet(::size_t a_ref = 0)
+      : std::locale::facet(a_ref),
         m_format(default_date_format),
         m_month_format(short_month_format),
         m_weekday_format(short_weekday_format),
@@ -465,8 +456,8 @@ namespace boost { namespace date_time {
     {}
 
     explicit date_input_facet(const string_type& format_str,
-                              ::size_t a_ref = 0) 
-      : std::locale::facet(a_ref), 
+                              ::size_t a_ref = 0)
+      : std::locale::facet(a_ref),
         m_format(format_str),
         m_month_format(short_month_format),
         m_weekday_format(short_weekday_format),
@@ -513,7 +504,7 @@ namespace boost { namespace date_time {
     void year_format(const char_type* const format_str) {
       m_year_format = format_str;
     }
-    
+
     void period_parser(period_parser_type per_parser) {
       m_period_parser = per_parser;
     }
@@ -549,7 +540,7 @@ namespace boost { namespace date_time {
                                   const string_type& before,
                                   const string_type& after,
                                   const string_type& of)
-                           
+
     {
       m_date_gen_parser.element_strings(first,second,third,fourth,fifth,last,before,after,of);
     }
@@ -559,68 +550,68 @@ namespace boost { namespace date_time {
       m_sv_parser = sv_parser;
     }
 
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& /*a_ios*/, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& /*a_ios*/,
                date_type& d) const
     {
       d = m_parser.parse_date(from, to, m_format, m_sv_parser);
       return from;
     }
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& /*a_ios*/, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& /*a_ios*/,
                month_type& m) const
     {
       m = m_parser.parse_month(from, to, m_month_format);
       return from;
     }
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& /*a_ios*/, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& /*a_ios*/,
                day_of_week_type& wd) const
     {
       wd = m_parser.parse_weekday(from, to, m_weekday_format);
       return from;
     }
     //! Expects 1 or 2 digit day range: 1-31
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& /*a_ios*/, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& /*a_ios*/,
                day_type& d) const
     {
       d = m_parser.parse_var_day_of_month(from, to);
       return from;
     }
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& /*a_ios*/, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& /*a_ios*/,
                year_type& y) const
     {
       y = m_parser.parse_year(from, to, m_year_format);
       return from;
     }
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& a_ios, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& a_ios,
                duration_type& dd) const
     {
       // skip leading whitespace
-      while(std::isspace(*from) && from != to) { ++from; } 
-     
-      /* num_get.get() will always consume the first character if it 
-       * is a sign indicator (+/-). Special value strings may begin 
+      while(std::isspace(*from) && from != to) { ++from; }
+
+      /* num_get.get() will always consume the first character if it
+       * is a sign indicator (+/-). Special value strings may begin
        * with one of these signs so we'll need a copy of it
        * in case num_get.get() fails. */
-      char_type c = '\0'; 
+      char_type c = '\0';
       // TODO Are these characters somewhere in the locale?
-      if(*from == '-' || *from == '+') { 
+      if(*from == '-' || *from == '+') {
         c = *from;
       }
       typedef std::num_get<CharT, InItrT> num_get;
       typename duration_type::duration_rep_type val = 0;
       std::ios_base::iostate err = std::ios_base::goodbit;
-      
+
       if (std::has_facet<num_get>(a_ios.getloc())) {
         from = std::use_facet<num_get>(a_ios.getloc()).get(from, to, a_ios, err, val);
       }
@@ -638,67 +629,68 @@ namespace boost { namespace date_time {
         }
         m_sv_parser.match(from, to, mr);
         if(mr.current_match == match_results::PARSE_ERROR) {
-          throw std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'");
+          boost::throw_exception(std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'"));
+          BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(return from); // should never reach
         }
-        dd = duration_type(static_cast<special_values>(mr.current_match)); 
+        dd = duration_type(static_cast<special_values>(mr.current_match));
       }
       else {
         dd = duration_type(val);
       }
       return from;
     }
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& a_ios, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& a_ios,
                period_type& p) const
     {
-      p = m_period_parser.get_period(from, to, a_ios, p, duration_type::unit(), *this);     
+      p = m_period_parser.get_period(from, to, a_ios, p, duration_type::unit(), *this);
       return from;
     }
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& a_ios, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& a_ios,
                nth_kday_type& nkd) const
     {
       nkd = m_date_gen_parser.get_nth_kday_type(from, to, a_ios, *this);
       return from;
     }
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& a_ios, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& a_ios,
                partial_date_type& pd) const
     {
 
       pd = m_date_gen_parser.get_partial_date_type(from, to, a_ios, *this);
       return from;
     }
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& a_ios, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& a_ios,
                first_kday_type& fkd) const
     {
       fkd = m_date_gen_parser.get_first_kday_type(from, to, a_ios, *this);
       return from;
     }
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& a_ios, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& a_ios,
                last_kday_type& lkd) const
     {
       lkd = m_date_gen_parser.get_last_kday_type(from, to, a_ios, *this);
       return from;
     }
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& a_ios, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& a_ios,
                kday_before_type& fkb) const
     {
       fkb = m_date_gen_parser.get_kday_before_type(from, to, a_ios, *this);
       return from;
     }
-    InItrT get(InItrT& from, 
-               InItrT& to, 
-               std::ios_base& a_ios, 
+    InItrT get(InItrT& from,
+               InItrT& to,
+               std::ios_base& a_ios,
                kday_after_type& fka) const
     {
       fka = m_date_gen_parser.get_kday_after_type(from, to, a_ios, *this);
@@ -721,55 +713,54 @@ namespace boost { namespace date_time {
   template <class date_type, class CharT, class OutItrT>
   std::locale::id date_input_facet<date_type, CharT, OutItrT>::id;
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_input_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
   date_input_facet<date_type, CharT, OutItrT>::long_weekday_format[3] = {'%','A'};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_input_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
   date_input_facet<date_type, CharT, OutItrT>::short_weekday_format[3] = {'%','a'};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_input_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
   date_input_facet<date_type, CharT, OutItrT>::long_month_format[3] = {'%','B'};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_input_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
   date_input_facet<date_type, CharT, OutItrT>::short_month_format[3] = {'%','b'};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_input_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
   date_input_facet<date_type, CharT, OutItrT>::four_digit_year_format[3] = {'%','Y'};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_input_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
   date_input_facet<date_type, CharT, OutItrT>::two_digit_year_format[3] = {'%','y'};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_input_facet<date_type, CharT, OutItrT>::char_type 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
   date_input_facet<date_type, CharT, OutItrT>::default_period_separator[4] = { ' ', '/', ' '};
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_input_facet<date_type, CharT, OutItrT>::char_type 
-  date_input_facet<date_type, CharT, OutItrT>::standard_format_specifier[3] = 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
+  date_input_facet<date_type, CharT, OutItrT>::standard_format_specifier[3] =
     {'%', 'x' };
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_input_facet<date_type, CharT, OutItrT>::char_type 
-  date_input_facet<date_type, CharT, OutItrT>::iso_format_specifier[7] = 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
+  date_input_facet<date_type, CharT, OutItrT>::iso_format_specifier[7] =
     {'%', 'Y', '%', 'm', '%', 'd' };
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_input_facet<date_type, CharT, OutItrT>::char_type 
-  date_input_facet<date_type, CharT, OutItrT>::iso_format_extended_specifier[9] = 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
+  date_input_facet<date_type, CharT, OutItrT>::iso_format_extended_specifier[9] =
     {'%', 'Y', '-', '%', 'm', '-', '%', 'd' };
 
-  template <class date_type, class CharT, class OutItrT>  
-  const typename date_input_facet<date_type, CharT, OutItrT>::char_type 
-  date_input_facet<date_type, CharT, OutItrT>::default_date_format[9] = 
+  template <class date_type, class CharT, class OutItrT>
+  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
+  date_input_facet<date_type, CharT, OutItrT>::default_date_format[9] =
     {'%','Y','-','%','b','-','%','d'};
 
 } } // namespaces
 
-
 #endif

include/boost/date_time/date_formatting.hpp

@@ -11,6 +11,7 @@
 
 #include "boost/date_time/iso_format.hpp"
 #include "boost/date_time/compiler_config.hpp"
+#include <boost/io/ios_state.hpp>
 #include <string>
 #include <sstream>
 #include <iomanip>
@@ -51,10 +52,13 @@ namespace date_time {
         }
         case month_as_integer: 
         { 
+          boost::io::basic_ios_fill_saver<charT> ifs(os);
           os << std::setw(2) << std::setfill(os.widen('0')) << month.as_number();
           break;
         }
-     
+        default:
+          break;
+          
       }
       return os;
     } // format_month
@@ -79,7 +83,13 @@ namespace date_time {
     {
       typedef typename ymd_type::month_type month_type;
       std::basic_ostringstream<charT> ss;
+
+      // Temporarily switch to classic locale to prevent possible formatting
+      // of year with comma or other character (for example 2,008).
+      ss.imbue(std::locale::classic());
       ss << ymd.year;
+      ss.imbue(std::locale());
+
       if (format_type::has_date_sep_chars()) {
         ss << format_type::month_sep_char();
       }

include/boost/date_time/date_formatting_locales.hpp

@@ -17,6 +17,7 @@
 #include "boost/date_time/iso_format.hpp"
 #include "boost/date_time/date_names_put.hpp"
 #include "boost/date_time/parse_format_base.hpp"
+#include <boost/io/ios_state.hpp>
 //#include <string>
 #include <sstream>
 #include <iomanip>
@@ -56,8 +57,8 @@ namespace date_time {
         }
         case month_as_integer:
         {
-          charT fill_char = '0';
-          os << std::setw(2) << std::setfill(fill_char) << month.as_number();
+          boost::io::basic_ios_fill_saver<charT> ifs(os);
+          os << std::setw(2) << std::setfill(os.widen('0')) << month.as_number();
           break;
         }
 
@@ -132,8 +133,8 @@ namespace date_time {
                         ostream_type& os,
                         const facet_type& f)
     {
+      boost::io::basic_ios_fill_saver<charT> ifs(os);
       std::ostreambuf_iterator<charT> oitr(os);
-      charT fill_char = '0';
       switch (f.date_order()) {
         case ymd_order_iso: {
           os << ymd.year;
@@ -144,7 +145,7 @@ namespace date_time {
           if (f.has_date_sep_chars()) {
             f.day_sep_char(oitr);
           }
-          os  << std::setw(2) << std::setfill(fill_char)
+          os  << std::setw(2) << std::setfill(os.widen('0'))
               << ymd.day;
           break;
         }
@@ -153,7 +154,7 @@ namespace date_time {
           if (f.has_date_sep_chars()) {
           f.day_sep_char(oitr);
           }
-          os  << std::setw(2) << std::setfill(fill_char)
+          os  << std::setw(2) << std::setfill(os.widen('0'))
             << ymd.day;
           if (f.has_date_sep_chars()) {
             f.month_sep_char(oitr);
@@ -162,7 +163,7 @@ namespace date_time {
           break;
         }
         case ymd_order_dmy: {
-          os  << std::setw(2) << std::setfill(fill_char)
+          os  << std::setw(2) << std::setfill(os.widen('0'))
               << ymd.day;
           if (f.has_date_sep_chars()) {
             f.day_sep_char(oitr);

include/boost/date_time/date_generator_formatter.hpp

@@ -63,6 +63,7 @@ namespace date_time {
       //! Default format elements used
       date_generator_formatter()
       {
+        phrase_strings.reserve(number_of_phrase_elements);
         phrase_strings.push_back(string_type(first_string));
         phrase_strings.push_back(string_type(second_string));
         phrase_strings.push_back(string_type(third_string));
@@ -75,25 +76,26 @@ namespace date_time {
       }
 
       //! Constructor that allows for a custom set of phrase elements
-      date_generator_formatter(const string_type& first,
-                               const string_type& second,
-                               const string_type& third,
-                               const string_type& fourth,
-                               const string_type& fifth,
-                               const string_type& last,
-                               const string_type& before,
-                               const string_type& after,
-                               const string_type& of)
+      date_generator_formatter(const string_type& first_str,
+                               const string_type& second_str,
+                               const string_type& third_str,
+                               const string_type& fourth_str,
+                               const string_type& fifth_str,
+                               const string_type& last_str,
+                               const string_type& before_str,
+                               const string_type& after_str,
+                               const string_type& of_str)
       {
-        phrase_strings.push_back(string_type(first_string));
-        phrase_strings.push_back(string_type(second_string));
-        phrase_strings.push_back(string_type(third_string));
-        phrase_strings.push_back(string_type(fourth_string));
-        phrase_strings.push_back(string_type(fifth_string));
-        phrase_strings.push_back(string_type(last_string));
-        phrase_strings.push_back(string_type(before_string));
-        phrase_strings.push_back(string_type(after_string));
-        phrase_strings.push_back(string_type(of_string));
+        phrase_strings.reserve(number_of_phrase_elements);
+        phrase_strings.push_back(first_str);
+        phrase_strings.push_back(second_str);
+        phrase_strings.push_back(third_str);
+        phrase_strings.push_back(fourth_str);
+        phrase_strings.push_back(fifth_str);
+        phrase_strings.push_back(last_str);
+        phrase_strings.push_back(before_str);
+        phrase_strings.push_back(after_str);
+        phrase_strings.push_back(of_str);
       }
 
       //! Replace the set of phrase elements with those contained in new_strings
@@ -148,7 +150,7 @@ namespace date_time {
         facet.put(next, a_ios, a_fill, nkd.month());
         return next;
       }
-   
+
       //! Put a first_day_of_the_week_in_month => "first weekday of month"
       template<class facet_type>
       OutItrT put_first_kday(OutItrT next, std::ios_base& a_ios,

include/boost/date_time/date_generator_parser.hpp

@@ -10,12 +10,14 @@
  * $Date$
  */
 
-
-#include "boost/date_time/string_parse_tree.hpp"
-#include "boost/date_time/date_generators.hpp"
-#include "boost/date_time/format_date_parser.hpp"
 #include <string>
 #include <vector>
+#include <iterator> // istreambuf_iterator
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/string_parse_tree.hpp>
+#include <boost/date_time/date_generators.hpp>
+#include <boost/date_time/format_date_parser.hpp>
 
 namespace boost { namespace date_time {
 
@@ -66,10 +68,10 @@ namespace boost { namespace date_time {
     static const char_type last_string[5];
     static const char_type before_string[8];
     static const char_type after_string[6];
-    static const char_type of_string[3];  
- 
+    static const char_type of_string[3];
+
     enum phrase_elements {first=0, second, third, fourth, fifth, last,
-                          before, after, of, number_of_phrase_elements};   
+                          before, after, of, number_of_phrase_elements};
 
     //! Creates a date_generator_parser with the default set of "element_strings"
     date_generator_parser()
@@ -96,7 +98,7 @@ namespace boost { namespace date_time {
                           const string_type& after_str,
                           const string_type& of_str)
     {
-      element_strings(first_str, second_str, third_str, fourth_str, fifth_str, 
+      element_strings(first_str, second_str, third_str, fourth_str, fifth_str,
                       last_str, before_str, after_str, of_str);
     }
 
@@ -128,19 +130,18 @@ namespace boost { namespace date_time {
     {
       m_element_strings = parse_tree_type(col, this->first); // enum first
     }
-                     
 
     //! returns partial_date parsed from stream
     template<class facet_type>
     partial_date_type
-    get_partial_date_type(stream_itr_type& sitr, 
+    get_partial_date_type(stream_itr_type& sitr,
                           stream_itr_type& stream_end,
-                          std::ios_base& a_ios, 
+                          std::ios_base& a_ios,
                           const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
       day_type d(1);
       month_type m(1);
       facet.get(sitr, stream_end, a_ios, d);
@@ -152,18 +153,18 @@ namespace boost { namespace date_time {
     //! returns nth_kday_of_week parsed from stream
     template<class facet_type>
     nth_kday_type
-    get_nth_kday_type(stream_itr_type& sitr, 
+    get_nth_kday_type(stream_itr_type& sitr,
                       stream_itr_type& stream_end,
-                      std::ios_base& a_ios, 
+                      std::ios_base& a_ios,
                       const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+ 
       typename nth_kday_type::week_num wn;
       day_of_week_type wd(0); // no default constructor
       month_type m(1);        // no default constructor
-     
+
       match_results mr = m_element_strings.match(sitr, stream_end);
       switch(mr.current_match) {
         case first  : { wn = nth_kday_type::first; break; }
@@ -173,98 +174,98 @@ namespace boost { namespace date_time {
         case fifth  : { wn = nth_kday_type::fifth; break; }
         default:
         {
-          throw std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'");
-          break;
+          boost::throw_exception(std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'"));
+          BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(wn = nth_kday_type::first);
         }
       }                                         // week num
       facet.get(sitr, stream_end, a_ios, wd);   // day_of_week
       extract_element(sitr, stream_end, of);    // "of" element
       facet.get(sitr, stream_end, a_ios, m);    // month
-      
+
       return nth_kday_type(wn, wd, m);
     }
 
     //! returns first_kday_of_week parsed from stream
     template<class facet_type>
     first_kday_type
-    get_first_kday_type(stream_itr_type& sitr, 
+    get_first_kday_type(stream_itr_type& sitr,
                         stream_itr_type& stream_end,
-                        std::ios_base& a_ios, 
+                        std::ios_base& a_ios,
                         const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
       day_of_week_type wd(0); // no default constructor
       month_type m(1);        // no default constructor
-     
+
       extract_element(sitr, stream_end, first); // "first" element
       facet.get(sitr, stream_end, a_ios, wd);   // day_of_week
       extract_element(sitr, stream_end, of);    // "of" element
       facet.get(sitr, stream_end, a_ios, m);    // month
-      
-      
+
+
       return first_kday_type(wd, m);
     }
 
     //! returns last_kday_of_week parsed from stream
     template<class facet_type>
     last_kday_type
-    get_last_kday_type(stream_itr_type& sitr, 
+    get_last_kday_type(stream_itr_type& sitr,
                        stream_itr_type& stream_end,
-                       std::ios_base& a_ios, 
+                       std::ios_base& a_ios,
                        const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
       day_of_week_type wd(0); // no default constructor
       month_type m(1);        // no default constructor
-     
+ 
       extract_element(sitr, stream_end, last); // "last" element
       facet.get(sitr, stream_end, a_ios, wd);  // day_of_week
       extract_element(sitr, stream_end, of);   // "of" element
       facet.get(sitr, stream_end, a_ios, m);   // month
-      
-      
+
+
       return last_kday_type(wd, m);
     }
 
     //! returns first_kday_of_week parsed from stream
     template<class facet_type>
     kday_before_type
-    get_kday_before_type(stream_itr_type& sitr, 
+    get_kday_before_type(stream_itr_type& sitr,
                          stream_itr_type& stream_end,
-                         std::ios_base& a_ios, 
+                         std::ios_base& a_ios,
                          const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
       day_of_week_type wd(0); // no default constructor
-     
+
       facet.get(sitr, stream_end, a_ios, wd);   // day_of_week
       extract_element(sitr, stream_end, before);// "before" element
-      
+
       return kday_before_type(wd);
     }
 
     //! returns first_kday_of_week parsed from stream
     template<class facet_type>
     kday_after_type
-    get_kday_after_type(stream_itr_type& sitr, 
+    get_kday_after_type(stream_itr_type& sitr,
                         stream_itr_type& stream_end,
-                        std::ios_base& a_ios, 
+                        std::ios_base& a_ios,
                         const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
       day_of_week_type wd(0); // no default constructor
-     
+
       facet.get(sitr, stream_end, a_ios, wd);   // day_of_week
       extract_element(sitr, stream_end, after); // "after" element
-      
+
       return kday_after_type(wd);
     }
 
@@ -277,13 +278,13 @@ namespace boost { namespace date_time {
                          typename date_generator_parser::phrase_elements ele) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
       match_results mr = m_element_strings.match(sitr, stream_end);
       if(mr.current_match != ele) {
-        throw std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'");
+        boost::throw_exception(std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'"));
       }
     }
-    
+
   };
 
   template<class date_type, class CharT>

include/boost/date_time/date_generators.hpp

@@ -2,20 +2,22 @@
 #define DATE_TIME_DATE_GENERATORS_HPP__
 
 /* Copyright (c) 2002,2003,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 
+ * Author: Jeff Garland, Bart Garst
  * $Date$
  */
 
 /*! @file date_generators.hpp
   Definition and implementation of date algorithm templates
 */
-#include <stdexcept>
+
 #include <sstream>
-#include "boost/date_time/date.hpp"
-#include "boost/date_time/compiler_config.hpp"
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/date.hpp>
+#include <boost/date_time/compiler_config.hpp>
 
 namespace boost {
 namespace date_time {
@@ -23,7 +25,7 @@ namespace date_time {
   //! Base class for all generators that take a year and produce a date.
   /*! This class is a base class for polymorphic function objects that take
     a year and produce a concrete date.
-    @param date_type The type representing a date.  This type must
+    @tparam date_type The type representing a date.  This type must
     export a calender_type which defines a year_type.
   */
   template<class date_type>
@@ -32,16 +34,16 @@ namespace date_time {
   public:
     typedef typename date_type::calendar_type calendar_type;
     typedef typename calendar_type::year_type        year_type;
-    year_based_generator() {};
-    virtual ~year_based_generator() {};
+    year_based_generator() {}
+    virtual ~year_based_generator() {}
     virtual date_type get_date(year_type y) const = 0;
     //! Returns a string for use in a POSIX time_zone string
-    virtual std::string to_string() const =0;
+    virtual std::string to_string() const = 0;
   };
-  
+
   //! Generates a date by applying the year to the given month and day.
   /*!
-    Example usage: 
+    Example usage:
     @code
     partial_date pd(1, Jan);
     partial_date pd2(70);
@@ -96,16 +98,14 @@ namespace date_time {
     * pg.get_date(2000); // returns 2000-2-29
     * @endcode
          */
-   date_type get_date(year_type y) const
+   date_type get_date(year_type y) const BOOST_OVERRIDE
    {
      if((day_ == 29) && (month_ == 2) && !(calendar_type::is_leap_year(y))) {
-       std::stringstream ss("");
+       std::ostringstream ss;
        ss << "No Feb 29th in given year of " << y << ".";
-       throw std::invalid_argument(ss.str());
-       //return date_type(1,1,1); // should never reach
-     } else {
-       return date_type(y, month_, day_);
+       boost::throw_exception(std::invalid_argument(ss.str()));
      }
+     return date_type(y, month_, day_);
    }
    date_type operator()(year_type y) const
    {
@@ -123,9 +123,9 @@ namespace date_time {
      //months are equal
      return (day_ < rhs.day_);
    }
-   
+
    // added for streaming purposes
-   month_type month() const 
+   month_type month() const
    {
      return month_;
    }
@@ -135,15 +135,15 @@ namespace date_time {
    }
 
    //! Returns string suitable for use in POSIX time zone string
-   /*! Returns string formatted with up to 3 digits: 
-    * Jan-01 == "0" 
+   /*! Returns string formatted with up to 3 digits:
+    * Jan-01 == "0"
     * Feb-29 == "58"
     * Dec-31 == "365" */
-   virtual std::string to_string() const
+   std::string to_string() const BOOST_OVERRIDE
    {
-     std::stringstream ss;
+     std::ostringstream ss;
      date_type d(2004, month_, day_);
-     unsigned short c = d.day_of_year();     
+     unsigned short c = d.day_of_year();
      c--; // numbered 0-365 while day_of_year is 1 based...
      ss << c;
      return ss.str();
@@ -153,21 +153,33 @@ namespace date_time {
    month_type month_;
  };
 
+  //! Returns nth arg as string. 1 -> "first", 2 -> "second", max is 5.
+  inline const char* nth_as_str(int ele)
+  {
+    static const char* const _nth_as_str[] = {"out of range", "first", "second",
+                                              "third", "fourth", "fifth"};
+    if(ele >= 1 && ele <= 5) {
+      return _nth_as_str[ele];
+    }
+    else {
+      return _nth_as_str[0];
+    }
+  }
 
   //! Useful generator functor for finding holidays
   /*! Based on the idea in Cal. Calc. for finding holidays that are
    *  the 'first Monday of September'. When instantiated with
    *  'fifth' kday of month, the result will be the last kday of month
-   *  which can be the fourth or fifth depending on the structure of 
+   *  which can be the fourth or fifth depending on the structure of
    *  the month.
    *
    *  The algorithm here basically guesses for the first
    *  day of the month.  Then finds the first day of the correct
    *  type.  That is, if the first of the month is a Tuesday
-   *  and it needs Wenesday then we simply increment by a day
+   *  and it needs Wednesday then we simply increment by a day
    *  and then we can add the length of a week until we get
-   *  to the 'nth kday'.  There are probably more efficient 
-   *  algorithms based on using a mod 7, but this one works 
+   *  to the 'nth kday'.  There are probably more efficient
+   *  algorithms based on using a mod 7, but this one works
    *  reasonably well for basic applications.
    *  \ingroup date_alg
    */
@@ -189,7 +201,7 @@ namespace date_time {
       dow_(dow)
     {}
     //! Return a concrete date when provided with a year specific year.
-    date_type get_date(year_type y) const
+    date_type get_date(year_type y) const BOOST_OVERRIDE
     {
       date_type d(y, month_, 1); //first day of month
       duration_type one_day(1);
@@ -227,10 +239,10 @@ namespace date_time {
     }
     //! Returns string suitable for use in POSIX time zone string
     /*! Returns a string formatted as "M4.3.0" ==> 3rd Sunday in April. */
-    virtual std::string to_string() const
+    std::string to_string() const BOOST_OVERRIDE
     {
-     std::stringstream ss;
-     ss << 'M' 
+     std::ostringstream ss;
+     ss << 'M'
        << static_cast<int>(month_) << '.'
        << static_cast<int>(wn_) << '.'
        << static_cast<int>(dow_);
@@ -241,9 +253,6 @@ namespace date_time {
     week_num wn_;
     day_of_week_type dow_;
   };
-  
-  //! Returns nth arg as string. 1 -> "first", 2 -> "second", max is 5.
-  BOOST_DATE_TIME_DECL const char* nth_as_str(int n);
 
   //! Useful generator functor for finding holidays and daylight savings
   /*! Similar to nth_kday_of_month, but requires less paramters
@@ -267,7 +276,7 @@ namespace date_time {
       dow_(dow)
     {}
     //! Return a concrete date when provided with a year specific year.
-    date_type get_date(year_type year) const
+    date_type get_date(year_type year) const BOOST_OVERRIDE
     {
       date_type d(year, month_,1);
       duration_type one_day(1);
@@ -275,7 +284,7 @@ namespace date_time {
         d = d + one_day;
       }
       return d;
-        }
+    }
     // added for streaming
     month_type month() const
     {
@@ -287,10 +296,10 @@ namespace date_time {
     }
     //! Returns string suitable for use in POSIX time zone string
     /*! Returns a string formatted as "M4.1.0" ==> 1st Sunday in April. */
-    virtual std::string to_string() const
+    std::string to_string() const BOOST_OVERRIDE
     {
-     std::stringstream ss;
-     ss << 'M' 
+     std::ostringstream ss;
+     ss << 'M'
        << static_cast<int>(month_) << '.'
        << 1 << '.'
        << static_cast<int>(dow_);
@@ -300,14 +309,14 @@ namespace date_time {
     month_type month_;
     day_of_week_type dow_;
   };
-  
-  
-  
+
+
+
   //! Calculate something like Last Sunday of January
   /*! Useful generator functor for finding holidays and daylight savings
    *  Get the last day of the month and then calculate the difference
    *  to the last previous day.
-   *  @param date_type A date class that exports day_of_week, month_type, etc.
+   *  @tparam date_type A date class that exports day_of_week, month_type, etc.
    *  \ingroup date_alg
    */
   template<class date_type>
@@ -328,7 +337,7 @@ namespace date_time {
       dow_(dow)
     {}
     //! Return a concrete date when provided with a year specific year.
-    date_type get_date(year_type year) const
+    date_type get_date(year_type year) const BOOST_OVERRIDE
     {
       date_type d(year, month_, calendar_type::end_of_month_day(year,month_));
       duration_type one_day(1);
@@ -348,10 +357,10 @@ namespace date_time {
     }
     //! Returns string suitable for use in POSIX time zone string
     /*! Returns a string formatted as "M4.5.0" ==> last Sunday in April. */
-    virtual std::string to_string() const
+    std::string to_string() const BOOST_OVERRIDE
     {
-      std::stringstream ss;
-      ss << 'M' 
+      std::ostringstream ss;
+      ss << 'M'
          << static_cast<int>(month_) << '.'
          << 5 << '.'
          << static_cast<int>(dow_);
@@ -361,8 +370,8 @@ namespace date_time {
     month_type month_;
     day_of_week_type dow_;
    };
-  
-  
+
+
   //! Calculate something like "First Sunday after Jan 1,2002
   /*! Date generator that takes a date and finds kday after
    *@code
@@ -400,7 +409,7 @@ namespace date_time {
   private:
     day_of_week_type dow_;
   };
-  
+
   //! Calculate something like "First Sunday before Jan 1,2002
   /*! Date generator that takes a date and finds kday after
    *@code
@@ -438,10 +447,10 @@ namespace date_time {
   private:
     day_of_week_type dow_;
   };
-  
+
   //! Calculates the number of days until the next weekday
   /*! Calculates the number of days until the next weekday.
-   * If the date given falls on a Sunday and the given weekday 
+   * If the date given falls on a Sunday and the given weekday
    * is Tuesday the result will be 2 days */
   template<typename date_type, class weekday_type>
   inline
@@ -458,8 +467,8 @@ namespace date_time {
 
   //! Calculates the number of days since the previous weekday
   /*! Calculates the number of days since the previous weekday
-   * If the date given falls on a Sunday and the given weekday 
-   * is Tuesday the result will be 5 days. The answer will be a positive 
+   * If the date given falls on a Sunday and the given weekday
+   * is Tuesday the result will be 5 days. The answer will be a positive
    * number because Tuesday is 5 days before Sunday, not -5 days before. */
   template<typename date_type, class weekday_type>
   inline
@@ -477,9 +486,9 @@ namespace date_time {
   }
 
   //! Generates a date object representing the date of the following weekday from the given date
-  /*! Generates a date object representing the date of the following 
-   * weekday from the given date. If the date given is 2004-May-9 
-   * (a Sunday) and the given weekday is Tuesday then the resulting date 
+  /*! Generates a date object representing the date of the following
+   * weekday from the given date. If the date given is 2004-May-9
+   * (a Sunday) and the given weekday is Tuesday then the resulting date
    * will be 2004-May-11. */
   template<class date_type, class weekday_type>
   inline
@@ -489,9 +498,9 @@ namespace date_time {
   }
 
   //! Generates a date object representing the date of the previous weekday from the given date
-  /*! Generates a date object representing the date of the previous 
-   * weekday from the given date. If the date given is 2004-May-9 
-   * (a Sunday) and the given weekday is Tuesday then the resulting date 
+  /*! Generates a date object representing the date of the previous
+   * weekday from the given date. If the date given is 2004-May-9
+   * (a Sunday) and the given weekday is Tuesday then the resulting date
    * will be 2004-May-4. */
   template<class date_type, class weekday_type>
   inline
@@ -502,8 +511,4 @@ namespace date_time {
 
 } } //namespace date_time
 
-
-
-
 #endif
-

include/boost/date_time/date_iterator.hpp

@@ -2,7 +2,7 @@
 #define DATE_ITERATOR_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
@@ -32,7 +32,7 @@ namespace date_time {
   template<class date_type>
   class date_itr_base {
   // works, but benefit unclear at the moment
-  //   class date_itr_base : public std::iterator<std::input_iterator_tag, 
+  //   class date_itr_base : public std::iterator<std::input_iterator_tag,
   //                                             date_type, void, void, void>{
   public:
     typedef typename date_type::duration_type duration_type;
@@ -40,31 +40,31 @@ namespace date_time {
     typedef std::input_iterator_tag iterator_category;
 
     date_itr_base(date_type d) : current_(d) {}
-    virtual ~date_itr_base() {};
-    date_itr_base& operator++() 
+    virtual ~date_itr_base() {}
+    date_itr_base& operator++()
     {
       current_ = current_ + get_offset(current_);
       return *this;
     }
-    date_itr_base& operator--() 
+    date_itr_base& operator--()
     {
       current_ = current_ + get_neg_offset(current_);
       return *this;
     }
     virtual duration_type get_offset(const date_type& current) const=0;
     virtual duration_type get_neg_offset(const date_type& current) const=0;
-    date_type operator*() {return current_;};
-    date_type* operator->() {return &current_;};
-    bool operator<  (const date_type& d) {return current_ < d;}
-    bool operator<= (const date_type& d) {return current_ <= d;}
-    bool operator>  (const date_type& d) {return current_ > d;}
-    bool operator>= (const date_type& d) {return current_ >= d;}
-    bool operator== (const date_type& d) {return current_ == d;}
-    bool operator!= (const date_type& d) {return current_ != d;}    
+    const date_type& operator*() const {return current_;}
+    const date_type* operator->() const {return &current_;}
+    bool operator<  (const date_type& d) const {return current_ < d;}
+    bool operator<= (const date_type& d) const {return current_ <= d;}
+    bool operator>  (const date_type& d) const {return current_ > d;}
+    bool operator>= (const date_type& d) const {return current_ >= d;}
+    bool operator== (const date_type& d) const {return current_ == d;}
+    bool operator!= (const date_type& d) const {return current_ != d;}
   private:
     date_type current_;
   };
-  
+
   //! Overrides the base date iterator providing hook for functors
   /*
    *  <b>offset_functor</b>
@@ -77,9 +77,9 @@ namespace date_time {
   class date_itr : public date_itr_base<date_type> {
   public:
     typedef typename date_type::duration_type duration_type;
-    date_itr(date_type d, int factor=1) : 
-      date_itr_base<date_type>(d), 
-      of_(factor) 
+    date_itr(date_type d, int factor=1) :
+      date_itr_base<date_type>(d),
+      of_(factor)
     {}
   private:
     virtual duration_type get_offset(const date_type& current) const
@@ -92,9 +92,9 @@ namespace date_time {
     }
     offset_functor of_;
   };
-  
 
-  
+
+
 } } //namespace date_time
 
 

include/boost/date_time/date_names_put.hpp

@@ -2,22 +2,23 @@
 #define DATE_TIME_DATE_NAMES_PUT_HPP___
 
 /* Copyright (c) 2002-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 
+ * Author: Jeff Garland, Bart Garst
  * $Date$
  */
 
 
-#include "boost/date_time/locale_config.hpp" // set BOOST_DATE_TIME_NO_LOCALE
+#include <boost/date_time/locale_config.hpp> // set BOOST_DATE_TIME_NO_LOCALE
 
 #ifndef BOOST_DATE_TIME_NO_LOCALE
 
-#include "boost/date_time/special_defs.hpp"
-#include "boost/date_time/date_defs.hpp"
-#include "boost/date_time/parse_format_base.hpp"
-#include "boost/lexical_cast.hpp"
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/date_defs.hpp>
+#include <boost/date_time/parse_format_base.hpp>
+#include <boost/lexical_cast.hpp>
 #include <locale>
 
 
@@ -27,22 +28,22 @@ namespace date_time {
     //! Output facet base class for gregorian dates.
     /*! This class is a base class for date facets used to localize the
      *  names of months and the names of days in the week.
-     * 
+     *
      * Requirements of Config
-     *  - define an enumeration month_enum that enumerates the months. 
+     *  - define an enumeration month_enum that enumerates the months.
      *    The enumeration should be '1' based eg: Jan==1
      *  - define as_short_string and as_long_string
      *
      * (see langer & kreft p334).
-     * 
+     *
      */
     template<class Config,
-             class charT = char, 
+             class charT = char,
              class OutputIterator = std::ostreambuf_iterator<charT> >
-    class date_names_put : public std::locale::facet
+    class BOOST_SYMBOL_VISIBLE date_names_put : public std::locale::facet
     {
     public:
-      date_names_put() {};
+      date_names_put() {}
       typedef OutputIterator iter_type;
       typedef typename Config::month_type month_type;
       typedef typename Config::month_enum month_enum;
@@ -118,7 +119,7 @@ namespace date_time {
         put_string(oitr, gm.as_short_string(c));
       }
       //! Default facet implementation uses month_type defaults
-      virtual void do_put_month_long(iter_type& oitr, 
+      virtual void do_put_month_long(iter_type& oitr,
                                      month_enum moy) const
       {
         month_type gm(moy);
@@ -160,7 +161,7 @@ namespace date_time {
         string_type s(separator); //put in '-'
         put_string(oitr, s);
       }
-      //! Default for date order 
+      //! Default for date order
       virtual ymd_order_spec do_date_order() const
       {
         return ymd_order_iso;
@@ -186,29 +187,29 @@ namespace date_time {
         }
       }
     };
-    
+
     template<class Config, class charT, class OutputIterator>
-    const typename date_names_put<Config, charT, OutputIterator>::char_type 
-    date_names_put<Config, charT, OutputIterator>::default_special_value_names[3][17] = { 
+    const typename date_names_put<Config, charT, OutputIterator>::char_type
+    date_names_put<Config, charT, OutputIterator>::default_special_value_names[3][17] = {
       {'n','o','t','-','a','-','d','a','t','e','-','t','i','m','e'},
       {'-','i','n','f','i','n','i','t','y'},
       {'+','i','n','f','i','n','i','t','y'} };
 
     template<class Config, class charT, class OutputIterator>
-    const typename date_names_put<Config, charT, OutputIterator>::char_type 
-    date_names_put<Config, charT, OutputIterator>::separator[2] = 
+    const typename date_names_put<Config, charT, OutputIterator>::char_type
+    date_names_put<Config, charT, OutputIterator>::separator[2] =
       {'-', '\0'} ;
-    
 
-    //! Generate storage location for a std::locale::id 
+
+    //! Generate storage location for a std::locale::id
     template<class Config, class charT, class OutputIterator>
     std::locale::id date_names_put<Config, charT, OutputIterator>::id;
 
     //! A date name output facet that takes an array of char* to define strings
     template<class Config,
-             class charT = char, 
+             class charT = char,
              class OutputIterator = std::ostreambuf_iterator<charT> >
-    class all_date_names_put : public date_names_put<Config, charT, OutputIterator>
+    class BOOST_SYMBOL_VISIBLE all_date_names_put : public date_names_put<Config, charT, OutputIterator>
     {
     public:
       all_date_names_put(const charT* const month_short_names[],
@@ -230,29 +231,29 @@ namespace date_time {
         separator_char_[0] = separator_char;
         separator_char_[1] = '\0';
 
-      };
+      }
       typedef OutputIterator iter_type;
       typedef typename Config::month_enum month_enum;
       typedef typename Config::weekday_enum weekday_enum;
       typedef typename Config::special_value_enum special_value_enum;
 
-      const charT* const* get_short_month_names() const 
+      const charT* const* get_short_month_names() const
       {
         return month_short_names_;
       }
-      const charT* const* get_long_month_names() const 
+      const charT* const* get_long_month_names() const
       {
         return month_long_names_;
       }
-      const charT* const* get_special_value_names() const 
+      const charT* const* get_special_value_names() const
       {
         return special_value_names_;
       }
-      const charT* const* get_short_weekday_names()const  
+      const charT* const* get_short_weekday_names()const
       {
         return weekday_short_names_;
       }
-      const charT* const* get_long_weekday_names()const 
+      const charT* const* get_long_weekday_names()const
       {
         return weekday_long_names_;
       }
@@ -263,7 +264,7 @@ namespace date_time {
       {
         this->put_string(oitr, month_short_names_[moy-1]);
       }
-      //! Long month names 
+      //! Long month names
       virtual void do_put_month_long(iter_type& oitr, month_enum moy) const
       {
         this->put_string(oitr, month_long_names_[moy-1]);
@@ -310,7 +311,7 @@ namespace date_time {
       const charT* const* weekday_long_names_;
       charT separator_char_[2];
       ymd_order_spec order_spec_;
-      month_format_spec month_format_spec_;      
+      month_format_spec month_format_spec_;
     };
 
 } } //namespace boost::date_time

include/boost/date_time/date_parsing.hpp

@@ -2,22 +2,25 @@
 #define _DATE_TIME_DATE_PARSING_HPP___
 
 /* Copyright (c) 2002,2003,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$
  */
 
-#include "boost/tokenizer.hpp"
-#include "boost/lexical_cast.hpp"
-#include "boost/date_time/compiler_config.hpp"
-#include "boost/date_time/parse_format_base.hpp"
+#include <map>
 #include <string>
+#include <sstream>
 #include <iterator>
 #include <algorithm>
+#include <boost/tokenizer.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/parse_format_base.hpp>
+#include <boost/date_time/period.hpp>
 
-#if defined(BOOST_NO_STD_LOCALE)
+#if defined(BOOST_DATE_TIME_NO_LOCALE)
 #include <cctype> // ::tolower(int)
 #else
 #include <locale> // std::tolower(char, locale)
@@ -29,90 +32,113 @@ namespace date_time {
   //! A function to replace the std::transform( , , ,tolower) construct
   /*! This function simply takes a string, and changes all the characters
    * in that string to lowercase (according to the default system locale).
-   * In the event that a compiler does not support locales, the old 
+   * In the event that a compiler does not support locales, the old
    * C style tolower() is used.
    */
   inline
-  std::string 
-  convert_to_lower(const std::string& inp) {
-    std::string tmp;
-    unsigned i = 0;
-#if defined(BOOST_NO_STD_LOCALE)
-    while(i < inp.length()) {
-      tmp += static_cast<char>(std::tolower(inp.at(i++)));
+  std::string
+  convert_to_lower(std::string inp)
+  {
+#if !defined(BOOST_DATE_TIME_NO_LOCALE)
+    const std::locale loc(std::locale::classic());
+#endif
+    std::string::size_type i = 0, n = inp.length();
+    for (; i < n; ++i) {
+      inp[i] =
+#if defined(BOOST_DATE_TIME_NO_LOCALE)
+        static_cast<char>(std::tolower(inp[i]));
 #else
-      static const std::locale loc(std::locale::classic());
-      while(i < inp.length()) {
         // tolower and others were brought in to std for borland >= v564
         // in compiler_config.hpp
-        std::string::value_type c(inp.at(i++));
-        tmp += std::tolower(c, loc);
+        std::tolower(inp[i], loc);
 #endif
-        
-      }
-      return tmp;
     }
-    
+    return inp;
+  }
+
     //! Helper function for parse_date.
-    /* Used by-value parameter because we change the string and may
-     * want to preserve the original argument */
     template<class month_type>
-    unsigned short 
-    month_str_to_ushort(std::string s) {
+    inline unsigned short
+    month_str_to_ushort(std::string const& s) {
       if((s.at(0) >= '0') && (s.at(0) <= '9')) {
         return boost::lexical_cast<unsigned short>(s);
-      } 
+      }
       else {
-        s = convert_to_lower(s);
-        typename month_type::month_map_ptr_type ptr = month_type::get_month_map_ptr();
-        typename month_type::month_map_type::iterator iter = ptr->find(s);
-        if(iter != ptr->end()) { // required for STLport
-          return iter->second;
+        std::string str = convert_to_lower(s);
+        //c++98 support
+#if defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
+        static std::map<std::string, unsigned short> month_map;
+        typedef std::map<std::string, unsigned short>::value_type vtype;
+        if( month_map.empty() ) {
+          month_map.insert( vtype("jan", static_cast<unsigned short>(1)) );
+          month_map.insert( vtype("january", static_cast<unsigned short>(1)) );
+          month_map.insert( vtype("feb", static_cast<unsigned short>(2)) );
+          month_map.insert( vtype("february", static_cast<unsigned short>(2)) );
+          month_map.insert( vtype("mar", static_cast<unsigned short>(3)) );
+          month_map.insert( vtype("march", static_cast<unsigned short>(3)) );
+          month_map.insert( vtype("apr", static_cast<unsigned short>(4)) );
+          month_map.insert( vtype("april", static_cast<unsigned short>(4)) );
+          month_map.insert( vtype("may", static_cast<unsigned short>(5)) );
+          month_map.insert( vtype("jun", static_cast<unsigned short>(6)) );
+          month_map.insert( vtype("june", static_cast<unsigned short>(6)) );
+          month_map.insert( vtype("jul", static_cast<unsigned short>(7)) );
+          month_map.insert( vtype("july", static_cast<unsigned short>(7)) );
+          month_map.insert( vtype("aug", static_cast<unsigned short>(8)) );
+          month_map.insert( vtype("august", static_cast<unsigned short>(8)) );
+          month_map.insert( vtype("sep", static_cast<unsigned short>(9)) );
+          month_map.insert( vtype("september", static_cast<unsigned short>(9)) );
+          month_map.insert( vtype("oct", static_cast<unsigned short>(10)) );
+          month_map.insert( vtype("october", static_cast<unsigned short>(10)) );
+          month_map.insert( vtype("nov", static_cast<unsigned short>(11)) );
+          month_map.insert( vtype("november", static_cast<unsigned short>(11)) );
+          month_map.insert( vtype("dec", static_cast<unsigned short>(12)) );
+          month_map.insert( vtype("december", static_cast<unsigned short>(12)) );
+        }
+#else  //c+11 and beyond
+        static std::map<std::string, unsigned short> month_map =
+          { { "jan", static_cast<unsigned short>(1) },  { "january",   static_cast<unsigned short>(1) },
+            { "feb", static_cast<unsigned short>(2) },  { "february",  static_cast<unsigned short>(2) },
+            { "mar", static_cast<unsigned short>(3) },  { "march",     static_cast<unsigned short>(3) },
+            { "apr", static_cast<unsigned short>(4) },  { "april",     static_cast<unsigned short>(4) },
+            { "may", static_cast<unsigned short>(5) },
+            { "jun", static_cast<unsigned short>(6) },  { "june",      static_cast<unsigned short>(6) },
+            { "jul", static_cast<unsigned short>(7) },  { "july",      static_cast<unsigned short>(7) },
+            { "aug", static_cast<unsigned short>(8) },  { "august",    static_cast<unsigned short>(8) },
+            { "sep", static_cast<unsigned short>(9) },  { "september", static_cast<unsigned short>(9) },
+            { "oct", static_cast<unsigned short>(10) }, { "october",   static_cast<unsigned short>(10)},
+            { "nov", static_cast<unsigned short>(11) }, { "november",  static_cast<unsigned short>(11)},
+            { "dec", static_cast<unsigned short>(12) }, { "december",  static_cast<unsigned short>(12)}
+          };
+#endif
+        std::map<std::string, unsigned short>::const_iterator mitr = month_map.find( str );
+        if ( mitr !=  month_map.end() ) {
+          return mitr->second;
         }
       }
       return 13; // intentionally out of range - name not found
     }
  
-    //! Find index of a string in either of 2 arrays
-    /*! find_match searches both arrays for a match to 's'. Indexing of the 
-     * arrays is from 0 to 'limit'. The index of the match is returned.
-     * Ex. "Jan" returns 0, "Dec" returns 11, "Tue" returns 2.
-     * 'limit' can be sent in with: greg_month::max(), 
-     * greg_weekday::max() or date_time::NumSpecialValues */
-    template<class charT>
-    short find_match(const charT* const* short_names, 
-                     const charT* const* long_names, 
-                     short limit,
-                     const std::basic_string<charT>& s) {
-      for(short i = 0; i <= limit; ++i){
-        if(short_names[i] == s || long_names[i] == s){
-          return i;
-        }
-      }
-      return static_cast<short>(limit + 1); // not-found, return a value out of range
-    }
-    
+
     //! Generic function to parse a delimited date (eg: 2002-02-10)
     /*! Accepted formats are: "2003-02-10" or " 2003-Feb-10" or
-     * "2003-Feburary-10" 
-     * The order in which the Month, Day, & Year appear in the argument 
-     * string can be accomodated by passing in the appropriate ymd_order_spec 
+     * "2003-Feburary-10"
+     * The order in which the Month, Day, & Year appear in the argument
+     * string can be accomodated by passing in the appropriate ymd_order_spec
      */
     template<class date_type>
     date_type
     parse_date(const std::string& s, int order_spec = ymd_order_iso) {
-      std::string spec_str("");
+      std::string spec_str;
       if(order_spec == ymd_order_iso) {
         spec_str = "ymd";
-      } 
+      }
       else if(order_spec == ymd_order_dmy) {
         spec_str = "dmy";
-      } 
+      }
       else { // (order_spec == ymd_order_us)
         spec_str = "mdy";
       }
-      
-      typedef typename date_type::year_type year_type;
+
       typedef typename date_type::month_type month_type;
       unsigned pos = 0;
       unsigned short year(0), month(0), day(0);
@@ -128,49 +154,49 @@ namespace date_time {
       const char sep_char[] = {',','-','.',' ','/','\0'};
       char_separator_type sep(sep_char);
       tokenizer tok(s,sep);
-      for(tokenizer_iterator beg=tok.begin(); 
-          beg!=tok.end() && pos < spec_str.size(); 
+      for(tokenizer_iterator beg=tok.begin();
+          beg!=tok.end() && pos < spec_str.size();
           ++beg, ++pos) {
         switch(spec_str.at(pos)) {
-          case 'y': 
+          case 'y':
           {
             year = boost::lexical_cast<unsigned short>(*beg);
             break;
           }
-          case 'm': 
+          case 'm':
           {
             month = month_str_to_ushort<month_type>(*beg);
             break;
           }
-          case 'd': 
+          case 'd':
           {
             day = boost::lexical_cast<unsigned short>(*beg);
             break;
           }
+          default: break;
         } //switch
       }
       return date_type(year, month, day);
     }
-    
+
     //! Generic function to parse undelimited date (eg: 20020201)
     template<class date_type>
     date_type
     parse_undelimited_date(const std::string& s) {
       int offsets[] = {4,2,2};
       int pos = 0;
-      typedef typename date_type::year_type year_type;
       //typename date_type::ymd_type ymd((year_type::min)(),1,1);
       unsigned short y = 0, m = 0, d = 0;
-      
-      /* The two bool arguments state that parsing will not wrap 
-       * (only the first 8 characters will be parsed) and partial 
-       * strings will not be parsed. 
+
+      /* The two bool arguments state that parsing will not wrap
+       * (only the first 8 characters will be parsed) and partial
+       * strings will not be parsed.
        * Ex:
        * "2005121" will parse 2005 & 12, but not the "1" */
       boost::offset_separator osf(offsets, offsets+3, false, false);
-      
-      typedef typename boost::tokenizer<boost::offset_separator, 
-                                        std::basic_string<char>::const_iterator, 
+
+      typedef typename boost::tokenizer<boost::offset_separator,
+                                        std::basic_string<char>::const_iterator,
                                         std::basic_string<char> > tokenizer_type;
       tokenizer_type tok(s, osf);
       for(typename tokenizer_type::iterator ti=tok.begin(); ti!=tok.end();++ti) {
@@ -179,39 +205,40 @@ namespace date_time {
         case 0: y = i; break;
         case 1: m = i; break;
         case 2: d = i; break;
+        default:       break;
         }
         pos++;
       }
       return date_type(y,m,d);
     }
-    
+
     //! Helper function for 'date gregorian::from_stream()'
     /*! Creates a string from the iterators that reference the
-     * begining & end of a char[] or string. All elements are 
+     * begining & end of a char[] or string. All elements are
      * used in output string */
     template<class date_type, class iterator_type>
-    inline 
+    inline
     date_type
-    from_stream_type(iterator_type& beg, 
-                     iterator_type& end,
-                     char) 
+    from_stream_type(iterator_type& beg,
+                     iterator_type const& end,
+                     char)
     {
-      std::stringstream ss("");
+      std::ostringstream ss;
       while(beg != end) {
         ss << *beg++;
       }
       return parse_date<date_type>(ss.str());
     }
- 
+
     //! Helper function for 'date gregorian::from_stream()'
     /*! Returns the first string found in the stream referenced by the
      * begining & end iterators */
     template<class date_type, class iterator_type>
-    inline 
+    inline
     date_type
-    from_stream_type(iterator_type& beg, 
-                     iterator_type& end,
-                     std::string) 
+    from_stream_type(iterator_type& beg,
+                     iterator_type const& /* end */,
+                     std::string const&)
     {
       return parse_date<date_type>(*beg);
     }
@@ -220,22 +247,30 @@ namespace date_time {
      * parse_date<>()? In the mean time this gets us started... */
     //! Helper function for 'date gregorian::from_stream()'
     /*! Creates a string from the iterators that reference the
-     * begining & end of a wstring. All elements are 
+     * begining & end of a wstring. All elements are
      * used in output string */
     template<class date_type, class iterator_type>
-    inline 
-    date_type from_stream_type(iterator_type& beg, 
-                               iterator_type& end,
-                               wchar_t) 
+    inline
+    date_type from_stream_type(iterator_type& beg,
+                               iterator_type const& end,
+                               wchar_t)
     {
-      std::stringstream ss("");
-      while(beg != end) {
+      std::ostringstream ss;
 #if !defined(BOOST_DATE_TIME_NO_LOCALE)
-        ss << std::use_facet<std::ctype<wchar_t> >(std::locale()).narrow(*beg++, 'X'); // 'X' will cause exception to be thrown
-#else
-        ss << ss.narrow(*beg++, 'X');
-#endif
+      std::locale loc;
+      std::ctype<wchar_t> const& fac = std::use_facet<std::ctype<wchar_t> >(loc);
+      while(beg != end) {
+        ss << fac.narrow(*beg++, 'X'); // 'X' will cause exception to be thrown
       }
+#else
+      while(beg != end) {
+        char c = 'X'; // 'X' will cause exception to be thrown
+        const wchar_t wc = *beg++;
+        if (wc >= 0 && wc <= 127)
+          c = static_cast< char >(wc);
+        ss << c;
+      }
+#endif
       return parse_date<date_type>(ss.str());
     }
 #ifndef BOOST_NO_STD_WSTRING
@@ -243,21 +278,29 @@ namespace date_time {
     /*! Creates a string from the first wstring found in the stream
      * referenced by the begining & end iterators */
     template<class date_type, class iterator_type>
-    inline 
+    inline
     date_type
-    from_stream_type(iterator_type& beg, 
-                     iterator_type& end,
-                     std::wstring) {
+    from_stream_type(iterator_type& beg,
+                     iterator_type const& /* end */,
+                     std::wstring const&) {
       std::wstring ws = *beg;
-      std::stringstream ss("");
+      std::ostringstream ss;
       std::wstring::iterator wsb = ws.begin(), wse = ws.end();
-      while(wsb != wse) {
 #if !defined(BOOST_DATE_TIME_NO_LOCALE)
-        ss << std::use_facet<std::ctype<wchar_t> >(std::locale()).narrow(*wsb++, 'X'); // 'X' will cause exception to be thrown
-#else
-        ss << ss.narrow(*wsb++, 'X'); // 'X' will cause exception to be thrown
-#endif
+      std::locale loc;
+      std::ctype<wchar_t> const& fac = std::use_facet<std::ctype<wchar_t> >(loc);
+      while(wsb != wse) {
+        ss << fac.narrow(*wsb++, 'X'); // 'X' will cause exception to be thrown
       }
+#else
+      while(wsb != wse) {
+        char c = 'X'; // 'X' will cause exception to be thrown
+        const wchar_t wc = *wsb++;
+        if (wc >= 0 && wc <= 127)
+          c = static_cast< char >(wc);
+        ss << c;
+      }
+#endif
       return parse_date<date_type>(ss.str());
     }
 #endif // BOOST_NO_STD_WSTRING
@@ -266,30 +309,30 @@ namespace date_time {
 #else
     //! function called by wrapper functions: date_period_from_(w)string()
     template<class date_type, class charT>
-    period<date_type, typename date_type::duration_type> 
+    period<date_type, typename date_type::duration_type>
     from_simple_string_type(const std::basic_string<charT>& s){
       typedef typename std::basic_string<charT>::traits_type traits_type;
       typedef typename boost::char_separator<charT, traits_type> char_separator;
-      typedef typename boost::tokenizer<char_separator, 
-                                        typename std::basic_string<charT>::const_iterator, 
+      typedef typename boost::tokenizer<char_separator,
+                                        typename std::basic_string<charT>::const_iterator,
                                         std::basic_string<charT> > tokenizer;
       const charT sep_list[4] = {'[','/',']','\0'};
       char_separator sep(sep_list);
       tokenizer tokens(s, sep);
-      typename tokenizer::iterator tok_it = tokens.begin(); 
+      typename tokenizer::iterator tok_it = tokens.begin();
       std::basic_string<charT> date_string = *tok_it;
       // get 2 string iterators and generate a date from them
-      typename std::basic_string<charT>::iterator date_string_start = date_string.begin(), 
-                                                  date_string_end = date_string.end(); 
+      typename std::basic_string<charT>::iterator date_string_start = date_string.begin(),
+                                                  date_string_end = date_string.end();
       typedef typename std::iterator_traits<typename std::basic_string<charT>::iterator>::value_type value_type;
       date_type d1 = from_stream_type<date_type>(date_string_start, date_string_end, value_type());
       date_string = *(++tok_it); // next token
-      date_string_start = date_string.begin(), date_string_end = date_string.end(); 
+      date_string_start = date_string.begin(), date_string_end = date_string.end();
       date_type d2 = from_stream_type<date_type>(date_string_start, date_string_end, value_type());
-      return period<date_type, typename date_type::duration_type>(d1, d2); 
+      return period<date_type, typename date_type::duration_type>(d1, d2);
     }
 #endif
-    
+
 } } //namespace date_time
 
 

include/boost/date_time/dst_rules.hpp

@@ -2,7 +2,7 @@
 #define DATE_TIME_DST_RULES_HPP__
 
 /* Copyright (c) 2002,2003, 2007 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
@@ -21,12 +21,12 @@
 namespace boost {
   namespace date_time {
 
-    enum time_is_dst_result {is_not_in_dst, is_in_dst, 
+    enum time_is_dst_result {is_not_in_dst, is_in_dst,
                              ambiguous, invalid_time_label};
 
 
     //! Dynamic class used to caluclate dst transition information
-    template<class date_type_, 
+    template<class date_type_,
              class time_duration_type_>
     class dst_calculator
     {
@@ -37,14 +37,14 @@ namespace boost {
       //! Check the local time offset when on dst start day
       /*! On this dst transition, the time label between
        *  the transition boundary and the boudary + the offset
-       *  are invalid times.  If before the boundary then still 
-       *  not in dst.  
+       *  are invalid times.  If before the boundary then still
+       *  not in dst.
        *@param time_of_day Time offset in the day for the local time
        *@param dst_start_offset_minutes Local day offset for start of dst
        *@param dst_length_minutes Number of minutes to adjust clock forward
        *@retval status of time label w.r.t. dst
        */
-      static time_is_dst_result 
+      static time_is_dst_result
       process_local_dst_start_day(const time_duration_type& time_of_day,
                                   unsigned int dst_start_offset_minutes,
                                   long dst_length_minutes)
@@ -57,19 +57,19 @@ namespace boost {
         if (time_of_day >= time_duration_type(0,offset,0)) {
           return is_in_dst;
         }
-        return invalid_time_label; 
+        return invalid_time_label;
       }
 
       //! Check the local time offset when on the last day of dst
       /*! This is the calculation for the DST end day.  On that day times
-       *  prior to the conversion time - dst_length (1 am in US) are still 
-       *  in dst.  Times between the above and the switch time are 
+       *  prior to the conversion time - dst_length (1 am in US) are still
+       *  in dst.  Times between the above and the switch time are
        *  ambiguous.  Times after the start_offset are not in dst.
        *@param time_of_day Time offset in the day for the local time
        *@param dst_end_offset_minutes Local time of day for end of dst
        *@retval status of time label w.r.t. dst
        */
-      static time_is_dst_result 
+      static time_is_dst_result
       process_local_dst_end_day(const time_duration_type& time_of_day,
                                 unsigned int dst_end_offset_minutes,
                                 long dst_length_minutes)
@@ -86,32 +86,32 @@ namespace boost {
       }
 
       //! Calculates if the given local time is dst or not
-      /*! Determines if the time is really in DST or not.  Also checks for 
+      /*! Determines if the time is really in DST or not.  Also checks for
        *  invalid and ambiguous.
        *  @param current_day The day to check for dst
-       *  @param time_of_day Time offset within the day to check 
+       *  @param time_of_day Time offset within the day to check
        *  @param dst_start_day  Starting day of dst for the given locality
        *  @param dst_start_offset Time offset within day for dst boundary
        *  @param dst_end_day    Ending day of dst for the given locality
        *  @param dst_end_offset Time offset within day given in dst for dst boundary
-       *  @param dst_length lenght of dst adjusment
+       *  @param dst_length_minutes length of dst adjusment
        *  @retval The time is either ambiguous, invalid, in dst, or not in dst
        */
-      static time_is_dst_result 
+      static time_is_dst_result
       local_is_dst(const date_type& current_day,
                    const time_duration_type& time_of_day,
                    const date_type& dst_start_day,
                    const time_duration_type& dst_start_offset,
                    const date_type& dst_end_day,
                    const time_duration_type& dst_end_offset,
-                   const time_duration_type& dst_length_minutes)
+                   const time_duration_type& dst_length)
       {
-        unsigned int start_minutes = 
-          dst_start_offset.hours() * 60 + dst_start_offset.minutes();
-        unsigned int end_minutes = 
-          dst_end_offset.hours() * 60 + dst_end_offset.minutes();
-        long length_minutes =  
-          dst_length_minutes.hours() * 60 + dst_length_minutes.minutes();
+        unsigned int start_minutes = static_cast<unsigned>(
+          dst_start_offset.hours() * 60 + dst_start_offset.minutes());
+        unsigned int end_minutes = static_cast<unsigned>(
+          dst_end_offset.hours() * 60 + dst_end_offset.minutes());
+        long length_minutes = static_cast<long>(
+          dst_length.hours() * 60 + dst_length.minutes());
 
         return local_is_dst(current_day, time_of_day,
                             dst_start_day, start_minutes,
@@ -120,20 +120,20 @@ namespace boost {
       }
 
       //! Calculates if the given local time is dst or not
-      /*! Determines if the time is really in DST or not.  Also checks for 
+      /*! Determines if the time is really in DST or not.  Also checks for
        *  invalid and ambiguous.
        *  @param current_day The day to check for dst
-       *  @param time_of_day Time offset within the day to check 
+       *  @param time_of_day Time offset within the day to check
        *  @param dst_start_day  Starting day of dst for the given locality
-       *  @param dst_start_offset_minutes Offset within day for dst 
+       *  @param dst_start_offset_minutes Offset within day for dst
        *         boundary (eg 120 for US which is 02:00:00)
        *  @param dst_end_day    Ending day of dst for the given locality
-       *  @param dst_end_offset_minutes Offset within day given in dst for dst 
+       *  @param dst_end_offset_minutes Offset within day given in dst for dst
        *         boundary (eg 120 for US which is 02:00:00)
        *  @param dst_length_minutes Length of dst adjusment (eg: 60 for US)
        *  @retval The time is either ambiguous, invalid, in dst, or not in dst
        */
-      static time_is_dst_result 
+      static time_is_dst_result
       local_is_dst(const date_type& current_day,
                    const time_duration_type& time_of_day,
                    const date_type& dst_start_day,
@@ -165,7 +165,7 @@ namespace boost {
                                              dst_start_offset_minutes,
                                              dst_length_minutes);
         }
-      
+
         if (current_day == dst_end_day) {
           return process_local_dst_end_day(time_of_day,
                                            dst_end_offset_minutes,
@@ -183,29 +183,29 @@ namespace boost {
      * calculation at compile time covering all the cases.  Unfortunately
      * because of the number of dimensions related to daylight savings
      * calculation the number of parameters is high.  In addition, the
-     * start and end transition rules are complex types that specify 
+     * start and end transition rules are complex types that specify
      * an algorithm for calculation of the starting day and ending
-     * day of daylight savings time including the month and day 
+     * day of daylight savings time including the month and day
      * specifications (eg: last sunday in October).
      *
      * @param date_type A type that represents dates, typically gregorian::date
      * @param time_duration_type Used for the offset in the day calculations
-     * @param dst_traits A set of traits that define the rules of dst 
+     * @param dst_traits A set of traits that define the rules of dst
      *        calculation.  The dst_trait must include the following:
      * start_rule_functor - Rule to calculate the starting date of a
      *                      dst transition (eg: last_kday_of_month).
-     * start_day - static function that returns month of dst start for 
+     * start_day - static function that returns month of dst start for
      *             start_rule_functor
-     * start_month -static function that returns day or day of week for 
+     * start_month -static function that returns day or day of week for
      *              dst start of dst
      * end_rule_functor - Rule to calculate the end of dst day.
      * end_day - static fucntion that returns end day for end_rule_functor
      * end_month - static function that returns end month for end_rule_functor
      * dst_start_offset_minutes - number of minutes from start of day to transition to dst -- 120 (or 2:00 am) is typical for the U.S. and E.U.
-     * dst_start_offset_minutes - number of minutes from start of day to transition off of dst -- 180 (or 3:00 am) is typical for E.U. 
+     * dst_start_offset_minutes - number of minutes from start of day to transition off of dst -- 180 (or 3:00 am) is typical for E.U.
      * dst_length_minutes - number of minutes that dst shifts clock
      */
-    template<class date_type, 
+    template<class date_type,
              class time_duration_type,
              class dst_traits>
     class dst_calc_engine
@@ -216,12 +216,12 @@ namespace boost {
       typedef dst_calculator<date_type, time_duration_type> dstcalc;
 
       //! Calculates if the given local time is dst or not
-      /*! Determines if the time is really in DST or not.  Also checks for 
+      /*! Determines if the time is really in DST or not.  Also checks for
        *  invalid and ambiguous.
        *  @retval The time is either ambiguous, invalid, in dst, or not in dst
        */
       static time_is_dst_result local_is_dst(const date_type& d,
-                                             const time_duration_type& td) 
+                                             const time_duration_type& td)
       {
 
         year_type y = d.year();
@@ -230,10 +230,10 @@ namespace boost {
         return dstcalc::local_is_dst(d,td,
                                      dst_start,
                                      dst_traits::dst_start_offset_minutes(),
-                                     dst_end, 
-                                     dst_traits::dst_end_offset_minutes(), 
+                                     dst_end,
+                                     dst_traits::dst_end_offset_minutes(),
                                      dst_traits::dst_shift_length_minutes());
-      
+
       }
 
       static bool is_dst_boundary_day(date_type d)
@@ -244,14 +244,14 @@ namespace boost {
       }
 
       //! The time of day for the dst transition (eg: typically 01:00:00 or 02:00:00)
-      static time_duration_type dst_offset() 
+      static time_duration_type dst_offset()
       {
         return time_duration_type(0,dst_traits::dst_shift_length_minutes(),0);
       }
 
       static date_type local_dst_start_day(year_type year)
       {
-        return dst_traits::local_dst_start_day(year);      
+        return dst_traits::local_dst_start_day(year);
       }
 
       static date_type local_dst_end_day(year_type year)
@@ -267,11 +267,11 @@ namespace boost {
      * In 2007 US/Canada DST rules changed
      * (http://en.wikipedia.org/wiki/Energy_Policy_Act_of_2005#Change_to_daylight_saving_time).
      */
-    template<class date_type_, 
+    template<class date_type_,
              class time_duration_type_,
-             unsigned int dst_start_offset_minutes=120, //from start of day 
+             unsigned int dst_start_offset_minutes=120, //from start of day
              short dst_length_minutes=60>  //1 hour == 60 min in US
-    class us_dst_rules 
+    class us_dst_rules
     {
     public:
       typedef time_duration_type_ time_duration_type;
@@ -284,12 +284,12 @@ namespace boost {
       typedef dst_calculator<date_type, time_duration_type> dstcalc;
 
       //! Calculates if the given local time is dst or not
-      /*! Determines if the time is really in DST or not.  Also checks for 
+      /*! Determines if the time is really in DST or not.  Also checks for
        *  invalid and ambiguous.
        *  @retval The time is either ambiguous, invalid, in dst, or not in dst
        */
       static time_is_dst_result local_is_dst(const date_type& d,
-                                             const time_duration_type& td) 
+                                             const time_duration_type& td)
       {
 
         year_type y = d.year();
@@ -297,9 +297,9 @@ namespace boost {
         date_type dst_end   = local_dst_end_day(y);
         return dstcalc::local_is_dst(d,td,
                                      dst_start,dst_start_offset_minutes,
-                                     dst_end, dst_start_offset_minutes, 
+                                     dst_end, dst_start_offset_minutes,
                                      dst_length_minutes);
-      
+
       }
 
 
@@ -314,12 +314,12 @@ namespace boost {
       {
         if (year >= year_type(2007)) {
           //second sunday in march
-          nkday ssim(nkday::second, Sunday, gregorian::Mar);
-          return ssim.get_date(year);      
+          nkday ssim(nkday::second, Sunday, date_time::Mar);
+          return ssim.get_date(year);
         } else {
           //first sunday in april
-          fkday fsia(Sunday, gregorian::Apr);
-          return fsia.get_date(year);      
+          fkday fsia(Sunday, date_time::Apr);
+          return fsia.get_date(year);
         }
       }
 
@@ -327,11 +327,11 @@ namespace boost {
       {
         if (year >= year_type(2007)) {
           //first sunday in november
-          fkday fsin(Sunday, gregorian::Nov);
-          return fsin.get_date(year);      
+          fkday fsin(Sunday, date_time::Nov);
+          return fsin.get_date(year);
         } else {
           //last sunday in october
-          lkday lsio(Sunday, gregorian::Oct);
+          lkday lsio(Sunday, date_time::Oct);
           return lsio.get_date(year);
         }
       }
@@ -358,25 +358,25 @@ namespace boost {
       //! Calculates if the given local time is dst or not
       /*! @retval Always is_not_in_dst since this is for zones without dst
        */
-      static time_is_dst_result local_is_dst(const date_type&, 
-                                             const time_duration_type&) 
-      {
-        return is_not_in_dst;
-      }
-    
-      //! Calculates if the given utc time is in dst
-      static time_is_dst_result utc_is_dst(const date_type&, 
-                                           const time_duration_type&) 
+      static time_is_dst_result local_is_dst(const date_type&,
+                                             const time_duration_type&)
       {
         return is_not_in_dst;
       }
 
-      static bool is_dst_boundary_day(date_type d)
+      //! Calculates if the given utc time is in dst
+      static time_is_dst_result utc_is_dst(const date_type&,
+                                           const time_duration_type&)
+      {
+        return is_not_in_dst;
+      }
+
+      static bool is_dst_boundary_day(date_type /*d*/)
       {
         return false;
       }
 
-      static time_duration_type dst_offset() 
+      static time_duration_type dst_offset()
       {
         return time_duration_type(0,0,0);
       }

include/boost/date_time/dst_transition_generators.hpp

@@ -7,7 +7,7 @@
 #ifndef DATE_TIME_DATE_DST_TRANSITION_DAY_GEN_HPP__
 #define DATE_TIME_DATE_DST_TRANSITION_DAY_GEN_HPP__
 
-
+#include <string>
 
 namespace boost {
 namespace date_time {
@@ -18,7 +18,7 @@ namespace date_time {
     {
     public:
       typedef typename date_type::year_type year_type;
-      virtual ~dst_day_calc_rule() {};
+      virtual ~dst_day_calc_rule() {}
       virtual date_type start_day(year_type y) const=0;
       virtual std::string start_rule_as_string() const=0;
       virtual date_type end_day(year_type y) const=0;
@@ -29,7 +29,7 @@ namespace date_time {
     //! Canonical form for a class that provides day rule calculation
     /*! This class is used to generate specific sets of dst rules
      *  
-     *@param spec Provides a specifiction of the function object types used
+     *@tparam spec Provides a specifiction of the function object types used
      *            to generate start and end days of daylight savings as well
      *            as the date type.
      */

include/boost/date_time/filetime_functions.hpp

@@ -10,66 +10,72 @@
  */
 
 /*! @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>
+
 #include <boost/cstdint.hpp>
 #include <boost/date_time/time.hpp>
-
+#include <boost/date_time/date_defs.hpp>
 
 namespace boost {
+
 namespace date_time {
 
+//! 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::detail::winapi::FILETIME_ 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;
 
-  //! 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;
+    // 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 microsec_clock::file_time_to_microseconds function. This allows to
+    // avoid integer wrapping for dates before 1970-Jan-01.
 
-    /* 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
+    // 100-nanos since 1601-Jan-01
+    uint64_t ft_as_integer = (static_cast< uint64_t >(ft.dwHighDateTime) << 32) | static_cast< uint64_t >(ft.dwLowDateTime);
+    uint64_t sec = ft_as_integer / 10000000UL;
+    uint32_t sub_sec = static_cast< uint32_t >(ft_as_integer % 10000000UL) // 100-nanoseconds since the last second
+#if !defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
+        / 10U; // microseconds since the last second
 #else
-    uint64_t sub_sec = (filetime % 10000000) / 10; // truncate to microseconds
+        * 100U; // 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
 

include/boost/date_time/find_match.hpp

@@ -0,0 +1,42 @@
+#ifndef _BOOST_DATE_TIME_FIND_MATCH_HPP___
+#define _BOOST_DATE_TIME_FIND_MATCH_HPP___
+
+/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
+ * 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$
+ */
+
+#include <string>
+
+namespace boost {
+namespace date_time {
+
+
+    //! Find index of a string in either of 2 arrays
+    /*! find_match searches both arrays for a match to 's'. Both arrays
+     * must contain 'size' elements. The index of the match is returned.
+     * If no match is found, 'size' is returned.
+     * Ex. "Jan" returns 0, "Dec" returns 11, "Tue" returns 2.
+     * 'size' can be sent in with: (greg_month::max)() (which 12),
+     * (greg_weekday::max)() + 1 (which is 7) or date_time::NumSpecialValues */
+    template<class charT>
+    short find_match(const charT* const* short_names,
+                     const charT* const* long_names,
+                     short size,
+                     const std::basic_string<charT>& s) {
+      for(short i = 0; i < size; ++i){
+        if(short_names[i] == s || long_names[i] == s){
+          return i;
+        }
+      }
+      return size; // not-found, return a value out of range
+    }
+
+
+} } //namespace date_time
+
+
+#endif

include/boost/date_time/format_date_parser.hpp

@@ -3,7 +3,7 @@
 #define DATE_TIME_FORMAT_DATE_PARSER_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
@@ -17,13 +17,26 @@
 #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
-/*! Will consume 'length' number of characters from stream. Consumed 
- * character are transfered to parse_match_result struct. 
- * Returns '-1' if no number can be parsed or incorrect number of 
+/*! Will consume 'length' number of characters from stream. Consumed
+ * character are transfered to parse_match_result struct.
+ * Returns '-1' if no number can be parsed or incorrect number of
  * digits in stream. */
 template<typename int_type, typename charT>
 inline
@@ -37,12 +50,12 @@ fixed_string_to_int(std::istreambuf_iterator<charT>& itr,
   //typedef std::basic_string<charT>  string_type;
   unsigned int j = 0;
   //string_type s;
-  while (j < length && itr != stream_end && 
+  while (j < length && itr != stream_end &&
       (std::isdigit(*itr) || *itr == fill_char)) {
     if(*itr == fill_char) {
-      /* Since a fill_char can be anything, we convert it to a zero. 
+      /* Since a fill_char can be anything, we convert it to a zero.
        * lexical_cast will behave predictably when zero is used as fill. */
-      mr.cache += ('0'); 
+      mr.cache += ('0');
     }
     else {
       mr.cache += (*itr);
@@ -50,23 +63,23 @@ fixed_string_to_int(std::istreambuf_iterator<charT>& itr,
     itr++;
     j++;
   }
-  int_type i = -1;
+  int_type i = static_cast<int_type>(-1);
   // mr.cache will hold leading zeros. size() tells us when input is too short.
   if(mr.cache.size() < length) {
     return i;
   }
   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;
 }
 
 //! Helper function for parsing fixed length strings into integers
-/*! Will consume 'length' number of characters from stream. Consumed 
- * character are transfered to parse_match_result struct. 
- * Returns '-1' if no number can be parsed or incorrect number of 
+/*! Will consume 'length' number of characters from stream. Consumed
+ * character are transfered to parse_match_result struct.
+ * Returns '-1' if no number can be parsed or incorrect number of
  * digits in stream. */
 template<typename int_type, typename charT>
 inline
@@ -80,26 +93,26 @@ fixed_string_to_int(std::istreambuf_iterator<charT>& itr,
 }
 
 //! Helper function for parsing varied length strings into integers
-/*! Will consume 'max_length' characters from stream only if those 
- * characters are digits. Returns '-1' if no number can be parsed. 
+/*! Will consume 'max_length' characters from stream only if those
+ * characters are digits. Returns '-1' if no number can be parsed.
  * Will not parse a number preceeded by a '+' or '-'. */
 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) {
+  int_type i = static_cast<int_type>(-1);
+  if(!s.empty()) {
     i = boost::lexical_cast<int_type>(s);
   }
   return i;
@@ -120,7 +133,7 @@ var_string_to_int(std::istreambuf_iterator<charT>& itr,
  -  %W - Week number 00 to 53 where Monday is first day of week 1
  -  %x - facet default date representation
  -  %y - Year without the century - eg: 04 for 2004
- -  %Y - Year with century 
+ -  %Y - Year with century
 
  The weekday specifiers (%a and %A) do not add to the date construction,
  but they provide a way to skip over the weekday names for formats that
@@ -129,7 +142,7 @@ var_string_to_int(std::istreambuf_iterator<charT>& itr,
  todo -- Another interesting feature that this approach could provide is
          an option to fill in any missing fields with the current values
          from the clock.  So if you have %m-%d the parser would detect
-         the missing year value and fill it in using the clock. 
+         the missing year value and fill it in using the clock.
 
  todo -- What to do with the %x.  %x in the classic facet is just bad...
 
@@ -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;
@@ -153,7 +166,7 @@ class format_date_parser
   typedef std::vector<std::basic_string<charT> > input_collection_type;
 
   // TODO sv_parser uses its default constructor - write the others
-  
+
   format_date_parser(const string_type& format_str,
                      const input_collection_type& month_short_names,
                      const input_collection_type& month_long_names,
@@ -165,7 +178,7 @@ class format_date_parser
     m_weekday_short_names(weekday_short_names),
     m_weekday_long_names(weekday_long_names)
   {}
-  
+
   format_date_parser(const string_type& format_str,
                      const std::locale& locale) :
     m_format(format_str),
@@ -183,7 +196,7 @@ class format_date_parser
     this->m_weekday_short_names = fdp.m_weekday_short_names;
     this->m_weekday_long_names = fdp.m_weekday_long_names;
   }
-  
+
   string_type format() const
   {
     return m_format;
@@ -212,61 +225,60 @@ class format_date_parser
   }
 
   date_type
-  parse_date(const string_type& value, 
+  parse_date(const string_type& value,
              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);
   }
 
   date_type
-  parse_date(std::istreambuf_iterator<charT>& sitr, 
+  parse_date(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              const special_values_parser<date_type,charT>& sv_parser) const
   {
     return parse_date(sitr, stream_end, m_format, sv_parser);
   }
 
-  /*! Of all the objects that the format_date_parser can parse, only a 
-   * date can be a special value. Therefore, only parse_date checks 
+  /*! Of all the objects that the format_date_parser can parse, only a
+   * date can be a special value. Therefore, only parse_date checks
    * for special_values. */
   date_type
-  parse_date(std::istreambuf_iterator<charT>& sitr, 
+  parse_date(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str,
              const special_values_parser<date_type,charT>& sv_parser) const
   {
     bool use_current_char = false;
-    
-    // skip leading whitespace
-    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-    charT current_char = *sitr;
 
-    short year(0), month(0), day(0), day_of_year(0);// wkday(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. 
+    // skip leading whitespace
+    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
+    short year(0), month(0), day(0), day_of_year(0);// wkday(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.
      * 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);
     day_of_week_type wkday(0);
-    
-    
+
+
     const_itr itr(format_str.begin());
     while (itr != format_str.end() && (sitr != stream_end)) {
       if (*itr == '%') {
-        itr++;
+        if ( ++itr == format_str.end())
+          break;
         if (*itr != '%') {
           switch(*itr) {
-          case 'a': 
+          case 'a':
             {
               //this value is just throw away.  It could be used for
-              //error checking potentially, but it isn't helpful in 
+              //error checking potentially, but it isn't helpful in
               //actually constructing the date - we just need to get it
               //out of the stream
               match_results mr = m_weekday_short_names.match(sitr, stream_end);
@@ -278,15 +290,14 @@ class format_date_parser
               }
               wkday = mr.current_match;
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
             }
-          case 'A': 
+          case 'A':
             {
               //this value is just throw away.  It could be used for
-              //error checking potentially, but it isn't helpful in 
+              //error checking potentially, but it isn't helpful in
               //actually constructing the date - we just need to get it
               //out of the stream
               match_results mr = m_weekday_long_names.match(sitr, stream_end);
@@ -298,12 +309,11 @@ class format_date_parser
               }
               wkday = mr.current_match;
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
             }
-          case 'b': 
+          case 'b':
             {
               match_results mr = m_month_short_names.match(sitr, stream_end);
               if(mr.current_match == match_results::PARSE_ERROR) {
@@ -314,12 +324,11 @@ class format_date_parser
               }
               t_month = month_type(mr.current_match);
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
             }
-          case 'B': 
+          case 'B':
             {
               match_results mr = m_month_long_names.match(sitr, stream_end);
               if(mr.current_match == match_results::PARSE_ERROR) {
@@ -330,12 +339,11 @@ class format_date_parser
               }
               t_month = month_type(mr.current_match);
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
             }
-          case 'd': 
+          case 'd':
             {
               match_results mr;
               day = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2);
@@ -347,7 +355,7 @@ class format_date_parser
               t_day = day_type(day);
               break;
             }
-          case 'e': 
+          case 'e':
             {
               match_results mr;
               day = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2, ' ');
@@ -359,7 +367,7 @@ class format_date_parser
               t_day = day_type(day);
               break;
             }
-          case 'j': 
+          case 'j':
             {
               match_results mr;
               day_of_year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 3);
@@ -373,7 +381,7 @@ class format_date_parser
               t_day_of_year = day_of_year_type(day_of_year);
               break;
             }
-          case 'm': 
+          case 'm':
             {
               match_results mr;
               month = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2);
@@ -385,7 +393,7 @@ class format_date_parser
               t_month = month_type(month);
               break;
             }
-          case 'Y': 
+          case 'Y':
             {
               match_results mr;
               year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 4);
@@ -397,7 +405,7 @@ class format_date_parser
               t_year = year_type(year);
               break;
             }
-          case 'y': 
+          case 'y':
             {
               match_results mr;
               year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2);
@@ -412,139 +420,135 @@ class format_date_parser
             }
           default:
             {} //ignore those we don't understand
-            
+
           }//switch
-          
+
         }
         else { // itr == '%', second consecutive
           sitr++;
         }
-        
+
         itr++; //advance past format specifier
       }
       else {  //skip past chars in format and in buffer
         itr++;
         if (use_current_char) {
           use_current_char = false;
-          current_char = *sitr;
         }
         else {
           sitr++;
         }
       }
     }
-    
+
     if (day_of_year > 0) {
       date_type d(static_cast<unsigned short>(year-1),12,31); //end of prior year
       return d + duration_type(day_of_year);
     }
-    
-    return date_type(t_year, t_month, t_day); // exceptions were thrown earlier 
-                                        // if input was no good 
+
+    return date_type(t_year, t_month, t_day); // exceptions were thrown earlier
+                                        // if input was no good
   }
- 
+
   //! Throws bad_month if unable to parse
   month_type
-  parse_month(std::istreambuf_iterator<charT>& sitr, 
+  parse_month(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str) const
   {
     match_results mr;
     return parse_month(sitr, stream_end, format_str, mr);
   }
- 
+
   //! Throws bad_month if unable to parse
   month_type
-  parse_month(std::istreambuf_iterator<charT>& sitr, 
+  parse_month(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str,
              match_results& mr) const
   {
     bool use_current_char = false;
-    
+
     // skip leading whitespace
-    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-    charT current_char = *sitr;
+    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
 
     short month(0);
-    
+
     const_itr itr(format_str.begin());
     while (itr != format_str.end() && (sitr != stream_end)) {
       if (*itr == '%') {
-        itr++;
+        if ( ++itr == format_str.end())
+          break;
         if (*itr != '%') {
           switch(*itr) {
-          case 'b': 
+          case 'b':
             {
               mr = m_month_short_names.match(sitr, stream_end);
               month = mr.current_match;
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
             }
-          case 'B': 
+          case 'B':
             {
               mr = m_month_long_names.match(sitr, stream_end);
               month = mr.current_match;
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
             }
-          case 'm': 
+          case 'm':
             {
               month = var_string_to_int<short, charT>(sitr, stream_end, 2);
-              // var_string_to_int returns -1 if parse failed. That will 
+              // var_string_to_int returns -1 if parse failed. That will
               // cause a bad_month exception to be thrown so we do nothing here
               break;
             }
           default:
             {} //ignore those we don't understand
-            
+
           }//switch
-          
+
         }
         else { // itr == '%', second consecutive
           sitr++;
         }
-        
+
         itr++; //advance past format specifier
       }
       else {  //skip past chars in format and in buffer
         itr++;
         if (use_current_char) {
           use_current_char = false;
-          current_char = *sitr;
         }
         else {
           sitr++;
         }
       }
     }
-    
+
     return month_type(month); // throws bad_month exception when values are zero
   }
 
   //! Expects 1 or 2 digits 1-31. Throws bad_day_of_month if unable to parse
   day_type
-  parse_var_day_of_month(std::istreambuf_iterator<charT>& sitr, 
+  parse_var_day_of_month(std::istreambuf_iterator<charT>& sitr,
                          std::istreambuf_iterator<charT>& stream_end) const
   {
     // skip leading whitespace
-    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
+    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
 
     return day_type(var_string_to_int<short, charT>(sitr, stream_end, 2));
   }
   //! Expects 2 digits 01-31. Throws bad_day_of_month if unable to parse
   day_type
-  parse_day_of_month(std::istreambuf_iterator<charT>& sitr, 
+  parse_day_of_month(std::istreambuf_iterator<charT>& sitr,
                      std::istreambuf_iterator<charT>& stream_end) const
   {
     // skip leading whitespace
-    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
+    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
 
     //return day_type(var_string_to_int<short, charT>(sitr, stream_end, 2));
     match_results mr;
@@ -552,7 +556,7 @@ class format_date_parser
   }
 
   day_of_week_type
-  parse_weekday(std::istreambuf_iterator<charT>& sitr, 
+  parse_weekday(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str) const
   {
@@ -560,49 +564,47 @@ class format_date_parser
     return parse_weekday(sitr, stream_end, format_str, mr);
   }
   day_of_week_type
-  parse_weekday(std::istreambuf_iterator<charT>& sitr, 
+  parse_weekday(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str,
              match_results& mr) const
   {
     bool use_current_char = false;
-    
+
     // skip leading whitespace
-    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-    charT current_char = *sitr;
+    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
 
     short wkday(0);
-    
+
     const_itr itr(format_str.begin());
     while (itr != format_str.end() && (sitr != stream_end)) {
       if (*itr == '%') {
-        itr++;
+        if ( ++itr == format_str.end())
+          break;
         if (*itr != '%') {
           switch(*itr) {
-          case 'a': 
+          case 'a':
             {
               //this value is just throw away.  It could be used for
-              //error checking potentially, but it isn't helpful in 
+              //error checking potentially, but it isn't helpful in
               //actually constructing the date - we just need to get it
               //out of the stream
               mr = m_weekday_short_names.match(sitr, stream_end);
               wkday = mr.current_match;
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
             }
-          case 'A': 
+          case 'A':
             {
               //this value is just throw away.  It could be used for
-              //error checking potentially, but it isn't helpful in 
+              //error checking potentially, but it isn't helpful in
               //actually constructing the date - we just need to get it
               //out of the stream
               mr = m_weekday_long_names.match(sitr, stream_end);
               wkday = mr.current_match;
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
@@ -615,35 +617,34 @@ class format_date_parser
             }
           default:
             {} //ignore those we don't understand
-            
+
           }//switch
-          
+
         }
         else { // itr == '%', second consecutive
           sitr++;
         }
-        
+
         itr++; //advance past format specifier
       }
       else {  //skip past chars in format and in buffer
         itr++;
         if (use_current_char) {
           use_current_char = false;
-          current_char = *sitr;
         }
         else {
           sitr++;
         }
       }
     }
-    
-    return day_of_week_type(wkday); // throws bad_day_of_month exception 
+
+    return day_of_week_type(wkday); // throws bad_day_of_month exception
                                     // when values are zero
   }
-  
+
   //! throws bad_year if unable to parse
   year_type
-  parse_year(std::istreambuf_iterator<charT>& sitr, 
+  parse_year(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str) const
   {
@@ -653,23 +654,21 @@ class format_date_parser
 
   //! throws bad_year if unable to parse
   year_type
-  parse_year(std::istreambuf_iterator<charT>& sitr, 
+  parse_year(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str,
              match_results& mr) const
   {
-    bool use_current_char = false;
-    
     // skip leading whitespace
-    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-    charT current_char = *sitr;
+    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
 
     unsigned short year(0);
-    
+
     const_itr itr(format_str.begin());
     while (itr != format_str.end() && (sitr != stream_end)) {
       if (*itr == '%') {
-        itr++;
+        if ( ++itr == format_str.end())
+          break;
         if (*itr != '%') {
           //match_results mr;
           switch(*itr) {
@@ -688,32 +687,26 @@ class format_date_parser
             }
           default:
             {} //ignore those we don't understand
-            
+
           }//switch
-          
+
         }
         else { // itr == '%', second consecutive
           sitr++;
         }
-        
+
         itr++; //advance past format specifier
       }
       else {  //skip past chars in format and in buffer
         itr++;
-        if (use_current_char) {
-          use_current_char = false;
-          current_char = *sitr;
-        }
-        else {
-          sitr++;
-        }
+        sitr++;
       }
     }
-    
+
     return year_type(year); // throws bad_year exception when values are zero
   }
-  
-  
+
+
  private:
   string_type m_format;
   parse_tree_type m_month_short_names;

include/boost/date_time/gregorian/conversion.hpp

@@ -2,72 +2,67 @@
 #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$
  */
 
-#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 <cstring>
+#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::memset(&datetm, 0, sizeof(datetm));
     boost::gregorian::date::ymd_type ymd = d.year_month_day();
-    datetm.tm_year = ymd.year-1900; 
-    datetm.tm_mon = ymd.month-1; 
+    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
-

include/boost/date_time/gregorian/formatters.hpp

@@ -65,7 +65,7 @@ namespace gregorian {
     std::basic_string<charT> s(date_time::date_formatter<date,date_time::iso_format<charT>,charT>::date_to_string(d.begin()));
     return s + sep + date_time::date_formatter<date,date_time::iso_format<charT>,charT>::date_to_string(d.last());
   }
-  //! Date period to iso standard format CCYYMMDD/CCYYMMDD. Example: 20021225/20021231
+  //! Date period to ISO 8601 standard format CCYYMMDD/CCYYMMDD. Example: 20021225/20021231
   /*!\ingroup date_format
    */
   inline std::string to_iso_string(const date_period& d) {
@@ -78,7 +78,7 @@ namespace gregorian {
   inline std::basic_string<charT> to_iso_extended_string_type(const date& d) {
     return date_time::date_formatter<date,date_time::iso_extended_format<charT>,charT>::date_to_string(d);
   }
-  //! Convert to iso extended format string CCYY-MM-DD. Example 2002-12-31
+  //! Convert to ISO 8601 extended format string CCYY-MM-DD. Example 2002-12-31
   /*!\ingroup date_format
    */
   inline std::string to_iso_extended_string(const date& d) {
@@ -90,7 +90,7 @@ namespace gregorian {
   inline std::basic_string<charT> to_iso_string_type(const date& d) {
     return date_time::date_formatter<date,date_time::iso_format<charT>,charT>::date_to_string(d);
   }
-  //! Convert to iso standard string YYYYMMDD. Example: 20021231
+  //! Convert to ISO 8601 standard string YYYYMMDD. Example: 20021231
   /*!\ingroup date_format
    */
   inline std::string to_iso_string(const date& d) {

include/boost/date_time/gregorian/formatters_limited.hpp

@@ -35,7 +35,7 @@ namespace gregorian {
     return std::string("[" + d1 + "/" + d2 + "]");
   }
 
-  //! Date period to iso standard format CCYYMMDD/CCYYMMDD. Example: 20021225/20021231
+  //! Date period to ISO 8601 standard format CCYYMMDD/CCYYMMDD. Example: 20021225/20021231
   /*!\ingroup date_format
    */
   inline std::string to_iso_string(const date_period& d) {
@@ -44,14 +44,14 @@ namespace gregorian {
   }
 
 
-  //! Convert to iso extended format string CCYY-MM-DD. Example 2002-12-31
+  //! Convert to ISO 8601 extended format string CCYY-MM-DD. Example 2002-12-31
   /*!\ingroup date_format
    */
   inline std::string to_iso_extended_string(const date& d) {
     return date_time::date_formatter<date,date_time::iso_extended_format<char> >::date_to_string(d);
   }
 
-  //! Convert to iso standard string YYYYMMDD. Example: 20021231
+  //! Convert to ISO 8601 standard string YYYYMMDD. Example: 20021231
   /*!\ingroup date_format
    */
   inline std::string to_iso_string(const date& d) {

include/boost/date_time/gregorian/greg_calendar.hpp

@@ -2,27 +2,29 @@
 #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 
+ * Author: Jeff Garland
  * $Date$
  */
 
-#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/compiler_config.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 BOOST_SYMBOL_VISIBLE 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 +36,14 @@ namespace gregorian {
     //! Date rep implements the traits stuff as well
     typedef fancy_date_rep       date_traits_type;
 
-    
+
   private:
   };
 
 } } //namespace gregorian
-  
+
 
 
 
 #endif
-  
+

include/boost/date_time/gregorian/greg_date.hpp

@@ -1,18 +1,20 @@
 #ifndef GREG_DATE_HPP___
 #define GREG_DATE_HPP___
 
-/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+/* Copyright (c) 2002,2003, 2020 CrystalClear Software, Inc.
+ * 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 
+ * Author: Jeff Garland
  * $Date$
  */
 
-#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/compiler_config.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,13 +29,13 @@ 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>
+  class BOOST_SYMBOL_VISIBLE date : public date_time::date<date, gregorian_calendar, date_duration>
   {
    public:
     typedef gregorian_calendar::year_type year_type;
@@ -46,86 +48,93 @@ namespace gregorian {
     typedef date_duration  duration_type;
 #if !defined(DATE_TIME_NO_DEFAULT_CONSTRUCTOR)
     //! Default constructor constructs with not_a_date_time
-    date():
+    BOOST_CXX14_CONSTEXPR date():
       date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(not_a_date_time))
     {}
 #endif // DATE_TIME_NO_DEFAULT_CONSTRUCTOR
     //! Main constructor with year, month, day
-    date(year_type y, month_type m, day_type d) 
+    BOOST_CXX14_CONSTEXPR 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) 
+    BOOST_CXX14_CONSTEXPR explicit date(const ymd_type& ymd)
       : date_time::date<date, gregorian_calendar, date_duration>(ymd)
     {}
     //! Needed copy constructor
-    explicit date(const date_int_type& rhs):
+    BOOST_CXX14_CONSTEXPR explicit date(const date_int_type& rhs):
       date_time::date<date,gregorian_calendar, date_duration>(rhs)
     {}
     //! Needed copy constructor
-    explicit date(date_rep_type rhs):
+    BOOST_CXX14_CONSTEXPR explicit date(date_rep_type rhs):
       date_time::date<date,gregorian_calendar, date_duration>(rhs)
     {}
     //! Constructor for infinities, not a date, max and min date
-    explicit date(special_values sv):
-      date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(sv))
-    {
-      if (sv == min_date_time)
-      {
-        *this = date(1400, 1, 1);
-      }
-      if (sv == max_date_time)
-      {
-        *this = date(9999, 12, 31);
-      }
-
-    }
+    BOOST_CXX14_CONSTEXPR explicit date(special_values sv):
+      date_time::date<date, gregorian_calendar, date_duration>(from_special_adjusted(sv))
+    {}
     //!Return the Julian Day number for the date.
-    date_int_type julian_day() const
+    BOOST_CXX14_CONSTEXPR date_int_type julian_day() const
     {
       ymd_type ymd = year_month_day();
       return gregorian_calendar::julian_day_number(ymd);
     }
     //!Return the day of year 1..365 or 1..366 (for leap year)
-    day_of_year_type day_of_year() const
+    BOOST_CXX14_CONSTEXPR day_of_year_type day_of_year() const
     {
       date start_of_year(year(), 1, 1);
       unsigned short doy = static_cast<unsigned short>((*this-start_of_year).days() + 1);
       return day_of_year_type(doy);
     }
     //!Return the Modified Julian Day number for the date.
-    long modjulian_day() const
+    BOOST_CXX14_CONSTEXPR 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
+    //!Return the ISO 8601 week number 1..53
+    BOOST_CXX14_CONSTEXPR 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
+    BOOST_CXX14_CONSTEXPR date_int_type day_number() const
     {
       return days_;
     }
     //! Return the last day of the current month
-    date end_of_month() const
+    BOOST_CXX14_CONSTEXPR date end_of_month() const
     {
-      ymd_type ymd = year_month_day(); 
-      short eom_day =  gregorian_calendar::end_of_month_day(ymd.year, ymd.month);
+      ymd_type ymd = year_month_day();
+      unsigned short eom_day =  gregorian_calendar::end_of_month_day(ymd.year, ymd.month);
       return date(ymd.year, ymd.month, eom_day);
     }
 
+    friend BOOST_CXX14_CONSTEXPR
+    bool operator==(const date& lhs, const date& rhs);
+
    private:
 
+    BOOST_CXX14_CONSTEXPR date_rep_type from_special_adjusted(special_values sv)
+    {
+      switch (sv)
+      {
+        case min_date_time: return gregorian_calendar::day_number(ymd_type(1400, 1, 1));
+        case max_date_time: return gregorian_calendar::day_number(ymd_type(9999, 12, 31));
+        default: return date_rep_type::from_special(sv);
+      }
+    }
   };
-  
+
+  inline BOOST_CXX14_CONSTEXPR
+  bool operator==(const date& lhs, const date& rhs)
+  {
+    return lhs.days_ == rhs.days_;
+  }
 
 
 } } //namespace gregorian

include/boost/date_time/gregorian/greg_day.hpp

@@ -1,7 +1,7 @@
 #ifndef GREG_DAY_HPP___
 #define GREG_DAY_HPP___
 
-/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+/* Copyright (c) 2002,2003,2020 CrystalClear Software, Inc.
  * 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)
@@ -9,7 +9,8 @@
  * $Date$
  */
 
-#include "boost/date_time/constrained_value.hpp"
+#include <boost/date_time/constrained_value.hpp>
+#include <boost/date_time/compiler_config.hpp>
 #include <stdexcept>
 #include <string>
 
@@ -17,7 +18,7 @@ namespace boost {
 namespace gregorian {
 
   //! Exception type for gregorian day of month (1..31)
-  struct bad_day_of_month : public std::out_of_range
+  struct BOOST_SYMBOL_VISIBLE bad_day_of_month : public std::out_of_range
   {
     bad_day_of_month() : 
       std::out_of_range(std::string("Day of month value is out of range 1..31")) 
@@ -39,11 +40,11 @@ namespace gregorian {
       is automatically range checked so values outside of the range 1-31
       will cause a bad_day_of_month exception
   */
-  class greg_day : public greg_day_rep {
+  class BOOST_SYMBOL_VISIBLE greg_day : public greg_day_rep {
   public:
-    greg_day(unsigned short day_of_month) : greg_day_rep(day_of_month) {}
-    unsigned short as_number() const {return value_;}
-    operator unsigned short()  const {return value_;}
+    BOOST_CXX14_CONSTEXPR greg_day(value_type day_of_month) : greg_day_rep(day_of_month) {}
+    BOOST_CXX14_CONSTEXPR value_type as_number() const {return value_;}
+    BOOST_CXX14_CONSTEXPR operator value_type()  const {return value_;}
   private:
     
   };

include/boost/date_time/gregorian/greg_day_of_year.hpp

@@ -9,7 +9,8 @@
  * $Date$
  */
 
-#include "boost/date_time/constrained_value.hpp"
+#include <boost/date_time/constrained_value.hpp>
+#include <boost/date_time/compiler_config.hpp>
 #include <stdexcept>
 #include <string>
 
@@ -17,7 +18,7 @@ namespace boost {
 namespace gregorian {
 
   //! Exception type for day of year (1..366)
-  struct bad_day_of_year : public std::out_of_range
+  struct BOOST_SYMBOL_VISIBLE bad_day_of_year : public std::out_of_range
   {
     bad_day_of_year() : 
       std::out_of_range(std::string("Day of year value is out of range 1..366")) 

include/boost/date_time/gregorian/greg_duration.hpp

@@ -1,7 +1,7 @@
 #ifndef GREG_DURATION_HPP___
 #define GREG_DURATION_HPP___
 
-/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+/* Copyright (c) 2002,2003, 2020 CrystalClear Software, Inc.
  * 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)
@@ -9,30 +9,139 @@
  * $Date$
  */
 
-#include "boost/date_time/date_duration.hpp"
-#if defined(BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES)
-#include "boost/date_time/date_duration_types.hpp"
-#endif
-#include "boost/date_time/int_adapter.hpp"
-
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/date_duration.hpp>
+#include <boost/date_time/int_adapter.hpp>
+#include <boost/date_time/special_defs.hpp>
 
 namespace boost {
 namespace gregorian {
 
-
   //!An internal date representation that includes infinities, not a date
   typedef boost::date_time::duration_traits_adapted date_duration_rep;
 
   //! Durations in days for gregorian system
   /*! \ingroup date_basics
    */
-  typedef date_time::date_duration<date_duration_rep> date_duration;
+  class BOOST_SYMBOL_VISIBLE date_duration :
+    public boost::date_time::date_duration< date_duration_rep >
+  {
+    typedef boost::date_time::date_duration< date_duration_rep > base_type;
+
+  public:
+    typedef base_type::duration_rep duration_rep;
+
+    //! Construct from a day count
+    BOOST_CXX14_CONSTEXPR explicit
+    date_duration(duration_rep day_count = 0) : base_type(day_count) {}
+
+    //! construct from special_values
+    BOOST_CXX14_CONSTEXPR
+    date_duration(date_time::special_values sv) : base_type(sv) {}
+
+    //! Construct from another date_duration
+    BOOST_CXX14_CONSTEXPR
+    date_duration(const base_type& other) : base_type(other)
+    {}
+
+    //  Relational operators
+    //  NOTE: Because of date_time::date_duration< T > design choice we don't use Boost.Operators here,
+    //  because we need the class to be a direct base. Either lose EBO, or define operators by hand.
+    //  The latter is more effecient.
+    BOOST_CXX14_CONSTEXPR bool operator== (const date_duration& rhs) const
+    {
+      return base_type::operator== (rhs);
+    }
+    BOOST_CXX14_CONSTEXPR bool operator!= (const date_duration& rhs) const
+    {
+      return !operator== (rhs);
+    }
+    BOOST_CXX14_CONSTEXPR bool operator< (const date_duration& rhs) const
+    {
+      return base_type::operator< (rhs);
+    }
+    BOOST_CXX14_CONSTEXPR bool operator> (const date_duration& rhs) const
+    {
+      return !(base_type::operator< (rhs) || base_type::operator== (rhs));
+    }
+    BOOST_CXX14_CONSTEXPR bool operator<= (const date_duration& rhs) const
+    {
+      return (base_type::operator< (rhs) || base_type::operator== (rhs));
+    }
+    BOOST_CXX14_CONSTEXPR bool operator>= (const date_duration& rhs) const
+    {
+      return !base_type::operator< (rhs);
+    }
+
+    //! Subtract another duration -- result is signed
+    BOOST_CXX14_CONSTEXPR date_duration& operator-= (const date_duration& rhs)
+    {
+      base_type::operator-= (rhs);
+      return *this;
+    }
+    
+    BOOST_CXX14_CONSTEXPR friend
+    date_duration operator- (date_duration rhs, date_duration const& lhs);
+
+    //! Add a duration -- result is signed
+    BOOST_CXX14_CONSTEXPR date_duration& operator+= (const date_duration& rhs)
+    {
+      base_type::operator+= (rhs);
+      return *this;
+    }
+    
+    BOOST_CXX14_CONSTEXPR friend
+    date_duration operator+ (date_duration rhs, date_duration const& lhs);
+
+    //! unary- Allows for dd = -date_duration(2); -> dd == -2
+    BOOST_CXX14_CONSTEXPR date_duration operator- ()const
+    {
+      return date_duration(get_rep() * (-1));
+    }
+
+    //! Division operations on a duration with an integer.
+    BOOST_CXX14_CONSTEXPR date_duration& operator/= (int divisor)
+    {
+      base_type::operator/= (divisor);
+      return *this;
+    }
+    
+    BOOST_CXX14_CONSTEXPR friend date_duration operator/ (date_duration rhs, int lhs);
+
+    //! Returns the smallest duration -- used by to calculate 'end'
+    static BOOST_CXX14_CONSTEXPR date_duration unit()
+    {
+      return date_duration(base_type::unit().get_rep());
+    }
+  };      
+
+  inline BOOST_CXX14_CONSTEXPR 
+  date_duration operator- (date_duration rhs, date_duration const& lhs)
+    {
+      rhs -= lhs;
+      return rhs;
+    }
+
+  inline BOOST_CXX14_CONSTEXPR 
+  date_duration operator+ (date_duration rhs, date_duration const& lhs)
+    {
+      rhs += lhs;
+      return rhs;
+    }
+
+  inline BOOST_CXX14_CONSTEXPR date_duration operator/ (date_duration rhs, int lhs)
+    {
+      rhs /= lhs;
+      return rhs;
+    }
 
   //! Shorthand for date_duration
   typedef date_duration days;
 
 } } //namespace gregorian
 
-
+#if defined(BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES)
+#include <boost/date_time/date_duration_types.hpp>
+#endif
 
 #endif

include/boost/date_time/gregorian/greg_duration_types.hpp

@@ -1,6 +1,6 @@
 #ifndef GREG_DURATION_TYPES_HPP___
 #define GREG_DURATION_TYPES_HPP___
-                                                                                
+
 /* Copyright (c) 2004 CrystalClear Software, Inc.
  * Subject to Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
@@ -9,17 +9,18 @@
  */
 
 
-#include "boost/date_time/gregorian/greg_date.hpp"
-#include "boost/date_time/int_adapter.hpp"
-#include "boost/date_time/adjust_functors.hpp"
-#include "boost/date_time/date_duration.hpp"
-#include "boost/date_time/date_duration_types.hpp"
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/gregorian/greg_date.hpp>
+#include <boost/date_time/int_adapter.hpp>
+#include <boost/date_time/adjust_functors.hpp>
+#include <boost/date_time/date_duration_types.hpp>
+#include <boost/date_time/gregorian/greg_duration.hpp>
 
 namespace boost {
 namespace gregorian {
 
   //! config struct for additional duration types (ie months_duration<> & years_duration<>)
-  struct greg_durations_config {
+  struct BOOST_SYMBOL_VISIBLE greg_durations_config {
     typedef date date_type;
     typedef date_time::int_adapter<int> int_rep;
     typedef date_time::month_functor<date_type> month_adjustor_type; 
@@ -27,7 +28,16 @@ namespace gregorian {
 
   typedef date_time::months_duration<greg_durations_config> months;
   typedef date_time::years_duration<greg_durations_config> years;
-  typedef date_time::weeks_duration<date_time::duration_traits_adapted> weeks;
+
+  class BOOST_SYMBOL_VISIBLE weeks_duration : public date_duration {
+  public:
+    BOOST_CXX14_CONSTEXPR weeks_duration(duration_rep w) 
+      : date_duration(w * 7) {}
+    BOOST_CXX14_CONSTEXPR weeks_duration(date_time::special_values sv) 
+      : date_duration(sv) {}
+  };
+
+  typedef weeks_duration weeks;
 
 }} // namespace boost::gregorian
 

include/boost/date_time/gregorian/greg_facet.hpp

@@ -9,21 +9,26 @@
  * $Date$
  */
 
-#include "boost/date_time/gregorian/gregorian_types.hpp"
-#include "boost/date_time/date_formatting_locales.hpp" // sets BOOST_DATE_TIME_NO_LOCALE
-#include "boost/date_time/gregorian/parsers.hpp"
-#include <string>
-#include <exception>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/gregorian/gregorian_types.hpp>
+#include <boost/date_time/date_formatting_locales.hpp> // sets BOOST_DATE_TIME_NO_LOCALE
+#include <boost/date_time/gregorian/parsers.hpp>
+#include <boost/io/ios_state.hpp>
 
 //This file is basically commented out if locales are not supported
 #ifndef BOOST_DATE_TIME_NO_LOCALE
 
+#include <string>
+#include <memory>
+#include <locale>
+#include <iostream>
+#include <exception>
 
 namespace boost {
 namespace gregorian {
   
   //! Configuration of the output facet template
-  struct greg_facet_config
+  struct BOOST_SYMBOL_VISIBLE greg_facet_config
   {
     typedef boost::gregorian::greg_month month_type;
     typedef boost::date_time::special_values special_value_enum;
@@ -71,9 +76,9 @@ namespace gregorian {
       greg_month_formatter::format_month(m, os, f);
 
     }
-    else { //default to numeric
-      charT fill_char = '0';
-      os  << std::setw(2) << std::setfill(fill_char) << m.as_number();
+    else { // default to numeric
+      boost::io::basic_ios_fill_saver<charT> ifs(os);
+      os  << std::setw(2) << std::setfill(os.widen('0')) << m.as_number();
     }
 
     return os;
@@ -94,7 +99,7 @@ namespace gregorian {
     std::locale locale = os.getloc();
     if (std::has_facet<facet_def>(locale)) {
       const facet_def& f = std::use_facet<facet_def>(locale);
-      greg_weekday_formatter::format_weekday(wd.as_enum(), os, f, true);
+      greg_weekday_formatter::format_weekday(wd, os, f, true);
     }
     else { //default to short English string eg: Sun, Mon, Tue, Wed...
       os  << wd.as_short_string();
@@ -138,7 +143,8 @@ namespace gregorian {
   std::basic_ostream<charT, traits>&
   operator<<(std::basic_ostream<charT, traits>& os, const partial_date& pd)
   {
-    os << std::setw(2) << std::setfill('0') << pd.day() << ' ' 
+    boost::io::basic_ios_fill_saver<charT> ifs(os);
+    os << std::setw(2) << std::setfill(os.widen('0')) << pd.day() << ' ' 
        << pd.month().as_short_string() ; 
     return os;
   }
@@ -211,8 +217,6 @@ namespace gregorian {
   std::basic_istream<charT>& operator>>(std::basic_istream<charT>& is, date& d)
   {
     std::istream_iterator<std::basic_string<charT>, charT> beg(is), eos;
-    
-    typedef boost::date_time::all_date_names_put<greg_facet_config, charT> facet_def;
     d = from_stream(beg, eos);
     return is;
   }
@@ -281,22 +285,32 @@ namespace gregorian {
       const facet_def& f = std::use_facet<facet_def>(is.getloc());
       num = date_time::find_match(f.get_short_month_names(), 
                                   f.get_long_month_names(), 
-                                  (greg_month::max)(), s); 
+                                  (greg_month::max)(), s); // greg_month spans 1..12, so max returns the array size,
+                                                           // which is needed by find_match
     }
     /* bad_cast will be thrown if the desired facet is not accessible
      * so we can generate the facet. This has the drawback of using english
      * names as a default. */
-    catch(std::bad_cast bc){
-      std::cout << "Month exception caught" << std::endl;
+    catch(std::bad_cast&){
       charT a = '\0';
-      const facet_def* f = create_facet_def(a);
+      
+#if defined(BOOST_NO_CXX11_SMART_PTR)
+      
+      std::auto_ptr< const facet_def > f(create_facet_def(a));
+      
+#else
+
+      std::unique_ptr< const facet_def > f(create_facet_def(a));
+      
+#endif
+      
       num = date_time::find_match(f->get_short_month_names(), 
                                   f->get_long_month_names(), 
-                                  (greg_month::max)(), s); 
-      delete(f);
+                                  (greg_month::max)(), s); // greg_month spans 1..12, so max returns the array size,
+                                                           // which is needed by find_match
     }
     
-    num += 1; // months numbered 1-12
+    ++num; // months numbered 1-12
     m = greg_month(num); 
 
     return is;
@@ -323,19 +337,29 @@ namespace gregorian {
       const facet_def& f = std::use_facet<facet_def>(is.getloc());
       num = date_time::find_match(f.get_short_weekday_names(), 
                                   f.get_long_weekday_names(), 
-                                  (greg_weekday::max)(), s); 
+                                  (greg_weekday::max)() + 1, s); // greg_weekday spans 0..6, so increment is needed
+                                                                 // to form the array size which is needed by find_match
     }
     /* bad_cast will be thrown if the desired facet is not accessible
      * so we can generate the facet. This has the drawback of using english
      * names as a default. */
-    catch(std::bad_cast bc){
-      //std::cout << "Weekday exception caught" << std::endl;
+    catch(std::bad_cast&){
       charT a = '\0';
-      const facet_def* f = create_facet_def(a);
+      
+#if defined(BOOST_NO_CXX11_SMART_PTR)
+
+      std::auto_ptr< const facet_def > f(create_facet_def(a));
+      
+#else 
+
+      std::unique_ptr< const facet_def > f(create_facet_def(a));
+      
+#endif
+      
       num = date_time::find_match(f->get_short_weekday_names(), 
                                   f->get_long_weekday_names(), 
-                                  (greg_weekday::max)(), s); 
-      delete(f);
+                                  (greg_weekday::max)() + 1, s); // greg_weekday spans 0..6, so increment is needed
+                                                                 // to form the array size which is needed by find_match
     }
    
     wd = greg_weekday(num); // weekdays numbered 0-6
@@ -344,8 +368,7 @@ namespace gregorian {
 
 } } //namespace gregorian
 
-#endif  
-    
-    
+#endif
+
 #endif
 

include/boost/date_time/gregorian/greg_month.hpp

@@ -1,7 +1,7 @@
 #ifndef GREG_MONTH_HPP___
 #define GREG_MONTH_HPP___
 
-/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+/* Copyright (c) 2002,2003, 2020 CrystalClear Software, Inc.
  * 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)
@@ -9,15 +9,11 @@
  * $Date$
  */
 
-#include "boost/date_time/constrained_value.hpp"
-#include "boost/date_time/date_defs.hpp"
-#include "boost/shared_ptr.hpp"
-#include "boost/date_time/compiler_config.hpp"
+#include <boost/date_time/constrained_value.hpp>
+#include <boost/date_time/date_defs.hpp>
+#include <boost/date_time/compiler_config.hpp>
 #include <stdexcept>
 #include <string>
-#include <map>
-#include <algorithm>
-#include <cctype>
 
 namespace boost {
 namespace gregorian {
@@ -39,9 +35,9 @@ namespace gregorian {
   using date_time::Dec;
   using date_time::NotAMonth;
   using date_time::NumMonths;
-  
+
   //! Exception thrown if a greg_month is constructed with a value out of range
-  struct bad_month : public std::out_of_range
+  struct BOOST_SYMBOL_VISIBLE bad_month : public std::out_of_range
   {
     bad_month() : std::out_of_range(std::string("Month number is out of range 1..12")) {}
   };
@@ -50,31 +46,65 @@ namespace gregorian {
   //! A constrained range that implements the gregorian_month rules
   typedef CV::constrained_value<greg_month_policies> greg_month_rep;
 
-  
+
   //! Wrapper class to represent months in gregorian based calendar
-  class BOOST_DATE_TIME_DECL greg_month : public greg_month_rep {
+  class BOOST_SYMBOL_VISIBLE greg_month : public greg_month_rep {
   public:
     typedef date_time::months_of_year month_enum;
-    typedef std::map<std::string, unsigned short> month_map_type;
-    typedef boost::shared_ptr<month_map_type> month_map_ptr_type;
+
     //! Construct a month from the months_of_year enumeration
-    greg_month(month_enum theMonth) : 
+    BOOST_CXX14_CONSTEXPR greg_month(month_enum theMonth) :
       greg_month_rep(static_cast<greg_month_rep::value_type>(theMonth)) {}
     //! Construct from a short value
-    greg_month(unsigned short theMonth) : greg_month_rep(theMonth) {}
+    BOOST_CXX14_CONSTEXPR greg_month(value_type theMonth) : greg_month_rep(theMonth) {}
     //! Convert the value back to a short
-    operator unsigned short()  const {return value_;}
+    BOOST_CXX14_CONSTEXPR operator value_type()  const {return value_;}
     //! Returns month as number from 1 to 12
-    unsigned short as_number() const {return value_;}
-    month_enum as_enum() const {return static_cast<month_enum>(value_);}
-    const char* as_short_string() const;
-    const char* as_long_string()  const;
+    BOOST_CXX14_CONSTEXPR value_type as_number() const {return value_;}
+    BOOST_CXX14_CONSTEXPR month_enum as_enum() const {return static_cast<month_enum>(value_);}
+
+    //! Returns 3 char english string for the month ex: Jan, Feb, Mar, Apr
+    const char*
+    as_short_string() const
+    {
+      static const char* const short_month_names[NumMonths]
+        = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec", "NAM"};
+      return short_month_names[value_-1];
+    }
+
+    //! Returns full name of month as string in english ex: January, February
+    const char*
+    as_long_string() const
+    {
+      static const char* const long_month_names[NumMonths]
+        = {"January","February","March","April","May","June","July","August",
+           "September","October","November","December","NotAMonth"};
+      return long_month_names[value_-1];
+    }
+
 #ifndef BOOST_NO_STD_WSTRING
-    const wchar_t* as_short_wstring() const;
-    const wchar_t* as_long_wstring()  const;
+
+    //! Returns 3 wchar_t english string for the month ex: Jan, Feb, Mar, Apr
+    const wchar_t*
+    as_short_wstring() const
+    {
+      static const wchar_t* const w_short_month_names[NumMonths]
+        = {L"Jan",L"Feb",L"Mar",L"Apr",L"May",L"Jun",L"Jul",L"Aug",L"Sep",L"Oct",
+           L"Nov",L"Dec",L"NAM"};
+      return w_short_month_names[value_-1];
+    }
+
+    //! Returns full name of month as wchar_t string in english ex: January, February
+    const wchar_t*
+    as_long_wstring() const
+    {
+      static const wchar_t* const w_long_month_names[NumMonths]
+        = {L"January",L"February",L"March",L"April",L"May",L"June",L"July",L"August",
+           L"September",L"October",L"November",L"December",L"NotAMonth"};
+      return w_long_month_names[value_-1];
+    }
+
 #endif // BOOST_NO_STD_WSTRING
-    //! Shared pointer to a map of Month strings (Names & Abbrev) & numbers
-    static month_map_ptr_type get_month_map_ptr();
 
     /* parameterized as_*_string functions are intended to be called
      * from a template function: "... as_short_string(charT c='\0');" */
@@ -100,6 +130,4 @@ namespace gregorian {
 
 } } //namespace gregorian
 
-
-
 #endif

include/boost/date_time/gregorian/greg_serialize.hpp

@@ -11,38 +11,47 @@
 
 #include "boost/date_time/gregorian/gregorian_types.hpp"
 #include "boost/date_time/gregorian/parsers.hpp"
-#include "boost/serialization/split_free.hpp"
+#include "boost/core/nvp.hpp"
 
-  
-// macros to split serialize functions into save & load functions
-// An expanded version is below for gregorian::date
-// NOTE: these macros define template functions in the boost::serialization namespace.
-// They must be expanded *outside* of any namespace
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::date_duration)
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::date_duration::duration_rep)
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::date_period)
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::greg_month)
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::greg_day)
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::greg_weekday)
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::partial_date)
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::nth_kday_of_month)
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::first_kday_of_month)
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::last_kday_of_month)
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::first_kday_before)
-BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::first_kday_after)
 
 namespace boost {
+
+  namespace gregorian {
+    std::string to_iso_string(const date&);
+  }
+
 namespace serialization {
 
+// A macro to split serialize functions into save & load functions.
+// It is here to avoid dependency on Boost.Serialization just for the
+// BOOST_SERIALIZATION_SPLIT_FREE macro
+#define BOOST_DATE_TIME_SPLIT_FREE(T)                                         \
+template<class Archive>                                                       \
+inline void serialize(Archive & ar,                                           \
+                      T & t,                                                  \
+                      const unsigned int file_version)                        \
+{                                                                             \
+    split_free(ar, t, file_version);                                          \
+}
+
 /*! Method that does serialization for gregorian::date -- splits to load/save
  */
-template<class Archive>                         
-inline void serialize(Archive & ar,                               
-                      ::boost::gregorian::date & d,
-                      const unsigned int file_version)
-{
-  split_free(ar, d, file_version);              
-}                                               
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::date)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::date_duration)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::date_duration::duration_rep)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::date_period)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::greg_year)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::greg_month)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::greg_day)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::greg_weekday)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::partial_date)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::nth_kday_of_month)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::first_kday_of_month)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::last_kday_of_month)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::first_kday_before)
+BOOST_DATE_TIME_SPLIT_FREE(::boost::gregorian::first_kday_after)
+
+#undef BOOST_DATE_TIME_SPLIT_FREE
 
 //! Function to save gregorian::date objects using serialization lib
 /*! Dates are serialized into a string for transport and storage. 
@@ -72,10 +81,10 @@ void load(Archive & ar,
   ar & make_nvp("date", ds);
   try{
     d = ::boost::gregorian::from_undelimited_string(ds);
-  }catch(bad_lexical_cast be) {
+  }catch(bad_lexical_cast&) {
     gregorian::special_values sv = gregorian::special_value_from_string(ds);
     if(sv == gregorian::not_special) {
-      throw(be); // no match found, rethrow original exception
+      throw; // no match found, rethrow original exception
     }
     else {
       d = gregorian::date(sv);
@@ -86,7 +95,7 @@ void load(Archive & ar,
 
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 ::boost::gregorian::date* dp, 
                                 const unsigned int /*file_version*/)
 {
@@ -115,7 +124,7 @@ void load(Archive & ar, gregorian::date_duration & dd, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::date_duration* dd, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::date_duration* dd, 
                                 const unsigned int /*file_version*/)
 {
   ::new(dd) gregorian::date_duration(gregorian::not_a_date_time);
@@ -141,7 +150,7 @@ void load(Archive & ar, gregorian::date_duration::duration_rep & dr, unsigned in
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::date_duration::duration_rep* dr, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::date_duration::duration_rep* dr, 
                                 const unsigned int /*file_version*/)
 {
   ::new(dr) gregorian::date_duration::duration_rep(0);
@@ -177,7 +186,7 @@ void load(Archive & ar, gregorian::date_period& dp, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::date_period* dp, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::date_period* dp, 
                                 const unsigned int /*file_version*/)
 {
   gregorian::date d(gregorian::not_a_date_time);
@@ -185,6 +194,32 @@ inline void load_construct_data(Archive & ar, gregorian::date_period* dp,
   ::new(dp) gregorian::date_period(d,dd);
 }
 
+/**** greg_year ****/
+
+//! Function to save gregorian::greg_year objects using serialization lib
+template<class Archive>
+void save(Archive & ar, const gregorian::greg_year& gy, 
+          unsigned int /*version*/)
+{
+  unsigned short us = gy;
+  ar & make_nvp("greg_year", us);
+}
+//! Function to load gregorian::greg_year objects using serialization lib
+template<class Archive>
+void load(Archive & ar, gregorian::greg_year& gy, unsigned int /*version*/)
+{
+  unsigned short us;
+  ar & make_nvp("greg_year", us);
+  gy = gregorian::greg_year(us);
+}
+//!override needed b/c no default constructor
+template<class Archive>
+inline void load_construct_data(Archive & /*ar*/, gregorian::greg_year* gy, 
+                                const unsigned int /*file_version*/)
+{
+  ::new(gy) gregorian::greg_year(1900);
+}
+
 /**** greg_month ****/
 
 //! Function to save gregorian::greg_month objects using serialization lib
@@ -205,7 +240,7 @@ void load(Archive & ar, gregorian::greg_month& gm, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::greg_month* gm, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::greg_month* gm, 
                                 const unsigned int /*file_version*/)
 {
   ::new(gm) gregorian::greg_month(1);
@@ -231,7 +266,7 @@ void load(Archive & ar, gregorian::greg_day& gd, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::greg_day* gd, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::greg_day* gd, 
                                 const unsigned int /*file_version*/)
 {
   ::new(gd) gregorian::greg_day(1);
@@ -257,7 +292,7 @@ void load(Archive & ar, gregorian::greg_weekday& gd, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::greg_weekday* gd, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::greg_weekday* gd, 
                                 const unsigned int /*file_version*/)
 {
   ::new(gd) gregorian::greg_weekday(1);
@@ -295,7 +330,7 @@ void load(Archive & ar, gregorian::partial_date& pd, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::partial_date* pd, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::partial_date* pd, 
                                 const unsigned int /*file_version*/)
 {
   gregorian::greg_month gm(1);
@@ -338,7 +373,7 @@ void load(Archive & ar, gregorian::nth_kday_of_month& nkd, unsigned int /*versio
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 gregorian::nth_kday_of_month* nkd, 
                                 const unsigned int /*file_version*/)
 {
@@ -378,7 +413,7 @@ void load(Archive & ar, gregorian::first_kday_of_month& fkd, unsigned int /*vers
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 gregorian::first_kday_of_month* fkd, 
                                 const unsigned int /*file_version*/)
 {
@@ -417,7 +452,7 @@ void load(Archive & ar, gregorian::last_kday_of_month& lkd, unsigned int /*versi
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 gregorian::last_kday_of_month* lkd, 
                                 const unsigned int /*file_version*/)
 {
@@ -446,7 +481,7 @@ void load(Archive & ar, gregorian::first_kday_before& fkdb, unsigned int /*versi
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 gregorian::first_kday_before* fkdb, 
                                 const unsigned int /*file_version*/)
 {
@@ -475,7 +510,7 @@ void load(Archive & ar, gregorian::first_kday_after& fkda, unsigned int /*versio
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 gregorian::first_kday_after* fkda, 
                                 const unsigned int /*file_version*/)
 {

include/boost/date_time/gregorian/greg_weekday.hpp

@@ -1,7 +1,7 @@
 #ifndef GREG_WEEKDAY_HPP___
 #define GREG_WEEKDAY_HPP___
 
-/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+/* Copyright (c) 2002,2003,2020 CrystalClear Software, Inc.
  * 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)
@@ -9,9 +9,9 @@
  * $Date$
  */
 
-#include "boost/date_time/constrained_value.hpp"
-#include "boost/date_time/date_defs.hpp"
-#include "boost/date_time/compiler_config.hpp"
+#include <boost/date_time/constrained_value.hpp>
+#include <boost/date_time/date_defs.hpp>
+#include <boost/date_time/compiler_config.hpp>
 #include <stdexcept>
 #include <string>
 
@@ -29,30 +29,64 @@ namespace gregorian {
 
 
   //! Exception that flags that a weekday number is incorrect
-  struct bad_weekday : public std::out_of_range
+  struct BOOST_SYMBOL_VISIBLE bad_weekday : public std::out_of_range
   {
-    bad_weekday() : std::out_of_range(std::string("Weekday os out of range 0..6")) {}
+    bad_weekday() : std::out_of_range(std::string("Weekday is out of range 0..6")) {}
   };
   typedef CV::simple_exception_policy<unsigned short, 0, 6, bad_weekday> greg_weekday_policies;
   typedef CV::constrained_value<greg_weekday_policies> greg_weekday_rep;
 
 
   //! Represent a day within a week (range 0==Sun to 6==Sat)
-  class BOOST_DATE_TIME_DECL greg_weekday : public greg_weekday_rep {
+  class BOOST_SYMBOL_VISIBLE greg_weekday : public greg_weekday_rep {
   public:
     typedef boost::date_time::weekdays weekday_enum;
-    greg_weekday(unsigned short day_of_week_num) :
+    BOOST_CXX14_CONSTEXPR greg_weekday(value_type day_of_week_num) :
       greg_weekday_rep(day_of_week_num)
     {}
 
-    unsigned short as_number() const {return value_;}
-    const char* as_short_string() const;
-    const char* as_long_string()  const;
+    BOOST_CXX14_CONSTEXPR value_type as_number() const {return value_;}
+    BOOST_CXX14_CONSTEXPR weekday_enum as_enum() const {return static_cast<weekday_enum>(value_);}
+
+    //! Return a 3 digit english string of the day of week (eg: Sun)
+    const char* as_short_string() const
+    {
+      static const char* const short_weekday_names[]
+        = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+
+      return short_weekday_names[value_];
+    }
+
+    //! Return a point to a long english string representing day of week
+    const char* as_long_string() const
+    {
+      static const char* const long_weekday_names[]
+        = {"Sunday","Monday","Tuesday","Wednesday", "Thursday", "Friday", "Saturday"};
+
+      return long_weekday_names[value_];
+    }
+
+
 #ifndef BOOST_NO_STD_WSTRING
-    const wchar_t* as_short_wstring() const;
-    const wchar_t* as_long_wstring()  const;
+
+    //! Return a 3 digit english wchar_t string of the day of week (eg: Sun)
+    const wchar_t* as_short_wstring() const
+    {
+      static const wchar_t* const w_short_weekday_names[]={L"Sun", L"Mon", L"Tue",
+                                                           L"Wed", L"Thu", L"Fri", L"Sat"};
+      return w_short_weekday_names[value_];
+    }
+
+    //! Return a point to a long english wchar_t string representing day of week
+    const wchar_t* as_long_wstring()  const
+    {
+      static const wchar_t* const w_long_weekday_names[]= {L"Sunday",L"Monday",L"Tuesday",
+                                                           L"Wednesday", L"Thursday",
+                                                           L"Friday", L"Saturday"};
+      return w_long_weekday_names[value_];
+    }
+
 #endif // BOOST_NO_STD_WSTRING
-    weekday_enum as_enum() const {return static_cast<weekday_enum>(value_);}
 
 
   };

include/boost/date_time/gregorian/greg_year.hpp

@@ -1,7 +1,7 @@
 #ifndef GREG_YEAR_HPP___
 #define GREG_YEAR_HPP___
 
-/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+/* Copyright (c) 2002,2003, 2020 CrystalClear Software, Inc.
  * 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)
@@ -9,7 +9,8 @@
  * $Date$
  */
 
-#include "boost/date_time/constrained_value.hpp"
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/constrained_value.hpp>
 #include <stdexcept>
 #include <string>
 
@@ -17,31 +18,29 @@ namespace boost {
 namespace gregorian {
 
   //! Exception type for gregorian year
-  struct bad_year : public std::out_of_range
+  struct BOOST_SYMBOL_VISIBLE bad_year : public std::out_of_range
   {
     bad_year() : 
-      std::out_of_range(std::string("Year is out of valid range: 1400..10000")) 
+      std::out_of_range(std::string("Year is out of valid range: 1400..9999")) 
     {}
   };
   //! Policy class that declares error handling gregorian year type
-  typedef CV::simple_exception_policy<unsigned short, 1400, 10000, bad_year> greg_year_policies;
+  typedef CV::simple_exception_policy<unsigned short, 1400, 9999, bad_year> greg_year_policies;
 
   //! Generated representation for gregorian year
   typedef CV::constrained_value<greg_year_policies> greg_year_rep;
 
-  //! Represent a day of the month (range 1900 - 10000) 
+  //! Represent a year (range 1400 - 9999) 
   /*! This small class allows for simple conversion an integer value into
       a year for the gregorian calendar.  This currently only allows a
-      range of 1900 to 10000.  Both ends of the range are a bit arbitrary
+      range of 1400 to 9999.  Both ends of the range are a bit arbitrary
       at the moment, but they are the limits of current testing of the 
       library.  As such they may be increased in the future.
   */
-  class greg_year : public greg_year_rep {
+  class BOOST_SYMBOL_VISIBLE greg_year : public greg_year_rep {
   public:
-    greg_year(unsigned short year) : greg_year_rep(year) {}
-    operator unsigned short()  const {return value_;}
-  private:
-    
+    BOOST_CXX14_CONSTEXPR greg_year(value_type year) : greg_year_rep(year) {}
+    BOOST_CXX14_CONSTEXPR operator value_type()  const {return value_;}
   };
 
 

include/boost/date_time/gregorian/gregorian_io.hpp

@@ -9,10 +9,17 @@
  * $Date$
  */
 
-#include "boost/date_time/date_facet.hpp"
-#include "boost/io/ios_state.hpp"
-#include <iostream>
 #include <locale>
+#include <iostream>
+#include <iterator> // i/ostreambuf_iterator
+#include <boost/io/ios_state.hpp>
+#include <boost/date_time/date_facet.hpp>
+#include <boost/date_time/period_parser.hpp>
+#include <boost/date_time/period_formatter.hpp>
+#include <boost/date_time/special_values_parser.hpp>
+#include <boost/date_time/special_values_formatter.hpp>
+#include <boost/date_time/gregorian/gregorian_types.hpp>
+#include <boost/date_time/gregorian/conversion.hpp> // to_tm will be needed in the facets
 
 namespace boost {
 namespace gregorian {
@@ -70,14 +77,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
         
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, d);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, d);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, d);
@@ -131,14 +138,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
         
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, dd);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, dd);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, dd);
@@ -195,14 +202,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
 
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, dp);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, dp);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, dp);
@@ -254,14 +261,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
 
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, m);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, m);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, m);
@@ -311,14 +318,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
 
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, wd);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, wd);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, wd);
@@ -352,14 +359,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
 
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, gd);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, gd);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, gd);
@@ -393,14 +400,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
 
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, gy);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, gy);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, gy);
@@ -451,14 +458,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
 
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, pd);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, pd);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, pd);
@@ -508,14 +515,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
 
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, nday);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, nday);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, nday);
@@ -566,14 +573,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
 
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fkd);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, fkd);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, fkd);
@@ -624,14 +631,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
 
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, lkd);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, lkd);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, lkd);
@@ -683,14 +690,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
 
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fka);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, fka);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, fka);
@@ -742,14 +749,14 @@ namespace gregorian {
     typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
     if (strm_sentry) {
       try {
-        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
+        typedef typename date_time::date_input_facet<date, CharT> date_input_facet_local;
 
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<date_input_facet>(is.getloc())) {
-          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fkb);
+        if(std::has_facet<date_input_facet_local>(is.getloc())) {
+          std::use_facet<date_input_facet_local>(is.getloc()).get(sit, str_end, is, fkb);
         }
         else {
-          date_input_facet* f = new date_input_facet();
+          date_input_facet_local* f = new date_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, fkb);

include/boost/date_time/gregorian/parsers.hpp

@@ -9,48 +9,67 @@
  * $Date$
  */
 
-#include "boost/date_time/gregorian/gregorian_types.hpp"
-#include "boost/date_time/date_parsing.hpp"
-#include "boost/date_time/compiler_config.hpp"
-#include "boost/date_time/parse_format_base.hpp"
+#include <boost/date_time/gregorian/gregorian_types.hpp>
+#include <boost/date_time/date_parsing.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/parse_format_base.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/find_match.hpp>
 #include <string>
-#include <sstream>
+#include <iterator>
 
 namespace boost {
 namespace gregorian {
 
   //! Return special_value from string argument
-  /*! Return special_value from string argument. If argument is 
-   * not one of the special value names (defined in src/gregorian/names.hpp), 
+  /*! Return special_value from string argument. If argument is
+   * not one of the special value names (defined in names.hpp),
    * return 'not_special' */
-  BOOST_DATE_TIME_DECL special_values special_value_from_string(const std::string& s);
+  inline
+  date_time::special_values
+  special_value_from_string(const std::string& s) {
+    static const char* const special_value_names[date_time::NumSpecialValues]
+      = {"not-a-date-time","-infinity","+infinity","min_date_time",
+         "max_date_time","not_special"};
+
+    short i = date_time::find_match(special_value_names,
+                                    special_value_names,
+                                    date_time::NumSpecialValues,
+                                    s);
+    if(i >= date_time::NumSpecialValues) { // match not found
+      return date_time::not_special;
+    }
+    else {
+      return static_cast<date_time::special_values>(i);
+    }
+  }
 
   //! Deprecated: Use from_simple_string
-  inline date from_string(std::string s) {
+  inline date from_string(const std::string& s) {
     return date_time::parse_date<date>(s);
   }
 
   //! From delimited date string where with order year-month-day eg: 2002-1-25 or 2003-Jan-25 (full month name is also accepted)
-  inline date from_simple_string(std::string s) {
+  inline date from_simple_string(const std::string& s) {
     return date_time::parse_date<date>(s, date_time::ymd_order_iso);
   }
   
   //! From delimited date string where with order year-month-day eg: 1-25-2003 or Jan-25-2003 (full month name is also accepted)
-  inline date from_us_string(std::string s) {
+  inline date from_us_string(const std::string& s) {
     return date_time::parse_date<date>(s, date_time::ymd_order_us);
   }
   
   //! From delimited date string where with order day-month-year eg: 25-1-2002 or 25-Jan-2003 (full month name is also accepted)
-  inline date from_uk_string(std::string s) {
+  inline date from_uk_string(const std::string& s) {
     return date_time::parse_date<date>(s, date_time::ymd_order_dmy);
   }
   
-  //! From iso type date string where with order year-month-day eg: 20020125
-  inline date from_undelimited_string(std::string s) {
+  //! From ISO 8601 type date string where with order year-month-day eg: 20020125
+  inline date from_undelimited_string(const std::string& s) {
     return date_time::parse_undelimited_date<date>(s);
   }
 
-  //! From iso type date string where with order year-month-day eg: 20020125
+  //! From ISO 8601 type date string where with order year-month-day eg: 20020125
   inline date date_from_iso_string(const std::string& s) {
     return date_time::parse_undelimited_date<date>(s);
   }

include/boost/date_time/gregorian_calendar.hpp

@@ -2,13 +2,14 @@
 #define DATE_TIME_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 
+ * Author: Jeff Garland
  * $Date$
  */
 
+#include <boost/date_time/compiler_config.hpp>
 
 namespace boost {
 namespace date_time {
@@ -19,15 +20,15 @@ namespace date_time {
       can be used in the creation of date systems or just to perform calculations.
       All the methods of this class are static functions, so the intent is to
       never create instances of this class.
-    @param ymd_type_ Struct type representing the year, month, day.  The ymd_type must
+    @tparam ymd_type_ Struct type representing the year, month, day.  The ymd_type must
            define a of types for the year, month, and day.  These types need to be
            arithmetic types.
-    @param date_int_type_ Underlying type for the date count.  Must be an arithmetic type.
+    @tparam date_int_type_ Underlying type for the date count.  Must be an arithmetic type.
   */
   template<typename ymd_type_, typename date_int_type_>
-  class gregorian_calendar_base {
+  class BOOST_SYMBOL_VISIBLE gregorian_calendar_base {
   public:
-    //! define a type a date split into components 
+    //! define a type a date split into components
     typedef ymd_type_  ymd_type;
     //! define a type for representing months
     typedef typename ymd_type::month_type  month_type;
@@ -39,32 +40,30 @@ namespace date_time {
     typedef date_int_type_ date_int_type;
 
 
-    static unsigned short day_of_week(const ymd_type& ymd);
-    static int week_number(const ymd_type&ymd);
-    //static unsigned short day_of_year(date_int_type);
-    static date_int_type day_number(const ymd_type& ymd);
-    static date_int_type julian_day_number(const ymd_type& ymd);
-    static long modjulian_day_number(const ymd_type& ymd);
-    static ymd_type from_day_number(date_int_type);
-    static ymd_type from_julian_day_number(date_int_type);
-    static ymd_type from_modjulian_day_number(long);
-    static bool is_leap_year(year_type);
-    static unsigned short end_of_month_day(year_type y, month_type m);
-    static ymd_type epoch();
-    static unsigned short days_in_week();
+    static BOOST_CXX14_CONSTEXPR unsigned short day_of_week(const ymd_type& ymd);
+    static BOOST_CXX14_CONSTEXPR int week_number(const ymd_type&ymd);
+    static BOOST_CXX14_CONSTEXPR date_int_type day_number(const ymd_type& ymd);
+    static BOOST_CXX14_CONSTEXPR date_int_type julian_day_number(const ymd_type& ymd);
+    static BOOST_CXX14_CONSTEXPR date_int_type modjulian_day_number(const ymd_type& ymd);
+    static BOOST_CXX14_CONSTEXPR ymd_type from_day_number(date_int_type);
+    static BOOST_CXX14_CONSTEXPR ymd_type from_julian_day_number(date_int_type);
+    static BOOST_CXX14_CONSTEXPR ymd_type from_modjulian_day_number(date_int_type);
+    static BOOST_CXX14_CONSTEXPR bool is_leap_year(year_type);
+    static BOOST_CXX14_CONSTEXPR unsigned short end_of_month_day(year_type y, month_type m);
+    static BOOST_CXX14_CONSTEXPR ymd_type epoch();
+    static BOOST_CXX14_CONSTEXPR unsigned short days_in_week();
 
   };
 
 
 
 } } //namespace
-  
-#ifndef NO_BOOST_DATE_TIME_INLINE
+
 #include "boost/date_time/gregorian_calendar.ipp"
-#endif
+
 
 
 
 #endif
-  
+
 

include/boost/date_time/gregorian_calendar.ipp

@@ -1,23 +1,20 @@
 /* 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$
  */
 
-#ifndef NO_BOOST_DATE_TIME_INLINE
-  #undef BOOST_DATE_TIME_INLINE
-  #define BOOST_DATE_TIME_INLINE inline
-#endif
 
 namespace boost {
 namespace date_time {
   //! Return the day of the week (0==Sunday, 1==Monday, etc)
-  /*! Converts a the year-month-day into a day of the week number
+  /*! Converts a year-month-day into a day of the week number
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   unsigned short
   gregorian_calendar_base<ymd_type_,date_int_type_>::day_of_week(const ymd_type& ymd) {
     unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
@@ -27,29 +24,30 @@ namespace date_time {
     //std::cout << year << "-" << month << "-" << day << " is day: " << d << "\n";
     return d;
   }
-  
-  //!Return the iso week number for the date
-  /*!Implements the rules associated with the iso 8601 week number.
-    Basically the rule is that Week 1 of the year is the week that contains 
+
+  //!Return the ISO 8601 week number for the date
+  /*!Implements the rules associated with the ISO 8601 week number.
+    Basically the rule is that Week 1 of the year is the week that contains
     January 4th or the week that contains the first Thursday in January.
     Reference for this algorithm is the Calendar FAQ by Claus Tondering, April 2000.
   */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   int
   gregorian_calendar_base<ymd_type_,date_int_type_>::week_number(const ymd_type& ymd) {
     unsigned long julianbegin = julian_day_number(ymd_type(ymd.year,1,1));
     unsigned long juliantoday = julian_day_number(ymd);
     unsigned long day = (julianbegin + 3) % 7;
     unsigned long week = (juliantoday + day - julianbegin + 4)/7;
-    
+
     if ((week >= 1) && (week <= 52)) {
-      return week;
+      return static_cast<int>(week);
     }
-    
-    if ((week == 53)) {
+
+    if (week == 53) {
       if((day==6) ||(day == 5 && is_leap_year(ymd.year))) {
-        return week; //under these circumstances week == 53.
+        return static_cast<int>(week); //under these circumstances week == 53.
       } else {
         return 1; //monday - wednesday is in week 1 of next year
       }
@@ -60,35 +58,37 @@ namespace date_time {
       juliantoday = julian_day_number(ymd);
       day = (julianbegin + 3) % 7;
       week = (juliantoday + day - julianbegin + 4)/7;
-      return week;
+      return static_cast<int>(week);
     }
-    
-    return week;  //not reachable -- well except if day == 5 and is_leap_year != true
-    
+
+    return static_cast<int>(week);  //not reachable -- well except if day == 5 and is_leap_year != true
+
   }
-  
+
   //! Convert a ymd_type into a day number
   /*! The day number is an absolute number of days since the start of count
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   date_int_type_
-  gregorian_calendar_base<ymd_type_,date_int_type_>::day_number(const ymd_type& ymd) 
+  gregorian_calendar_base<ymd_type_,date_int_type_>::day_number(const ymd_type& ymd)
   {
     unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
     unsigned short y = static_cast<unsigned short>(ymd.year + 4800 - a);
     unsigned short m = static_cast<unsigned short>(ymd.month + 12*a - 3);
-    unsigned long  d = ymd.day + ((153*m + 2)/5) + 365*y + (y/4) - (y/100) + (y/400) - 32045;
-    return d;
+    unsigned long  d = static_cast<unsigned long>(ymd.day) + ((153*m + 2)/5) + 365*y + (y/4) - (y/100) + (y/400) - 32045;
+    return static_cast<date_int_type>(d);
   }
-  
+
   //! Convert a year-month-day into the julian day number
   /*! Since this implementation uses julian day internally, this is the same as the day_number.
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   date_int_type_
-  gregorian_calendar_base<ymd_type_,date_int_type_>::julian_day_number(const ymd_type& ymd) 
+  gregorian_calendar_base<ymd_type_,date_int_type_>::julian_day_number(const ymd_type& ymd)
   {
     return day_number(ymd);
   }
@@ -98,18 +98,20 @@ namespace date_time {
    *  MJD 0 thus started on 17 Nov 1858(Gregorian) at 00:00:00 UTC
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
-  long
-  gregorian_calendar_base<ymd_type_,date_int_type_>::modjulian_day_number(const ymd_type& ymd) 
+  BOOST_CXX14_CONSTEXPR
+  inline
+  date_int_type_
+  gregorian_calendar_base<ymd_type_,date_int_type_>::modjulian_day_number(const ymd_type& ymd)
   {
     return julian_day_number(ymd)-2400001; //prerounded
   }
-  
+
   //! Change a day number into a year-month-day
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   ymd_type_
-  gregorian_calendar_base<ymd_type_,date_int_type_>::from_day_number(date_int_type dayNumber) 
+  gregorian_calendar_base<ymd_type_,date_int_type_>::from_day_number(date_int_type dayNumber)
   {
     date_int_type a = dayNumber + 32044;
     date_int_type b = (4*a + 3)/146097;
@@ -121,15 +123,16 @@ namespace date_time {
     unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
     year_type year = static_cast<unsigned short>(100*b + d - 4800 + (m/10));
     //std::cout << year << "-" << month << "-" << day << "\n";
-    
+
     return ymd_type(static_cast<unsigned short>(year),month,day);
   }
-  
+
   //! Change a day number into a year-month-day
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   ymd_type_
-  gregorian_calendar_base<ymd_type_,date_int_type_>::from_julian_day_number(date_int_type dayNumber) 
+  gregorian_calendar_base<ymd_type_,date_int_type_>::from_julian_day_number(date_int_type dayNumber)
   {
     date_int_type a = dayNumber + 32044;
     date_int_type b = (4*a+3)/146097;
@@ -141,41 +144,44 @@ namespace date_time {
     unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
     year_type year = static_cast<year_type>(100*b + d - 4800 + (m/10));
     //std::cout << year << "-" << month << "-" << day << "\n";
-    
+
     return ymd_type(year,month,day);
   }
-  
+
   //! Change a modified julian day number into a year-month-day
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   ymd_type_
-  gregorian_calendar_base<ymd_type_,date_int_type_>::from_modjulian_day_number(long dayNumber) {
+  gregorian_calendar_base<ymd_type_,date_int_type_>::from_modjulian_day_number(date_int_type dayNumber) {
     date_int_type jd = dayNumber + 2400001; //is 2400000.5 prerounded
     return from_julian_day_number(jd);
   }
-  
+
   //! Determine if the provided year is a leap year
   /*!
    *@return true if year is a leap year, false otherwise
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   bool
-  gregorian_calendar_base<ymd_type_,date_int_type_>::is_leap_year(year_type year) 
+  gregorian_calendar_base<ymd_type_,date_int_type_>::is_leap_year(year_type year)
   {
     //divisible by 4, not if divisible by 100, but true if divisible by 400
     return (!(year % 4))  && ((year % 100) || (!(year % 400)));
   }
-  
+
   //! Calculate the last day of the month
   /*! Find the day which is the end of the month given year and month
    *  No error checking is performed.
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   unsigned short
   gregorian_calendar_base<ymd_type_,date_int_type_>::end_of_month_day(year_type year,
-                                                                      month_type month) 
+                                                                      month_type month)
   {
     switch (month) {
     case 2:
@@ -183,7 +189,7 @@ namespace date_time {
         return 29;
       } else {
         return 28;
-      };
+      }
     case 4:
     case 6:
     case 9:
@@ -191,29 +197,28 @@ namespace date_time {
       return 30;
     default:
       return 31;
-    };
-
+    }
   }
-  
-  //! Provide the ymd_type specification for the calandar start
+
+  //! Provide the ymd_type specification for the calendar start
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   ymd_type_
-  gregorian_calendar_base<ymd_type_,date_int_type_>::epoch() 
+  gregorian_calendar_base<ymd_type_,date_int_type_>::epoch()
   {
     return ymd_type(1400,1,1);
   }
 
   //! Defines length of a week for week calculations
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   unsigned short
-  gregorian_calendar_base<ymd_type_,date_int_type_>::days_in_week() 
+  gregorian_calendar_base<ymd_type_,date_int_type_>::days_in_week()
   {
     return 7;
   }
 
 
 } } //namespace gregorian
-
-

include/boost/date_time/int_adapter.hpp

@@ -14,7 +14,15 @@
 #include "boost/limits.hpp" //work around compilers without limits
 #include "boost/date_time/special_defs.hpp"
 #include "boost/date_time/locale_config.hpp"
-#include <iostream>
+#ifndef BOOST_DATE_TIME_NO_LOCALE
+#  include <ostream>
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+// conditional expression is constant
+#pragma warning(disable: 4127)
+#endif
 
 namespace boost {
 namespace date_time {
@@ -38,34 +46,34 @@ template<typename int_type_>
 class int_adapter {
 public:
   typedef int_type_ int_type;
-  int_adapter(int_type v) :
+  BOOST_CXX14_CONSTEXPR int_adapter(int_type v) :
     value_(v)
   {}
-  static bool has_infinity()
+  static BOOST_CONSTEXPR bool has_infinity()
   {
     return  true;
   }
-  static const int_adapter  pos_infinity()
+  static BOOST_CONSTEXPR int_adapter  pos_infinity()
   {
     return (::std::numeric_limits<int_type>::max)();
   }
-  static const int_adapter  neg_infinity()
+  static BOOST_CONSTEXPR int_adapter  neg_infinity()
   {
     return (::std::numeric_limits<int_type>::min)();
   }
-  static const int_adapter  not_a_number()
+  static BOOST_CONSTEXPR int_adapter  not_a_number()
   {
     return (::std::numeric_limits<int_type>::max)()-1;
   }
-  static  int_adapter max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+  static BOOST_CONSTEXPR int_adapter max BOOST_PREVENT_MACRO_SUBSTITUTION ()
   {
     return (::std::numeric_limits<int_type>::max)()-2;
   }
-  static  int_adapter min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+  static BOOST_CONSTEXPR int_adapter min BOOST_PREVENT_MACRO_SUBSTITUTION ()
   {
     return (::std::numeric_limits<int_type>::min)()+1;
   }
-  static int_adapter from_special(special_values sv)
+  static BOOST_CXX14_CONSTEXPR int_adapter from_special(special_values sv)
   {
     switch (sv) {
     case not_a_date_time: return not_a_number();
@@ -76,25 +84,25 @@ public:
     default:              return not_a_number();
     }
   }
-  static bool is_inf(int_type v)
+  static BOOST_CONSTEXPR bool is_inf(int_type v)
   {
     return (v == neg_infinity().as_number() ||
             v == pos_infinity().as_number());
   }
-  static bool is_neg_inf(int_type v)
+  static BOOST_CXX14_CONSTEXPR bool is_neg_inf(int_type v)
   {
     return (v == neg_infinity().as_number());
   }
-  static bool is_pos_inf(int_type v)
+  static BOOST_CXX14_CONSTEXPR bool is_pos_inf(int_type v)
   {
     return (v == pos_infinity().as_number());
   }
-  static bool is_not_a_number(int_type v)
+  static BOOST_CXX14_CONSTEXPR bool is_not_a_number(int_type v)
   {
     return (v == not_a_number().as_number());
   }
   //! Returns either special value type or is_not_special
-  static special_values to_special(int_type v)
+  static BOOST_CXX14_CONSTEXPR special_values to_special(int_type v)
   {
     if (is_not_a_number(v)) return not_a_date_time;
     if (is_neg_inf(v)) return neg_infin;
@@ -103,40 +111,38 @@ public:
   }
 
   //-3 leaves room for representations of infinity and not a date
-  static  int_type maxcount()
+  static BOOST_CONSTEXPR int_type maxcount()
   {
     return (::std::numeric_limits<int_type>::max)()-3;
   }
-  bool is_infinity() const
+  BOOST_CONSTEXPR bool is_infinity() const
   {
     return (value_ == neg_infinity().as_number() ||
             value_ == pos_infinity().as_number());
   }
-  bool is_pos_infinity()const
+  BOOST_CONSTEXPR bool is_pos_infinity()const
   {
     return(value_ == pos_infinity().as_number());
   }
-  bool is_neg_infinity()const
+  BOOST_CONSTEXPR bool is_neg_infinity()const
   {
     return(value_ == neg_infinity().as_number());
   }
-  bool is_nan() const
+  BOOST_CONSTEXPR bool is_nan() const
   {
     return (value_ == not_a_number().as_number());
   }
-  bool is_special() const
+  BOOST_CONSTEXPR bool is_special() const
   {
     return(is_infinity() || is_nan()); 
   }
-  bool operator==(const int_adapter& rhs) const
+  BOOST_CONSTEXPR bool operator==(const int_adapter& rhs) const
   {
     return (compare(rhs) == 0);
   }
-  bool operator==(const int& rhs) const
+  BOOST_CXX14_CONSTEXPR bool operator==(const int& rhs) const
   {
-    // quiets compiler warnings
-    bool is_signed = std::numeric_limits<int_type>::is_signed;
-    if(!is_signed)
+    if(!std::numeric_limits<int_type>::is_signed)
     {
       if(is_neg_inf(value_) && rhs == 0)
       {
@@ -145,15 +151,13 @@ public:
     }
     return (compare(rhs) == 0);
   }
-  bool operator!=(const int_adapter& rhs) const
+  BOOST_CONSTEXPR bool operator!=(const int_adapter& rhs) const
   {
     return (compare(rhs) != 0);
   }
-  bool operator!=(const int& rhs) const
+  BOOST_CXX14_CONSTEXPR bool operator!=(const int& rhs) const
   {
-    // quiets compiler warnings
-    bool is_signed = std::numeric_limits<int_type>::is_signed;
-    if(!is_signed)
+    if(!std::numeric_limits<int_type>::is_signed)
     {
       if(is_neg_inf(value_) && rhs == 0)
       {
@@ -162,15 +166,14 @@ public:
     }
     return (compare(rhs) != 0);
   }
-  bool operator<(const int_adapter& rhs) const
+  BOOST_CONSTEXPR bool operator<(const int_adapter& rhs) const
   {
     return (compare(rhs) == -1);
   }
-  bool operator<(const int& rhs) const
+  BOOST_CXX14_CONSTEXPR bool operator<(const int& rhs) const
   {
     // quiets compiler warnings
-    bool is_signed = std::numeric_limits<int_type>::is_signed;
-    if(!is_signed)
+    if(!std::numeric_limits<int_type>::is_signed)
     {
       if(is_neg_inf(value_) && rhs == 0)
       {
@@ -179,16 +182,16 @@ public:
     }
     return (compare(rhs) == -1);
   }
-  bool operator>(const int_adapter& rhs) const
+  BOOST_CONSTEXPR bool operator>(const int_adapter& rhs) const
   {
     return (compare(rhs) == 1);
   }
-  int_type as_number() const
+  BOOST_CONSTEXPR int_type as_number() const
   {
     return value_;
   }
   //! Returns either special value type or is_not_special
-  special_values as_special() const
+  BOOST_CONSTEXPR special_values as_special() const
   {
     return int_adapter::to_special(value_);
   }
@@ -201,7 +204,7 @@ public:
   /*! Operator allows for adding dissimilar int_adapter types.
    * The return type will match that of the the calling object's type */
   template<class rhs_type>
-  inline
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator+(const int_adapter<rhs_type>& rhs) const
   {
     if(is_special() || rhs.is_special())
@@ -228,9 +231,10 @@ public:
         return int_adapter::neg_infinity();
       }
     }
-    return int_adapter<int_type>(value_ + rhs.as_number());
+    return int_adapter<int_type>(value_ + static_cast<int_type>(rhs.as_number()));
   }
 
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator+(const int_type rhs) const
   {
     if(is_special())
@@ -250,7 +254,7 @@ public:
   /*! Operator allows for subtracting dissimilar int_adapter types.
    * The return type will match that of the the calling object's type */
   template<class rhs_type>
-  inline
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator-(const int_adapter<rhs_type>& rhs)const
   {
     if(is_special() || rhs.is_special())
@@ -277,8 +281,10 @@ public:
         return int_adapter::pos_infinity();
       }
     }
-    return int_adapter<int_type>(value_ - rhs.as_number());
+    return int_adapter<int_type>(value_ - static_cast<int_type>(rhs.as_number()));
   }
+
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator-(const int_type rhs) const
   {
     if(is_special())
@@ -296,6 +302,7 @@ public:
   }
 
   // should templatize this to be consistant with op +-
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator*(const int_adapter& rhs)const
   {
     if(this->is_special() || rhs.is_special())
@@ -304,8 +311,10 @@ public:
     }
     return int_adapter<int_type>(value_ * rhs.value_);
   }
+
   /*! Provided for cases when automatic conversion from 
    * 'int' to 'int_adapter' causes incorrect results. */
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator*(const int rhs) const
   {
     if(is_special())
@@ -316,6 +325,7 @@ public:
   }
 
   // should templatize this to be consistant with op +-
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator/(const int_adapter& rhs)const
   {
     if(this->is_special() || rhs.is_special())
@@ -329,23 +339,27 @@ public:
         return mult_div_specials(rhs);
       }
       else { // let divide by zero blow itself up
-        return int_adapter<int_type>(value_ / rhs.value_);
+        return int_adapter<int_type>(value_ / rhs.value_); //NOLINT
       }
     }
     return int_adapter<int_type>(value_ / rhs.value_);
   }
+
   /*! Provided for cases when automatic conversion from 
    * 'int' to 'int_adapter' causes incorrect results. */
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator/(const int rhs) const
   {
     if(is_special() && rhs != 0)
     {
       return mult_div_specials(rhs);
     }
-    return int_adapter<int_type>(value_ / rhs);
+    // let divide by zero blow itself up like int
+    return int_adapter<int_type>(value_ / rhs); //NOLINT
   }
 
   // should templatize this to be consistant with op +-
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator%(const int_adapter& rhs)const
   {
     if(this->is_special() || rhs.is_special())
@@ -359,26 +373,31 @@ public:
         return mult_div_specials(rhs);
       }
       else { // let divide by zero blow itself up
-        return int_adapter<int_type>(value_ % rhs.value_);
+        return int_adapter<int_type>(value_ % rhs.value_); //NOLINT
       }
     }
     return int_adapter<int_type>(value_ % rhs.value_);
   }
+
   /*! Provided for cases when automatic conversion from 
    * 'int' to 'int_adapter' causes incorrect results. */
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator%(const int rhs) const
   {
     if(is_special() && rhs != 0)
     {
       return mult_div_specials(rhs);
     }
-    return int_adapter<int_type>(value_ % rhs);
+    // let divide by zero blow itself up
+    return int_adapter<int_type>(value_ % rhs); //NOLINT
   }
+
 private:
   int_type value_;
   
   //! returns -1, 0, 1, or 2 if 'this' is <, ==, >, or 'nan comparison' rhs
-  int compare(const int_adapter& rhs)const
+  BOOST_CXX14_CONSTEXPR
+  int compare( const int_adapter& rhs ) const
   {
     if(this->is_special() || rhs.is_special())
     {
@@ -405,25 +424,19 @@ private:
     // implied-> if(value_ == rhs.value_) 
     return 0;
   }
+
   /* When multiplying and dividing with at least 1 special value
    * very simmilar rules apply. In those cases where the rules
    * are different, they are handled in the respective operator 
    * function. */
   //! Assumes at least 'this' or 'rhs' is a special value
-  int_adapter mult_div_specials(const int_adapter& rhs)const
+  BOOST_CXX14_CONSTEXPR
+  int_adapter mult_div_specials(const int_adapter& rhs) const
   {
-    int min_value; 
-    // quiets compiler warnings
-    bool is_signed = std::numeric_limits<int_type>::is_signed;
-    if(is_signed) {
-      min_value = 0;
-    }
-    else {
-      min_value = 1;// there is no zero with unsigned
-    }
     if(this->is_nan() || rhs.is_nan()) {
       return int_adapter<int_type>(not_a_number());
     }
+    BOOST_CONSTEXPR_OR_CONST int min_value = std::numeric_limits<int_type>::is_signed ? 0 : 1; 
     if((*this > 0 && rhs > 0) || (*this < min_value && rhs < min_value)) {
         return int_adapter<int_type>(pos_infinity());
     }
@@ -433,26 +446,20 @@ private:
     //implied -> if(this->value_ == 0 || rhs.value_ == 0)
     return int_adapter<int_type>(not_a_number());
   }
+
   /* Overloaded function necessary because of special
    * situation where int_adapter is instantiated with 
    * 'unsigned' and func is called with negative int.
    * It would produce incorrect results since 'unsigned'
    * wraps around when initialized with a negative value */
   //! Assumes 'this' is a special value
+  BOOST_CXX14_CONSTEXPR
   int_adapter mult_div_specials(const int& rhs) const
   {
-    int min_value; 
-    // quiets compiler warnings
-    bool is_signed = std::numeric_limits<int_type>::is_signed;
-    if(is_signed) {
-      min_value = 0;
-    }
-    else {
-      min_value = 1;// there is no zero with unsigned
-    }
     if(this->is_nan()) {
       return int_adapter<int_type>(not_a_number());
     }
+    BOOST_CONSTEXPR_OR_CONST int min_value = std::numeric_limits<int_type>::is_signed ? 0 : 1; 
     if((*this > 0 && rhs > 0) || (*this < min_value && rhs < 0)) {
         return int_adapter<int_type>(pos_infinity());
     }
@@ -462,7 +469,7 @@ private:
     //implied -> if(this->value_ == 0 || rhs.value_ == 0)
     return int_adapter<int_type>(not_a_number());
   }
-  
+
 };
 
 #ifndef BOOST_DATE_TIME_NO_LOCALE
@@ -502,6 +509,8 @@ private:
 
 } } //namespace date_time
 
-
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
 
 #endif

include/boost/date_time/iso_format.hpp

@@ -14,11 +14,11 @@
 namespace boost {
 namespace date_time {
 
-//! Class to provide common iso formatting spec
+//! Class to provide common ISO 8601 formatting spec
 template<class charT>
 class iso_format_base {
 public:
-  //! Describe month format -- its an integer in iso format
+  //! Describe month format -- its an integer in ISO 8601 format
   static month_format_spec month_format()
   {
     return month_as_integer;
@@ -40,17 +40,17 @@ public:
     return "-infinity";
   }
 
-  //! ISO char for a year -- used in durations
+  //! ISO 8601 char for a year -- used in durations
   static charT year_sep_char()
   {
     return 'Y';
   }
-  //! ISO char for a month
+  //! ISO 8601 char for a month
   static charT month_sep_char()
   {
     return '-';
   }
-  //! ISO char for a day
+  //! ISO 8601 char for a day
   static charT day_sep_char()
   {
     return '-';
@@ -70,7 +70,7 @@ public:
   {
     return ':';
   }
-  //! ISO char for a period
+  //! ISO 8601 char for a period
   static charT period_start_char()
   {
     return 'P';
@@ -143,11 +143,11 @@ public:
 
 #ifndef BOOST_NO_STD_WSTRING
 
-//! Class to provide common iso formatting spec
+//! Class to provide common ISO 8601 formatting spec
 template<>
 class iso_format_base<wchar_t> {
 public:
-  //! Describe month format -- its an integer in iso format
+  //! Describe month format -- its an integer in ISO 8601 format
   static month_format_spec month_format()
   {
     return month_as_integer;
@@ -169,17 +169,17 @@ public:
     return L"-infinity";
   }
 
-  //! ISO char for a year -- used in durations
+  //! ISO 8601 char for a year -- used in durations
   static wchar_t year_sep_char()
   {
     return 'Y';
   }
-  //! ISO char for a month
+  //! ISO 8601 char for a month
   static wchar_t month_sep_char()
   {
     return '-';
   }
-  //! ISO char for a day
+  //! ISO 8601 char for a day
   static wchar_t day_sep_char()
   {
     return '-';
@@ -199,7 +199,7 @@ public:
   {
     return ':';
   }
-  //! ISO char for a period
+  //! ISO 8601 char for a period
   static wchar_t period_start_char()
   {
     return 'P';
@@ -272,7 +272,7 @@ public:
 
 #endif // BOOST_NO_STD_WSTRING
 
-//! Format description for iso normal YYYYMMDD
+//! Format description for ISO 8601 normal YYYYMMDD
 template<class charT>
 class iso_format : public iso_format_base<charT> {
 public:

include/boost/date_time/local_time/conversion.hpp

@@ -18,9 +18,8 @@ namespace local_time {
 
 //! Function that creates a tm struct from a local_date_time
 inline
-tm to_tm(const local_date_time& lt) {
-  tm lt_tm;
-  lt_tm = posix_time::to_tm(lt.local_time());
+std::tm to_tm(const local_date_time& lt) {
+  std::tm lt_tm = posix_time::to_tm(lt.local_time());
   if(lt.is_dst()){
     lt_tm.tm_isdst = 1;
   }

include/boost/date_time/local_time/custom_time_zone.hpp

@@ -2,7 +2,7 @@
 #define LOCAL_TIME_CUSTOM_TIME_ZONE_HPP__
 
 /* Copyright (c) 2003-2005 CrystalClear Software, Inc.
- * Subject to the Boost Software License, Version 1.0. 
+ * 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$
@@ -34,8 +34,8 @@ namespace local_time {
     typedef typename base_type::stringstream_type stringstream_type;
     typedef date_time::time_zone_names_base<CharT> time_zone_names;
     typedef CharT char_type;
-    
-    custom_time_zone_base(const time_zone_names& zone_names,   
+
+    custom_time_zone_base(const time_zone_names& zone_names,
                      const time_duration_type& utc_offset,
                      const dst_adjustment_offsets& dst_shift,
                      boost::shared_ptr<dst_calc_rule> calc_rule) :
@@ -43,8 +43,8 @@ namespace local_time {
       base_utc_offset_(utc_offset),
       dst_offsets_(dst_shift),
       dst_calc_rules_(calc_rule)
-    {};
-    virtual ~custom_time_zone_base() {};
+    {}
+    virtual ~custom_time_zone_base() {}
     virtual string_type dst_zone_abbrev() const
     {
       return zone_names_.dst_zone_abbrev();
@@ -64,7 +64,7 @@ namespace local_time {
     //! True if zone uses daylight savings adjustments
     virtual bool has_dst() const
     {
-      return (dst_calc_rules_); //if calc_rule is set the tz has dst
+      return (bool) dst_calc_rules_; //if calc_rule is set the tz has dst
     }
     //! Local time that DST starts -- NADT if has_dst is false
     virtual posix_time::ptime dst_local_start_time(gregorian::greg_year y) const
@@ -154,7 +154,6 @@ namespace local_time {
     }
   private:
     time_zone_names zone_names_;
-    bool has_dst_;
     time_duration_type base_utc_offset_;
     dst_adjustment_offsets dst_offsets_;
     boost::shared_ptr<dst_calc_rule> dst_calc_rules_;

include/boost/date_time/local_time/local_date_time.hpp

@@ -2,44 +2,48 @@
 #define LOCAL_TIME_LOCAL_DATE_TIME_HPP__
 
 /* Copyright (c) 2003-2005 CrystalClear Software, Inc.
- * Subject to the Boost Software License, Version 1.0. 
+ * 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$
  */
 
-
-#include "boost/date_time/time.hpp"
-#include "boost/date_time/posix_time/posix_time.hpp" //todo remove?
-#include "boost/shared_ptr.hpp"
-#include "boost/date_time/dst_rules.hpp"
-#include "boost/date_time/time_zone_base.hpp"
-#include "boost/date_time/special_defs.hpp"
 #include <string>
+#include <iomanip>
 #include <sstream>
+#include <stdexcept>
+#include <boost/shared_ptr.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/time.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp> //todo remove?
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/dst_rules.hpp>
+#include <boost/date_time/time_zone_base.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/time_resolution_traits.hpp> // absolute_value
 
 namespace boost {
 namespace local_time {
 
   //! simple exception for reporting when STD or DST cannot be determined
-  struct ambiguous_result : public std::logic_error
+  struct BOOST_SYMBOL_VISIBLE ambiguous_result : public std::logic_error
   {
-    ambiguous_result (std::string _msg="") :
-      std::logic_error(std::string("Daylight Savings Results are ambiguous: " + _msg)) {}
+    ambiguous_result (std::string const& msg = std::string()) :
+      std::logic_error(std::string("Daylight Savings Results are ambiguous: " + msg)) {}
   };
   //! simple exception for when time label given cannot exist
-  struct time_label_invalid : public std::logic_error
+  struct BOOST_SYMBOL_VISIBLE time_label_invalid : public std::logic_error
   {
-    time_label_invalid (std::string _msg="") :
-      std::logic_error(std::string("Time label given is invalid: " + _msg)) {}
+    time_label_invalid (std::string const& msg = std::string()) :
+      std::logic_error(std::string("Time label given is invalid: " + msg)) {}
   };
-  struct dst_not_valid: public std::logic_error
+  struct BOOST_SYMBOL_VISIBLE dst_not_valid: public std::logic_error
   {
-    dst_not_valid(std::string _msg="") :
-      std::logic_error(std::string("is_dst flag does not match resulting dst for time label given: " + _msg)) {}
+    dst_not_valid(std::string const& msg = std::string()) :
+      std::logic_error(std::string("is_dst flag does not match resulting dst for time label given: " + msg)) {}
   };
 
-  //TODO: I think these should be in local_date_time_base and not 
+  //TODO: I think these should be in local_date_time_base and not
   // necessarily brought into the namespace
   using date_time::time_is_dst_result;
   using date_time::is_in_dst;
@@ -49,17 +53,17 @@ namespace local_time {
 
   //! Representation of "wall-clock" time in a particular time zone
   /*! Representation of "wall-clock" time in a particular time zone
-   * Local_date_time_base holds a time value (date and time offset from 00:00) 
-   * along with a time zone. The time value is stored as UTC and conversions 
-   * to wall clock time are made as needed. This approach allows for 
-   * operations between wall-clock times in different time zones, and 
-   * daylight savings time considerations, to be made. Time zones are 
+   * Local_date_time_base holds a time value (date and time offset from 00:00)
+   * along with a time zone. The time value is stored as UTC and conversions
+   * to wall clock time are made as needed. This approach allows for
+   * operations between wall-clock times in different time zones, and
+   * daylight savings time considerations, to be made. Time zones are
    * required to be in the form of a boost::shared_ptr<time_zone_base>.
    */
-  template<class utc_time_=posix_time::ptime, 
+  template<class utc_time_=posix_time::ptime,
            class tz_type=date_time::time_zone_base<utc_time_,char> >
-  class local_date_time_base :  public date_time::base_time<utc_time_, 
-                                                            boost::posix_time::posix_time_system> { 
+  class BOOST_SYMBOL_VISIBLE local_date_time_base :  public date_time::base_time<utc_time_,
+                                                            boost::posix_time::posix_time_system> {
   public:
     typedef utc_time_ utc_time_type;
     typedef typename utc_time_type::time_duration_type time_duration_type;
@@ -68,41 +72,41 @@ namespace local_time {
     typedef typename utc_time_type::time_system_type time_system_type;
     /*! This constructor interprets the passed time as a UTC time.
      *  So, for example, if the passed timezone is UTC-5 then the
-     *  time will be adjusted back 5 hours.  The time zone allows for 
+     *  time will be adjusted back 5 hours.  The time zone allows for
      *  automatic calculation of whether the particular time is adjusted for
      *  daylight savings, etc.
      *  If the time zone shared pointer is null then time stays unadjusted.
      *@param t A UTC time
      *@param tz Timezone for to adjust the UTC time to.
      */
-    local_date_time_base(utc_time_type t, 
-                         boost::shared_ptr<tz_type> tz) : 
+    local_date_time_base(utc_time_type t,
+                         boost::shared_ptr<tz_type> tz) :
       date_time::base_time<utc_time_type, time_system_type>(t),
       zone_(tz)
     {
       // param was already utc so nothing more to do
-    } 
+    }
 
-    /*! This constructs a local time -- the passed time information 
-     * understood to be in the passed tz. The DST flag must be passed 
-     * to indicate whether the time is in daylight savings or not.  
-     *  @throws -- time_label_invalid if the time passed does not exist in 
-     *             the given locale. The non-existent case occurs typically 
-     *             during the shift-back from daylight savings time.  When 
-     *             the clock is shifted forward a range of times 
+    /*! This constructs a local time -- the passed time information
+     * understood to be in the passed tz. The DST flag must be passed
+     * to indicate whether the time is in daylight savings or not.
+     *  @throws -- time_label_invalid if the time passed does not exist in
+     *             the given locale. The non-existent case occurs typically
+     *             during the shift-back from daylight savings time.  When
+     *             the clock is shifted forward a range of times
      *             (2 am to 3 am in the US) is skipped and hence is invalid.
-     *  @throws -- dst_not_valid if the DST flag is passed for a period 
+     *  @throws -- dst_not_valid if the DST flag is passed for a period
      *             where DST is not active.
      */
-    local_date_time_base(date_type d, 
+    local_date_time_base(date_type d,
                          time_duration_type td,
-                         boost::shared_ptr<tz_type> tz, 
+                         boost::shared_ptr<tz_type> tz,
                          bool dst_flag) : //necessary for constr_adj()
       date_time::base_time<utc_time_type,time_system_type>(construction_adjustment(utc_time_type(d, td), tz, dst_flag)),
       zone_(tz)
     {
       if(tz != boost::shared_ptr<tz_type>() && tz->has_dst()){
-        
+
         // d & td are already local so we use them
         time_is_dst_result result = check_dst(d, td, tz);
         bool in_dst = (result == is_in_dst); // less processing than is_dst()
@@ -110,35 +114,35 @@ namespace local_time {
         // ambig occurs at end, invalid at start
         if(result == invalid_time_label){
           // Ex: 2:15am local on trans-in day in nyc, dst_flag irrelevant
-          std::stringstream ss;
+          std::ostringstream ss;
           ss << "time given: " << d << ' ' << td;
-          throw time_label_invalid(ss.str());
+          boost::throw_exception(time_label_invalid(ss.str()));
         }
         else if(result != ambiguous && in_dst != dst_flag){
           // is dst_flag accurate?
           // Ex: false flag in NYC in June
-          std::stringstream ss;
-          ss << "flag given: " << (dst_flag ? "dst=true" : "dst=false")
-            << ", dst calculated: " << (in_dst ? "dst=true" : "dst=false");
-          throw dst_not_valid(ss.str());
+          std::ostringstream ss;
+          ss.setf(std::ios_base::boolalpha);
+          ss << "flag given: dst=" << dst_flag << ", dst calculated: dst=" << in_dst;
+          boost::throw_exception(dst_not_valid(ss.str()));
         }
-        
+
         // everything checks out and conversion to utc already done
       }
-    } 
-    
+    }
+
     //TODO maybe not the right set...Ignore the last 2 for now...
-    enum DST_CALC_OPTIONS { EXCEPTION_ON_ERROR, NOT_DATE_TIME_ON_ERROR }; 
+    enum DST_CALC_OPTIONS { EXCEPTION_ON_ERROR, NOT_DATE_TIME_ON_ERROR };
                             //ASSUME_DST_ON_ERROR, ASSUME_NOT_DST_ON_ERROR };
 
-    /*! This constructs a local time -- the passed time information 
-     * understood to be in the passed tz.  The DST flag is calculated 
-     * according to the specified rule. 
+    /*! This constructs a local time -- the passed time information
+     * understood to be in the passed tz.  The DST flag is calculated
+     * according to the specified rule.
      */
-    local_date_time_base(date_type d, 
+    local_date_time_base(date_type d,
                          time_duration_type td,
-                         boost::shared_ptr<tz_type> tz, 
-                         DST_CALC_OPTIONS calc_option) : 
+                         boost::shared_ptr<tz_type> tz,
+                         DST_CALC_OPTIONS calc_option) :
       // dummy value - time_ is set in constructor code
       date_time::base_time<utc_time_type,time_system_type>(utc_time_type(d,td)),
       zone_(tz)
@@ -146,9 +150,9 @@ namespace local_time {
       time_is_dst_result result = check_dst(d, td, tz);
       if(result == ambiguous) {
         if(calc_option == EXCEPTION_ON_ERROR){
-          std::stringstream ss;
+          std::ostringstream ss;
           ss << "time given: " << d << ' ' << td;
-          throw ambiguous_result(ss.str());
+          boost::throw_exception(ambiguous_result(ss.str()));
         }
         else{ // NADT on error
           this->time_ = posix_time::posix_time_system::get_time_rep(date_type(date_time::not_a_date_time), time_duration_type(date_time::not_a_date_time));
@@ -156,45 +160,45 @@ namespace local_time {
       }
       else if(result == invalid_time_label){
         if(calc_option == EXCEPTION_ON_ERROR){
-          std::stringstream ss;
+          std::ostringstream ss;
           ss << "time given: " << d << ' ' << td;
-          throw time_label_invalid(ss.str());
+          boost::throw_exception(time_label_invalid(ss.str()));
         }
         else{ // NADT on error
           this->time_ = posix_time::posix_time_system::get_time_rep(date_type(date_time::not_a_date_time), time_duration_type(date_time::not_a_date_time));
         }
       }
       else if(result == is_in_dst){
-        utc_time_type t = 
+        utc_time_type t =
           construction_adjustment(utc_time_type(d, td), tz, true);
-        this->time_ = posix_time::posix_time_system::get_time_rep(t.date(), 
+        this->time_ = posix_time::posix_time_system::get_time_rep(t.date(),
                                                             t.time_of_day());
       }
       else{
-        utc_time_type t = 
+        utc_time_type t =
           construction_adjustment(utc_time_type(d, td), tz, false);
-        this->time_ = posix_time::posix_time_system::get_time_rep(t.date(), 
+        this->time_ = posix_time::posix_time_system::get_time_rep(t.date(),
                                                             t.time_of_day());
       }
     }
 
 
     //! Determines if given time label is in daylight savings for given zone
-    /*! Determines if given time label is in daylight savings for given zone. 
-     * Takes a date and time_duration representing a local time, along 
+    /*! Determines if given time label is in daylight savings for given zone.
+     * Takes a date and time_duration representing a local time, along
      * with time zone, and returns a time_is_dst_result object as result.
      */
-    static time_is_dst_result check_dst(date_type d, 
+    static time_is_dst_result check_dst(date_type d,
                                         time_duration_type td,
-                                        boost::shared_ptr<tz_type> tz) 
+                                        boost::shared_ptr<tz_type> tz)
     {
       if(tz != boost::shared_ptr<tz_type>() && tz->has_dst()) {
         typedef typename date_time::dst_calculator<date_type, time_duration_type> dst_calculator;
         return dst_calculator::local_is_dst(
-            d, td, 
-            tz->dst_local_start_time(d.year()).date(), 
-            tz->dst_local_start_time(d.year()).time_of_day(), 
-            tz->dst_local_end_time(d.year()).date(), 
+            d, td,
+            tz->dst_local_start_time(d.year()).date(),
+            tz->dst_local_start_time(d.year()).time_of_day(),
+            tz->dst_local_end_time(d.year()).date(),
             tz->dst_local_end_time(d.year()).time_of_day(),
             tz->dst_offset()
         );
@@ -205,10 +209,10 @@ namespace local_time {
     }
 
     //! Simple destructor, releases time zone if last referrer
-    ~local_date_time_base() {};
+    ~local_date_time_base() {}
 
     //! Copy constructor
-    local_date_time_base(const local_date_time_base& rhs) : 
+    local_date_time_base(const local_date_time_base& rhs) :
       date_time::base_time<utc_time_type, time_system_type>(rhs),
       zone_(rhs.zone_)
     {}
@@ -221,7 +225,7 @@ namespace local_time {
     {}
 
     //! returns time zone associated with calling instance
-    boost::shared_ptr<tz_type> zone() const 
+    boost::shared_ptr<tz_type> zone() const
     {
       return zone_;
     }
@@ -240,12 +244,12 @@ namespace local_time {
             return false;
           case is_in_dst:
             return true;
-          case ambiguous: 
+          case ambiguous:
             if(lt + zone_->dst_offset() < zone_->dst_local_end_time(lt.date().year())) {
               return true;
             }
             break;
-          case invalid_time_label: 
+          case invalid_time_label:
             if(lt >= zone_->dst_local_start_time(lt.date().year())) {
               return true;
             }
@@ -255,12 +259,12 @@ namespace local_time {
       return false;
     }
     //! Returns object's time value as a utc representation
-    utc_time_type utc_time() const 
+    utc_time_type utc_time() const
     {
       return utc_time_type(this->time_);
     }
     //! Returns object's time value as a local representation
-    utc_time_type local_time() const 
+    utc_time_type local_time() const
     {
       if(zone_ != boost::shared_ptr<tz_type>()){
         utc_time_type lt = this->utc_time() + zone_->base_utc_offset();
@@ -273,12 +277,12 @@ namespace local_time {
     }
     //! Returns string in the form "2003-Aug-20 05:00:00 EDT"
     /*! Returns string in the form "2003-Aug-20 05:00:00 EDT". If
-     * time_zone is NULL the time zone abbreviation will be "UTC". The time 
+     * time_zone is NULL the time zone abbreviation will be "UTC". The time
      * zone abbrev will not be included if calling object is a special_value*/
     std::string to_string() const
     {
       //TODO is this a temporary function ???
-      std::stringstream ss;
+      std::ostringstream ss;
       if(this->is_special()){
         ss << utc_time();
         return ss.str();
@@ -301,17 +305,17 @@ namespace local_time {
       }
       return ss.str();
     }
-    /*! returns a local_date_time_base in the given time zone with the 
+    /*! returns a local_date_time_base in the given time zone with the
      * optional time_duration added. */
-    local_date_time_base local_time_in(boost::shared_ptr<tz_type> new_tz, 
-                                       time_duration_type td=time_duration_type(0,0,0)) const 
+    local_date_time_base local_time_in(boost::shared_ptr<tz_type> new_tz,
+                                       time_duration_type td=time_duration_type(0,0,0)) const
     {
       return local_date_time_base(utc_time_type(this->time_) + td, new_tz);
     }
-    
-    //! Returns name of associated time zone or "Coordinated Universal Time".
-    /*! Optional bool parameter will return time zone as an offset 
-     * (ie "+07:00" extended iso format). Empty string is returned for 
+
+    //! Returns name of associated time zone or "UTC".
+    /*! Optional bool parameter will return time zone as an offset
+     * (ie "+07:00" extended ISO 8601 format). Empty string is returned for
      * classes that do not use a time_zone */
     std::string zone_name(bool as_offset=false) const
     {
@@ -320,7 +324,7 @@ namespace local_time {
           return std::string("Z");
         }
         else {
-          return std::string("Coordinated Universal Time");
+          return std::string("UTC");
         }
       }
       if (is_dst()) {
@@ -344,8 +348,8 @@ namespace local_time {
       }
     }
     //! Returns abbreviation of associated time zone or "UTC".
-    /*! Optional bool parameter will return time zone as an offset 
-     * (ie "+0700" iso format). Empty string is returned for classes 
+    /*! Optional bool parameter will return time zone as an offset
+     * (ie "+0700" ISO 8601 format). Empty string is returned for classes
      * that do not use a time_zone */
     std::string zone_abbrev(bool as_offset=false) const
     {
@@ -386,7 +390,7 @@ namespace local_time {
       }
       return zone_->to_posix_string();
     }
-      
+
     //! Equality comparison operator
     /*bool operator==(const date_time::base_time<boost::posix_time::ptime,boost::posix_time::posix_time_system>& rhs) const
     { // fails due to rhs.time_ being protected
@@ -424,45 +428,45 @@ namespace local_time {
       return (*this > rhs || *this == rhs);
     }
 
-    //! Local_date_time + date_duration 
+    //! Local_date_time + date_duration
     local_date_time_base operator+(const date_duration_type& dd) const
     {
       return local_date_time_base(time_system_type::add_days(this->time_,dd), zone_);
     }
-    //! Local_date_time += date_duration 
+    //! Local_date_time += date_duration
     local_date_time_base operator+=(const date_duration_type& dd)
     {
       this->time_ = time_system_type::add_days(this->time_,dd);
       return *this;
     }
-    //! Local_date_time - date_duration 
+    //! Local_date_time - date_duration
     local_date_time_base operator-(const date_duration_type& dd) const
     {
       return local_date_time_base(time_system_type::subtract_days(this->time_,dd), zone_);
     }
-    //! Local_date_time -= date_duration 
+    //! Local_date_time -= date_duration
     local_date_time_base operator-=(const date_duration_type& dd)
     {
       this->time_ = time_system_type::subtract_days(this->time_,dd);
       return *this;
     }
-    //! Local_date_time + time_duration 
+    //! Local_date_time + time_duration
     local_date_time_base operator+(const time_duration_type& td) const
     {
       return local_date_time_base(time_system_type::add_time_duration(this->time_,td), zone_);
     }
-    //! Local_date_time += time_duration 
-    local_date_time_base operator+=(const time_duration_type& td) 
+    //! Local_date_time += time_duration
+    local_date_time_base operator+=(const time_duration_type& td)
     {
       this->time_ = time_system_type::add_time_duration(this->time_,td);
       return *this;
     }
-    //! Local_date_time - time_duration 
+    //! Local_date_time - time_duration
     local_date_time_base operator-(const time_duration_type& td) const
     {
       return local_date_time_base(time_system_type::subtract_time_duration(this->time_,td), zone_);
     }
-    //! Local_date_time -= time_duration 
+    //! Local_date_time -= time_duration
     local_date_time_base operator-=(const time_duration_type& td)
     {
       this->time_ = time_system_type::subtract_time_duration(this->time_,td);
@@ -479,7 +483,7 @@ namespace local_time {
 
     /*! Adjust the passed in time to UTC?
      */
-    utc_time_type construction_adjustment(utc_time_type t, 
+    utc_time_type construction_adjustment(utc_time_type t,
                                           boost::shared_ptr<tz_type> z,
                                           bool dst_flag)
     {
@@ -494,21 +498,21 @@ namespace local_time {
 
     /*! Simple formatting code -- todo remove this?
      */
-    std::string zone_as_offset(const time_duration_type& td, 
+    std::string zone_as_offset(const time_duration_type& td,
                                const std::string& separator) const
     {
-      std::stringstream ss;
+      std::ostringstream ss;
       if(td.is_negative()) {
         // a negative duration is represented as "-[h]h:mm"
-        // we require two digits for the hour. A positive duration 
+        // we require two digits for the hour. A positive duration
         // with the %H flag will always give two digits
         ss << "-";
       }
       else {
         ss << "+";
       }
-      ss  << std::setw(2) << std::setfill('0') 
-          << date_time::absolute_value(td.hours()) 
+      ss  << std::setw(2) << std::setfill('0')
+          << date_time::absolute_value(td.hours())
           << separator
           << std::setw(2) << std::setfill('0')
           << date_time::absolute_value(td.minutes());

include/boost/date_time/local_time/local_time_io.hpp

@@ -8,12 +8,18 @@
  * $Date$
  */
 
+#include <string>
+#include <locale>
 #include <iostream>
-#include "boost/date_time/local_time/local_date_time.hpp"
-#include "boost/date_time/local_time/posix_time_zone.hpp"
-#include "boost/date_time/time_facet.hpp"
-#include "boost/date_time/string_convert.hpp"
-#include "boost/io/ios_state.hpp"
+#include <iterator> // i/ostreambuf_iterator
+#include <boost/io/ios_state.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/time_facet.hpp>
+#include <boost/date_time/string_convert.hpp>
+#include <boost/date_time/local_time/local_time_types.hpp>
+#include <boost/date_time/local_time/local_date_time.hpp>
+#include <boost/date_time/local_time/posix_time_zone.hpp>
+#include <boost/date_time/local_time/conversion.hpp> // to_tm will be needed in the facets
 
 namespace boost {
 namespace local_time {
@@ -23,7 +29,7 @@ namespace local_time {
 
   typedef boost::date_time::time_input_facet<local_date_time::utc_time_type,wchar_t> wlocal_time_input_facet;
   typedef boost::date_time::time_input_facet<local_date_time::utc_time_type,char>     local_time_input_facet;
-  
+
   //! operator<< for local_date_time - see local_time docs for formatting details
   template<class CharT, class TraitsT>
   inline
@@ -33,9 +39,8 @@ namespace local_time {
     boost::io::ios_flags_saver iflags(os);
     typedef local_date_time time_type;//::utc_time_type typename 
     typedef date_time::time_facet<time_type, CharT> custom_time_facet;
-    typedef std::time_put<CharT> std_time_facet;
     std::ostreambuf_iterator<CharT> oitr(os);
-    
+
     if(std::has_facet<custom_time_facet>(os.getloc())) {
       std::use_facet<custom_time_facet>(os.getloc()).put(oitr, 
                                                          os, 
@@ -60,7 +65,7 @@ namespace local_time {
   operator>>(std::basic_istream<CharT, Traits>& is, local_date_time& ldt)
   {
     boost::io::ios_flags_saver iflags(is);
-    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
+    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
     if (strm_sentry) {
       try {
         typedef typename local_date_time::utc_time_type utc_time_type;
@@ -69,7 +74,7 @@ namespace local_time {
         // intermediate objects
         std::basic_string<CharT> tz_str;
         utc_time_type pt(not_a_date_time); 
-        
+
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
         if(std::has_facet<time_input_facet>(is.getloc())) {
           std::use_facet<time_input_facet>(is.getloc()).get_local_time(sit, str_end, is, pt, tz_str);
@@ -92,27 +97,91 @@ namespace local_time {
           ldt = local_date_time(pt.date(), pt.time_of_day(), tz_ptr, local_date_time::EXCEPTION_ON_ERROR);
         }
       }
-      catch(...) { 
+      catch(...) {
         // mask tells us what exceptions are turned on
         std::ios_base::iostate exception_mask = is.exceptions();
         // if the user wants exceptions on failbit, we'll rethrow our 
         // date_time exception & set the failbit
         if(std::ios_base::failbit & exception_mask) {
-          try { is.setstate(std::ios_base::failbit); } 
+          try { is.setstate(std::ios_base::failbit); }
           catch(std::ios_base::failure&) {} // ignore this one
           throw; // rethrow original exception
         }
         else {
           // if the user want's to fail quietly, we simply set the failbit
-          is.setstate(std::ios_base::failbit); 
-        } 
-            
+          is.setstate(std::ios_base::failbit);
+        }
+
+      }
+    }
+    return is;
+  }
+
+  //! output operator for local_time_period
+  template <class CharT, class TraitsT>
+  inline
+  std::basic_ostream<CharT, TraitsT>&
+  operator<<(std::basic_ostream<CharT, TraitsT>& os,
+             const boost::local_time::local_time_period& p) {
+    boost::io::ios_flags_saver iflags(os);
+    typedef boost::date_time::time_facet<local_date_time, CharT> custom_facet;
+    std::ostreambuf_iterator<CharT> oitr(os);
+    if (std::has_facet<custom_facet>(os.getloc())) {
+      std::use_facet<custom_facet>(os.getloc()).put(oitr, os, os.fill(), p);
+    }
+    else {
+      //instantiate a custom facet for dealing with periods since the user
+      //has not put one in the stream so far.  This is for efficiency 
+      //since we would always need to reconstruct for every time period
+      //if the local did not already exist.  Of course this will be overridden
+      //if the user imbues as some later point.
+      custom_facet* f = new custom_facet();
+      std::locale l = std::locale(os.getloc(), f);
+      os.imbue(l);
+      f->put(oitr, os, os.fill(), p);
+    }
+    return os;
+  }
+
+  //! input operator for local_time_period
+  template <class CharT, class Traits>
+  inline
+  std::basic_istream<CharT, Traits>&
+  operator>>(std::basic_istream<CharT, Traits>& is, boost::local_time::local_time_period& tp)
+  {
+    boost::io::ios_flags_saver iflags(is);
+    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+    if (strm_sentry) {
+      try {
+        typedef typename date_time::time_input_facet<local_date_time, CharT> time_input_facet;
+
+        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+        if(std::has_facet<time_input_facet>(is.getloc())) {
+          std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, tp);
+        }
+        else {
+          time_input_facet* f = new time_input_facet();
+          std::locale l = std::locale(is.getloc(), f);
+          is.imbue(l);
+          f->get(sit, str_end, is, tp);
+        }
+      }
+      catch(...) {
+        std::ios_base::iostate exception_mask = is.exceptions();
+        if(std::ios_base::failbit & exception_mask) {
+          try { is.setstate(std::ios_base::failbit); }
+          catch(std::ios_base::failure&) {}
+          throw; // rethrow original exception
+        }
+        else {
+          is.setstate(std::ios_base::failbit);
+        }
+
       }
     }
     return is;
   }
 
-  
 } } // namespaces
 
 #endif // BOOST_DATE_TIME_LOCAL_TIME_IO_HPP__

include/boost/date_time/local_time/posix_time_zone.hpp

@@ -1,5 +1,5 @@
 #ifndef _DATE_TIME_POSIX_TIME_ZONE__
-#define _DATE_TIME_POSIX_TIME_ZONE__ 
+#define _DATE_TIME_POSIX_TIME_ZONE__
 
 /* Copyright (c) 2003-2005 CrystalClear Software, Inc.
  * Subject to the Boost Software License, Version 1.0. (See accompanying
@@ -10,36 +10,40 @@
 
 #include <string>
 #include <sstream>
-#include "boost/date_time/gregorian/gregorian.hpp"
-#include "boost/date_time/time_zone_names.hpp"
-#include "boost/date_time/time_zone_base.hpp"
-#include "boost/date_time/local_time/dst_transition_day_rules.hpp"
-#include "boost/date_time/posix_time/posix_time.hpp"
-#include "boost/date_time/string_convert.hpp"
-#include "boost/date_time/time_parsing.hpp"
-#include "boost/tokenizer.hpp"
 #include <stdexcept>
+#include <boost/tokenizer.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/gregorian/gregorian.hpp>
+#include <boost/date_time/time_zone_names.hpp>
+#include <boost/date_time/time_zone_base.hpp>
+#include <boost/date_time/local_time/dst_transition_day_rules.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/date_time/string_convert.hpp>
+#include <boost/date_time/time_parsing.hpp>
 
 namespace boost{
 namespace local_time{
 
   //! simple exception for UTC and Daylight savings start/end offsets
-  struct bad_offset : public std::out_of_range
+  struct BOOST_SYMBOL_VISIBLE bad_offset : public std::out_of_range
   {
-    bad_offset(std::string _msg="") : std::out_of_range(std::string("Offset out of range: " + _msg)) {}
+    bad_offset(std::string const& msg = std::string()) :
+      std::out_of_range(std::string("Offset out of range: " + msg)) {}
   };
   //! simple exception for UTC daylight savings adjustment
-  struct bad_adjustment : public std::out_of_range
+  struct BOOST_SYMBOL_VISIBLE bad_adjustment : public std::out_of_range
   {
-    bad_adjustment(std::string _msg="") : std::out_of_range(std::string("Adjustment out of range: " + _msg)) {}
+    bad_adjustment(std::string const& msg = std::string()) :
+      std::out_of_range(std::string("Adjustment out of range: " + msg)) {}
   };
-  
+
   typedef boost::date_time::dst_adjustment_offsets<boost::posix_time::time_duration> dst_adjustment_offsets;
 
   //! A time zone class constructed from a POSIX time zone string
   /*! A POSIX time zone string takes the form of:<br>
    * "std offset dst [offset],start[/time],end[/time]" (w/no spaces)
-   * 'std' specifies the abbrev of the time zone.<br> 
+   * 'std' specifies the abbrev of the time zone.<br>
    * 'offset' is the offset from UTC.<br>
    * 'dst' specifies the abbrev of the time zone during daylight savings time.<br>
    * The second offset is how many hours changed during DST. Default=1<br>
@@ -56,12 +60,15 @@ namespace local_time{
    * An invalid date spec (see date class)<br>
    * A boost::local_time::bad_offset exception will be thrown for:<br>
    * A DST start or end offset that is negative or more than 24 hours<br>
-   * A UTC zone that is greater than +12 or less than -12 hours<br>
+   * A UTC zone that is greater than +14 or less than -12 hours<br>
    * A boost::local_time::bad_adjustment exception will be thrown for:<br>
    * A DST adjustment that is 24 hours or more (positive or negative)<br>
+   *
+   * Note that UTC zone offsets can be greater than +12:
+   * http://www.worldtimezone.com/utc/utc+1200.html
    */
   template<class CharT>
-  class posix_time_zone_base : public date_time::time_zone_base<posix_time::ptime,CharT> {
+  class BOOST_SYMBOL_VISIBLE posix_time_zone_base : public date_time::time_zone_base<posix_time::ptime,CharT> {
   public:
     typedef boost::posix_time::time_duration time_duration_type;
     typedef date_time::time_zone_names_base<CharT> time_zone_names;
@@ -73,30 +80,43 @@ namespace local_time{
     typedef boost::tokenizer<char_separator_type,
                              typename string_type::const_iterator,
                              string_type> tokenizer_type;
-    typedef typename boost::tokenizer<char_separator_type,
-                             typename string_type::const_iterator,
-                             string_type>::iterator tokenizer_iterator_type;
+    typedef typename tokenizer_type::iterator tokenizer_iterator_type;
 
     //! Construct from a POSIX time zone string
-    posix_time_zone_base(const string_type& s) : 
+    posix_time_zone_base(const string_type& s) :
       //zone_names_("std_name","std_abbrev","no-dst","no-dst"),
       zone_names_(),
-      has_dst_(false), 
+      has_dst_(false),
       base_utc_offset_(posix_time::hours(0)),
       dst_offsets_(posix_time::hours(0),posix_time::hours(0),posix_time::hours(0)),
       dst_calc_rules_()
     {
+#ifdef __HP_aCC
+      // Work around bug in aC++ compiler: see QXCR1000880488 in the
+      // HP bug tracking system
+      const char_type sep_chars[2] = {',',0};
+#else
       const char_type sep_chars[2] = {','};
+#endif
       char_separator_type sep(sep_chars);
       tokenizer_type tokens(s, sep);
-      tokenizer_iterator_type it = tokens.begin();
+      tokenizer_iterator_type it = tokens.begin(), end = tokens.end();
+      if (it == end)
+        BOOST_THROW_EXCEPTION(std::invalid_argument("Could not parse time zone name"));
       calc_zone(*it++);
-      if(has_dst_){
-        string_type tmp_str = *it++;
-        calc_rules(tmp_str, *it);
+      if(has_dst_)
+      {
+        if (it == end)
+          BOOST_THROW_EXCEPTION(std::invalid_argument("Could not parse DST begin time"));
+        string_type dst_begin = *it++;
+
+        if (it == end)
+          BOOST_THROW_EXCEPTION(std::invalid_argument("Could not parse DST end time"));
+        string_type dst_end = *it;
+        calc_rules(dst_begin, dst_end);
       }
-    } 
-    virtual ~posix_time_zone_base() {};
+    }
+    virtual ~posix_time_zone_base() {}
     //!String for the zone when not in daylight savings (eg: EST)
     virtual string_type std_zone_abbrev()const
     {
@@ -109,15 +129,15 @@ namespace local_time{
       return zone_names_.dst_zone_abbrev();
     }
     //!String for the zone when not in daylight savings (eg: Eastern Standard Time)
-    /*! The full STD name is not extracted from the posix time zone string. 
+    /*! The full STD name is not extracted from the posix time zone string.
      * Therefore, the STD abbreviation is used in it's place */
     virtual string_type std_zone_name()const
     {
       return zone_names_.std_zone_name();
     }
     //!String for the timezone when in daylight savings (eg: Eastern Daylight Time)
-    /*! The full DST name is not extracted from the posix time zone string. 
-     * Therefore, the STD abbreviation is used in it's place. For time zones 
+    /*! The full DST name is not extracted from the posix time zone string.
+     * Therefore, the STD abbreviation is used in it's place. For time zones
      * that have no DST, an empty string is used */
     virtual string_type dst_zone_name()const
     {
@@ -231,51 +251,51 @@ namespace local_time{
     void calc_zone(const string_type& obj){
       const char_type empty_string[2] = {'\0'};
       stringstream_type ss(empty_string);
-      typename string_type::const_iterator sit = obj.begin();
+      typename string_type::const_pointer sit = obj.c_str(), obj_end = sit + obj.size();
       string_type l_std_zone_abbrev, l_dst_zone_abbrev;
 
       // get 'std' name/abbrev
       while(std::isalpha(*sit)){
         ss << *sit++;
       }
-      l_std_zone_abbrev = ss.str(); 
+      l_std_zone_abbrev = ss.str();
       ss.str(empty_string);
 
       // get UTC offset
-      if(sit != obj.end()){
+      if(sit != obj_end){
         // get duration
-        while(sit != obj.end() && !std::isalpha(*sit)){
-        ss << *sit++;
+        while(sit != obj_end && !std::isalpha(*sit)){
+          ss << *sit++;
         }
-        base_utc_offset_ = date_time::str_from_delimited_time_duration<time_duration_type,char_type>(ss.str()); 
+        base_utc_offset_ = date_time::str_from_delimited_time_duration<time_duration_type,char_type>(ss.str());
         ss.str(empty_string);
 
-        // base offset must be within range of -12 hours to +12 hours
+        // base offset must be within range of -12 hours to +14 hours
         if(base_utc_offset_ < time_duration_type(-12,0,0) ||
-            base_utc_offset_ > time_duration_type(12,0,0))
+          base_utc_offset_ > time_duration_type(14,0,0))
         {
-            throw bad_offset(posix_time::to_simple_string(base_utc_offset_));
+          boost::throw_exception(bad_offset(posix_time::to_simple_string(base_utc_offset_)));
         }
       }
 
       // get DST data if given
-      if(sit != obj.end()){
+      if(sit != obj_end){
         has_dst_ = true;
-    
+
         // get 'dst' name/abbrev
-        while(sit != obj.end() && std::isalpha(*sit)){
+        while(sit != obj_end && std::isalpha(*sit)){
           ss << *sit++;
         }
-        l_dst_zone_abbrev = ss.str(); 
+        l_dst_zone_abbrev = ss.str();
         ss.str(empty_string);
 
         // get DST offset if given
-        if(sit != obj.end()){
+        if(sit != obj_end){
           // get duration
-          while(sit != obj.end() && !std::isalpha(*sit)){
+          while(sit != obj_end && !std::isalpha(*sit)){
             ss << *sit++;
           }
-          dst_offsets_.dst_adjust_ = date_time::str_from_delimited_time_duration<time_duration_type,char_type>(ss.str());  
+          dst_offsets_.dst_adjust_ = date_time::str_from_delimited_time_duration<time_duration_type,char_type>(ss.str());
           ss.str(empty_string);
         }
         else{ // default DST offset
@@ -286,7 +306,7 @@ namespace local_time{
         if(dst_offsets_.dst_adjust_ <= time_duration_type(-24,0,0) ||
             dst_offsets_.dst_adjust_ >= time_duration_type(24,0,0))
         {
-          throw bad_adjustment(posix_time::to_simple_string(dst_offsets_.dst_adjust_));
+          boost::throw_exception(bad_adjustment(posix_time::to_simple_string(dst_offsets_.dst_adjust_)));
         }
       }
       // full names not extracted so abbrevs used in their place
@@ -294,7 +314,13 @@ namespace local_time{
     }
 
     void calc_rules(const string_type& start, const string_type& end){
+#ifdef __HP_aCC
+      // Work around bug in aC++ compiler: see QXCR1000880488 in the
+      // HP bug tracking system
+      const char_type sep_chars[2] = {'/',0};
+#else
       const char_type sep_chars[2] = {'/'};
+#endif
       char_separator_type sep(sep_chars);
       tokenizer_type st_tok(start, sep);
       tokenizer_type et_tok(end, sep);
@@ -328,7 +354,7 @@ namespace local_time{
       if(dst_offsets_.dst_start_offset_ < time_duration_type(0,0,0) ||
           dst_offsets_.dst_start_offset_ >= time_duration_type(24,0,0))
       {
-        throw bad_offset(posix_time::to_simple_string(dst_offsets_.dst_start_offset_));
+        boost::throw_exception(bad_offset(posix_time::to_simple_string(dst_offsets_.dst_start_offset_)));
       }
 
       // ending offset
@@ -343,7 +369,7 @@ namespace local_time{
       if(dst_offsets_.dst_end_offset_ < time_duration_type(0,0,0) ||
         dst_offsets_.dst_end_offset_ >= time_duration_type(24,0,0))
       {
-        throw bad_offset(posix_time::to_simple_string(dst_offsets_.dst_end_offset_));
+        boost::throw_exception(bad_offset(posix_time::to_simple_string(dst_offsets_.dst_end_offset_)));
       }
     }
 
@@ -354,15 +380,21 @@ namespace local_time{
     void M_func(const string_type& s, const string_type& e){
       typedef gregorian::nth_kday_of_month nkday;
       unsigned short sm=0,sw=0,sd=0,em=0,ew=0,ed=0; // start/end month,week,day
+#ifdef __HP_aCC
+      // Work around bug in aC++ compiler: see QXCR1000880488 in the
+      // HP bug tracking system
+      const char_type sep_chars[3] = {'M','.',0};
+#else
       const char_type sep_chars[3] = {'M','.'};
+#endif
       char_separator_type sep(sep_chars);
       tokenizer_type stok(s, sep), etok(e, sep);
-      
+
       tokenizer_iterator_type it = stok.begin();
       sm = lexical_cast<unsigned short>(*it++);
       sw = lexical_cast<unsigned short>(*it++);
       sd = lexical_cast<unsigned short>(*it);
-     
+
       it = etok.begin();
       em = lexical_cast<unsigned short>(*it++);
       ew = lexical_cast<unsigned short>(*it++);
@@ -371,13 +403,13 @@ namespace local_time{
       dst_calc_rules_ = shared_ptr<dst_calc_rule>(
         new nth_kday_dst_rule(
           nth_last_dst_rule::start_rule(
-            static_cast<nkday::week_num>(sw),sd,sm), 
+            static_cast<nkday::week_num>(sw),sd,sm),
           nth_last_dst_rule::start_rule(
-            static_cast<nkday::week_num>(ew),ed,em) 
+            static_cast<nkday::week_num>(ew),ed,em)
           )
       );
     }
-    
+
     //! Julian day. Feb29 is never counted, even in leap years
     // expects range of 1-365
     void julian_no_leap(const string_type& s, const string_type& e){
@@ -399,9 +431,9 @@ namespace local_time{
       dst_calc_rules_ = shared_ptr<dst_calc_rule>(
         new partial_date_dst_rule(
           partial_date_dst_rule::start_rule(
-            sd, static_cast<date_time::months_of_year>(sm)), 
+            static_cast<unsigned short>(sd), static_cast<date_time::months_of_year>(sm)),
           partial_date_dst_rule::end_rule(
-            ed, static_cast<date_time::months_of_year>(em)) 
+            static_cast<unsigned short>(ed), static_cast<date_time::months_of_year>(em))
           )
       );
     }
@@ -436,8 +468,8 @@ namespace local_time{
   };
 
   typedef posix_time_zone_base<char> posix_time_zone;
-  
+
 } } // namespace boost::local_time
 
 
-#endif // _DATE_TIME_POSIX_TIME_ZONE__ 
+#endif // _DATE_TIME_POSIX_TIME_ZONE__

include/boost/date_time/local_time_adjustor.hpp

@@ -13,9 +13,13 @@
   Time adjustment calculations for local times
 */
 
-#include "boost/date_time/date_generators.hpp"
-#include "boost/date_time/dst_rules.hpp"
 #include <stdexcept>
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/date_generators.hpp>
+#include <boost/date_time/dst_rules.hpp>
+#include <boost/date_time/time_defs.hpp> // boost::date_time::dst_flags
+#include <boost/date_time/special_defs.hpp> // not_a_date_time
 
 namespace boost {
   namespace date_time {
@@ -109,7 +113,7 @@ namespace boost {
         time_is_dst_result dst_flag = 
           dst_rules::local_is_dst(initial.date(), initial.time_of_day());
         switch(dst_flag) {
-    case is_in_dst:        return utc_offset_rules::utc_to_local_base_offset() + dst_rules::dst_offset();
+        case is_in_dst:        return utc_offset_rules::utc_to_local_base_offset() + dst_rules::dst_offset();
         case is_not_in_dst:    return utc_offset_rules::utc_to_local_base_offset();
         case invalid_time_label:return utc_offset_rules::utc_to_local_base_offset() + dst_rules::dst_offset();
         case ambiguous: {
@@ -125,15 +129,15 @@ namespace boost {
           }
         }
         }//case
-        //TODO  better excpetion type
-        throw std::out_of_range("Unreachable case");
-
+        //TODO  better exception type
+        boost::throw_exception(std::out_of_range("Unreachable case"));
+        BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(return time_duration_type(not_a_date_time)); // should never reach
       }
 
       //! Get the offset to UTC given a local time
       static time_duration_type local_to_utc_offset(const time_type& t, 
                                                     date_time::dst_flags dst=date_time::calculate) 
-      { 
+      {
         switch (dst) {
         case is_dst:
           return utc_offset_rules::local_to_utc_base_offset() - dst_rules::dst_offset();
@@ -146,13 +150,14 @@ namespace boost {
           case is_in_dst:      return utc_offset_rules::local_to_utc_base_offset() - dst_rules::dst_offset();
           case is_not_in_dst:      return utc_offset_rules::local_to_utc_base_offset();
           case ambiguous:          return utc_offset_rules::local_to_utc_base_offset();
-          case invalid_time_label: throw std::out_of_range("Time label invalid");
+          case invalid_time_label: break;
           }
-        }  
-        throw std::out_of_range("Time label invalid");
+        }
+        boost::throw_exception(std::out_of_range("Time label invalid"));
+        BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(return time_duration_type(not_a_date_time)); // should never reach
       }
 
-    
+
     private:
 
     };

include/boost/date_time/local_timezone_defs.hpp

@@ -66,7 +66,7 @@ namespace boost {
          if (y < 2007) return Apr;
          return Mar;
        }
-       static day_of_week_type end_day(year_type y) {return Sunday;}
+       static day_of_week_type end_day(year_type) {return Sunday;}
        static month_type end_month(year_type y) 
        {
          if (y < 2007) return Oct;

include/boost/date_time/locale_config.hpp

@@ -1,7 +1,7 @@
 #ifndef DATE_TIME_LOCALE_CONFIG_HPP___
 #define DATE_TIME_LOCALE_CONFIG_HPP___
 
-/* Copyright (c) 2002-2006 CrystalClear Software, Inc.
+/* Copyright (c) 2002-2020 CrystalClear Software, Inc.
  * 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)
@@ -17,12 +17,14 @@
 // defines BOOST_NO_STD_LOCALE (gcc 2.95.x)
 
 #include "boost/config.hpp" //sets BOOST_NO_STD_LOCALE
-#include "boost/detail/workaround.hpp"
+#include "boost/config/workaround.hpp"
 
 //This file basically becomes a noop if locales are not properly supported
 #if (defined(BOOST_NO_STD_LOCALE)  \
  || (BOOST_WORKAROUND( BOOST_MSVC, < 1300)) \
- || (BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x581 )) ) )
+ || (BOOST_WORKAROUND( BOOST_BORLANDC, BOOST_TESTED_AT( 0x581 )) ) \
+ || (BOOST_WORKAROUND( BOOST_XLCPP_ZOS, BOOST_TESTED_AT( 0x42010000 )) ) /* <cctype> "shadows" the locale enabled overloads from <locale> */ \
+ )
 #define BOOST_DATE_TIME_NO_LOCALE
 #endif
 

include/boost/date_time/microsec_time_clock.hpp

@@ -14,14 +14,14 @@
   This file contains a high resolution time clock implementation.
 */
 
+#include <boost/cstdint.hpp>
+#include <boost/shared_ptr.hpp>
 #include <boost/detail/workaround.hpp>
-#include "boost/date_time/c_time.hpp"
-#include "boost/date_time/time_clock.hpp"
-#include "boost/cstdint.hpp"
-#include "boost/shared_ptr.hpp"
-
-#ifdef BOOST_HAS_FTIME
-#include <windows.h>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/c_time.hpp>
+#include <boost/date_time/time_clock.hpp>
+#if defined(BOOST_HAS_FTIME)
+#include <boost/winapi/time.hpp>
 #endif
 
 #ifdef BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK
@@ -29,7 +29,6 @@
 namespace boost {
 namespace date_time {
 
-
   //! A clock providing microsecond level resolution
   /*! A high precision clock that measures the local time
    *  at a resolution up to microseconds and adjusts to the
@@ -41,6 +40,10 @@ namespace date_time {
   template<class time_type>
   class microsec_clock
   {
+  private:
+    //! Type for the function used to convert time_t to tm
+    typedef std::tm* (*time_converter)(const std::time_t*, std::tm*);
+
   public:
     typedef typename time_type::date_type date_type;
     typedef typename time_type::time_duration_type time_duration_type;
@@ -49,7 +52,8 @@ namespace date_time {
     //! return a local time object for the given zone, based on computer clock
     //JKG -- looks like we could rewrite this against universal_time
     template<class time_zone_type>
-    static time_type local_time(shared_ptr<time_zone_type> tz_ptr) {
+    static time_type local_time(shared_ptr<time_zone_type> tz_ptr)
+    {
       typedef typename time_type::utc_time_type utc_time_type;
       typedef second_clock<utc_time_type> second_clock;
       // we'll need to know the utc_offset this machine has
@@ -62,137 +66,86 @@ namespace date_time {
       return time_type(utc_time, tz_ptr);
     }
 
-
-  private:
-    // we want this enum available for both platforms yet still private
-    enum TZ_FOR_CREATE { LOCAL, GMT };
-    
-  public:
-
-#ifdef BOOST_HAS_GETTIMEOFDAY
-    //! Return the local time based on computer clock settings
-    static time_type local_time() {
-      return create_time(LOCAL);
+    //! Returns the local time based on computer clock settings
+    static time_type local_time()
+    {
+      return create_time(&c_time::localtime);
     }
 
-    //! Get the current day in universal date as a ymd_type
+    //! Returns the UTC time based on computer settings
     static time_type universal_time()
     {
-      return create_time(GMT);
+      return create_time(&c_time::gmtime);
     }
 
   private:
-    static time_type create_time(TZ_FOR_CREATE tz) {
+    static time_type create_time(time_converter converter)
+    {
+#ifdef BOOST_HAS_GETTIMEOFDAY
       timeval tv;
       gettimeofday(&tv, 0); //gettimeofday does not support TZ adjust on Linux.
       std::time_t t = tv.tv_sec;
-      boost::uint32_t fs = tv.tv_usec;
-      std::tm curr, *curr_ptr = 0;
-      if (tz == LOCAL) {
-        curr_ptr = c_time::localtime(&t, &curr);
-      } else {
-        curr_ptr = c_time::gmtime(&t, &curr);
+      boost::uint32_t sub_sec = tv.tv_usec;
+#elif defined(BOOST_HAS_FTIME)
+      boost::winapi::FILETIME_ ft;
+      boost::winapi::GetSystemTimeAsFileTime(&ft);
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+      // Some runtime library implementations expect local times as the norm for ctime functions.
+      {
+        boost::winapi::FILETIME_ local_ft;
+        boost::winapi::FileTimeToLocalFileTime(&ft, &local_ft);
+        ft = local_ft;
       }
-      date_type d(curr_ptr->tm_year + 1900,
-                  curr_ptr->tm_mon + 1,
-                  curr_ptr->tm_mday);
-      //The following line will adjusts the fractional second tick in terms
+#endif
+
+      boost::uint64_t micros = file_time_to_microseconds(ft); // it will not wrap, since ft is the current time
+                                                              // and cannot be before 1970-Jan-01
+      std::time_t t = static_cast<std::time_t>(micros / 1000000UL); // seconds since epoch
+      // microseconds -- static casts suppress warnings
+      boost::uint32_t sub_sec = static_cast<boost::uint32_t>(micros % 1000000UL);
+#else
+#error Internal Boost.DateTime error: BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK is defined, however neither gettimeofday nor FILETIME support is detected.
+#endif
+
+      std::tm curr;
+      std::tm* curr_ptr = converter(&t, &curr);
+      date_type d(static_cast< typename date_type::year_type::value_type >(curr_ptr->tm_year + 1900),
+                  static_cast< typename date_type::month_type::value_type >(curr_ptr->tm_mon + 1),
+                  static_cast< typename date_type::day_type::value_type >(curr_ptr->tm_mday));
+
+      //The following line will adjust the fractional second tick in terms
       //of the current time system.  For example, if the time system
       //doesn't support fractional seconds then res_adjust returns 0
       //and all the fractional seconds return 0.
-      int adjust = resolution_traits_type::res_adjust()/1000000;
+      int adjust = static_cast< int >(resolution_traits_type::res_adjust() / 1000000);
 
-      time_duration_type td(curr_ptr->tm_hour,
-                            curr_ptr->tm_min,
-                            curr_ptr->tm_sec,
-                            fs*adjust);
-      return time_type(d,td);
-
-    }
-#endif // BOOST_HAS_GETTIMEOFDAY
-
-#ifdef BOOST_HAS_FTIME
-    //! Return the local time based on computer clock settings
-    static time_type local_time() {
-      FILETIME ft;
-      #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-      // Some runtime library implementations expect local times as the norm for ctime.
-      FILETIME ft_utc;
-      GetSystemTimeAsFileTime(&ft_utc);
-      FileTimeToLocalFileTime(&ft_utc,&ft);
-      #elif defined(BOOST_NO_GETSYSTEMTIMEASFILETIME)
-      SYSTEMTIME st;
-      GetSystemTime( &st );
-      SystemTimeToFileTime( &st, &ft );
-      #else
-      GetSystemTimeAsFileTime(&ft);
-      #endif
-      return create_time(ft, LOCAL);
-    }
-    
-    //! Return the UTC time based on computer settings
-    static time_type universal_time() {
-      FILETIME ft;
-      #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-      // Some runtime library implementations expect local times as the norm for ctime.
-      FILETIME ft_utc;
-      GetSystemTimeAsFileTime(&ft_utc);
-      FileTimeToLocalFileTime(&ft_utc,&ft);
-      #elif defined(BOOST_NO_GETSYSTEMTIMEASFILETIME)
-      SYSTEMTIME st;
-      GetSystemTime( &st );
-      SystemTimeToFileTime( &st, &ft );
-      #else
-      GetSystemTimeAsFileTime(&ft);
-      #endif
-      return create_time(ft, GMT);
-    }
-
-  private:
-    static time_type create_time(FILETIME& ft, TZ_FOR_CREATE tz) {
-      // offset is difference (in 100-nanoseconds) from
-      // 1970-Jan-01 to 1601-Jan-01
-      boost::uint64_t c1 = 27111902;
-      boost::uint64_t c2 = 3577643008UL; // 'UL' removes compiler warnings
-      const boost::uint64_t OFFSET = (c1 << 32) + c2;
-
-      boost::uint64_t filetime = ft.dwHighDateTime;
-      filetime = filetime << 32;
-      filetime += ft.dwLowDateTime;
-      filetime -= OFFSET;
-      // filetime now holds 100-nanoseconds since 1970-Jan-01
-
-      // microseconds -- static casts supress warnings
-      boost::uint32_t sub_sec = static_cast<boost::uint32_t>((filetime % 10000000) / 10);
-
-      std::time_t t = static_cast<time_t>(filetime / 10000000); // seconds since epoch
-      
-      std::tm curr, *curr_ptr = 0;
-      if (tz == LOCAL) {
-        curr_ptr = c_time::localtime(&t, &curr);
-      }
-      else {
-        curr_ptr = c_time::gmtime(&t, &curr);
-      }
-      date_type d(curr_ptr->tm_year + 1900,
-                  curr_ptr->tm_mon + 1,
-                  curr_ptr->tm_mday);
-
-      //The following line will adjusts the fractional second tick in terms
-      //of the current time system.  For example, if the time system
-      //doesn't support fractional seconds then res_adjust returns 0
-      //and all the fractional seconds return 0.
-      int adjust = static_cast<int>(resolution_traits_type::res_adjust()/1000000);
-
-      time_duration_type td(curr_ptr->tm_hour,
-                            curr_ptr->tm_min,
-                            curr_ptr->tm_sec,
+      time_duration_type td(static_cast< typename time_duration_type::hour_type >(curr_ptr->tm_hour),
+                            static_cast< typename time_duration_type::min_type >(curr_ptr->tm_min),
+                            static_cast< typename time_duration_type::sec_type >(curr_ptr->tm_sec),
                             sub_sec * adjust);
-                            //st.wMilliseconds * adjust);
-      return time_type(d,td);
 
+      return time_type(d,td);
     }
-#endif // BOOST_HAS_FTIME
+
+#if defined(BOOST_HAS_FTIME)
+    /*!
+     * 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.
+     */
+    static boost::uint64_t file_time_to_microseconds(boost::winapi::FILETIME_ const& ft)
+    {
+      // shift is difference between 1970-Jan-01 & 1601-Jan-01
+      // in 100-nanosecond units
+      const boost::uint64_t shift = 116444736000000000ULL; // (27111902 << 32) + 3577643008
+
+      // 100-nanos since 1601-Jan-01
+      boost::uint64_t ft_as_integer = (static_cast< boost::uint64_t >(ft.dwHighDateTime) << 32) | static_cast< boost::uint64_t >(ft.dwLowDateTime);
+
+      ft_as_integer -= shift; // filetime is now 100-nanos since 1970-Jan-01
+      return (ft_as_integer / 10U); // truncate to microseconds
+    }
+#endif
   };
 
 

include/boost/date_time/period.hpp

@@ -17,7 +17,8 @@
 
 */
 
-#include "boost/operators.hpp"
+#include <boost/operators.hpp>
+#include <boost/date_time/compiler_config.hpp>
 
 
 namespace boost {
@@ -48,7 +49,7 @@ namespace date_time {
 
    */
   template<class point_rep, class duration_rep>
-  class period : private
+  class BOOST_SYMBOL_VISIBLE period : private
       boost::less_than_comparable<period<point_rep, duration_rep> 
     , boost::equality_comparable< period<point_rep, duration_rep> 
     > >
@@ -57,26 +58,26 @@ namespace date_time {
     typedef point_rep point_type;
     typedef duration_rep duration_type;
 
-    period(point_rep first_point, point_rep end_point);
-    period(point_rep first_point, duration_rep len);
-    point_rep begin() const;
-    point_rep end() const;
-    point_rep last() const;
-    duration_rep length() const;
-    bool is_null() const;
-    bool operator==(const period& rhs) const;
-    bool operator<(const period& rhs) const;
-    void shift(const duration_rep& d);
-    void expand(const duration_rep& d);
-    bool contains(const point_rep& point) const;
-    bool contains(const period& other) const;
-    bool intersects(const period& other) const;
-    bool is_adjacent(const period& other) const;
-    bool is_before(const point_rep& point) const;
-    bool is_after(const point_rep& point) const;
-    period intersection(const period& other) const;
-    period merge(const period& other) const;
-    period span(const period& other) const;
+    BOOST_CXX14_CONSTEXPR period(point_rep first_point, point_rep end_point);
+    BOOST_CXX14_CONSTEXPR period(point_rep first_point, duration_rep len);
+    BOOST_CXX14_CONSTEXPR point_rep begin() const;
+    BOOST_CXX14_CONSTEXPR point_rep end() const;
+    BOOST_CXX14_CONSTEXPR point_rep last() const;
+    BOOST_CXX14_CONSTEXPR duration_rep length() const;
+    BOOST_CXX14_CONSTEXPR bool is_null() const;
+    BOOST_CXX14_CONSTEXPR bool operator==(const period& rhs) const;
+    BOOST_CXX14_CONSTEXPR bool operator<(const period& rhs) const;
+    BOOST_CXX14_CONSTEXPR void shift(const duration_rep& d);
+    BOOST_CXX14_CONSTEXPR void expand(const duration_rep& d);
+    BOOST_CXX14_CONSTEXPR bool contains(const point_rep& point) const;
+    BOOST_CXX14_CONSTEXPR bool contains(const period& other) const;
+    BOOST_CXX14_CONSTEXPR bool intersects(const period& other) const;
+    BOOST_CXX14_CONSTEXPR bool is_adjacent(const period& other) const;
+    BOOST_CXX14_CONSTEXPR bool is_before(const point_rep& point) const;
+    BOOST_CXX14_CONSTEXPR bool is_after(const point_rep& point) const;
+    BOOST_CXX14_CONSTEXPR period intersection(const period& other) const;
+    BOOST_CXX14_CONSTEXPR period merge(const period& other) const;
+    BOOST_CXX14_CONSTEXPR period span(const period& other) const;
   private:
     point_rep begin_;
     point_rep last_;
@@ -86,7 +87,7 @@ namespace date_time {
   /*! If end <= begin then the period will be invalid
    */
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   period<point_rep,duration_rep>::period(point_rep first_point, 
                                          point_rep end_point) : 
     begin_(first_point), 
@@ -97,7 +98,7 @@ namespace date_time {
   /*! If len is <= 0 then the period will be invalid
    */
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   period<point_rep,duration_rep>::period(point_rep first_point, duration_rep len) :
     begin_(first_point), 
     last_(first_point + len-duration_rep::unit())
@@ -106,7 +107,7 @@ namespace date_time {
 
   //! Return the first element in the period
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   point_rep period<point_rep,duration_rep>::begin() const 
   {
     return begin_;
@@ -114,7 +115,7 @@ namespace date_time {
 
   //! Return one past the last element 
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   point_rep period<point_rep,duration_rep>::end() const 
   {
     return last_ + duration_rep::unit();
@@ -122,7 +123,7 @@ namespace date_time {
 
   //! Return the last item in the period
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   point_rep period<point_rep,duration_rep>::last() const 
   {
     return last_;
@@ -130,7 +131,7 @@ namespace date_time {
 
   //! True if period is ill formed (length is zero or less)
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   bool period<point_rep,duration_rep>::is_null() const 
   {
     return end() <= begin_;
@@ -138,7 +139,7 @@ namespace date_time {
 
   //! Return the length of the period
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   duration_rep period<point_rep,duration_rep>::length() const
   {
     if(last_ < begin_){ // invalid period
@@ -151,7 +152,7 @@ namespace date_time {
 
   //! Equality operator
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   bool period<point_rep,duration_rep>::operator==(const period& rhs) const 
   {
     return  ((begin_ == rhs.begin_) && 
@@ -160,7 +161,7 @@ namespace date_time {
 
   //! Strict as defined by rhs.last <= lhs.last
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   bool period<point_rep,duration_rep>::operator<(const period& rhs) const 
   {
     return (last_ < rhs.begin_);
@@ -169,7 +170,7 @@ namespace date_time {
 
   //! Shift the start and end by the specified amount
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   void period<point_rep,duration_rep>::shift(const duration_rep& d)
   {
     begin_ = begin_ + d;
@@ -196,7 +197,7 @@ namespace date_time {
    *@endcode
    */
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   void period<point_rep,duration_rep>::expand(const duration_rep& d)
   {
     begin_ = begin_ - d;
@@ -205,7 +206,7 @@ namespace date_time {
 
   //! True if the point is inside the period, zero length periods contain no points
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   bool period<point_rep,duration_rep>::contains(const point_rep& point) const 
   {
     return ((point >= begin_) &&
@@ -215,7 +216,7 @@ namespace date_time {
 
   //! True if this period fully contains (or equals) the other period
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   bool period<point_rep,duration_rep>::contains(const period<point_rep,duration_rep>& other) const
   {
     return ((begin_ <= other.begin_) && (last_ >= other.last_));
@@ -232,9 +233,8 @@ namespace date_time {
    *@endcode
    */
   template<class point_rep, class duration_rep>
-  inline
-  bool 
-  period<point_rep,duration_rep>::is_adjacent(const period<point_rep,duration_rep>& other) const 
+  inline BOOST_CXX14_CONSTEXPR
+  bool period<point_rep,duration_rep>::is_adjacent(const period<point_rep,duration_rep>& other) const
   {
     return (other.begin() == end() ||
             begin_ == other.end());
@@ -251,9 +251,8 @@ namespace date_time {
    *@endcode
    */
   template<class point_rep, class duration_rep>
-  inline
-  bool 
-  period<point_rep,duration_rep>::is_after(const point_rep& t) const 
+  inline BOOST_CXX14_CONSTEXPR
+  bool period<point_rep,duration_rep>::is_after(const point_rep& t) const
   { 
     if (is_null()) 
     {
@@ -273,9 +272,8 @@ namespace date_time {
    *@endcode
    */
   template<class point_rep, class duration_rep>
-  inline
-  bool 
-  period<point_rep,duration_rep>::is_before(const point_rep& t) const 
+  inline BOOST_CXX14_CONSTEXPR
+  bool period<point_rep,duration_rep>::is_before(const point_rep& t) const
   { 
     if (is_null()) 
     {
@@ -298,17 +296,15 @@ namespace date_time {
    *@endcode
    */
   template<class point_rep, class duration_rep>
-  inline
-  bool period<point_rep,duration_rep>::intersects(const period<point_rep,duration_rep>& other) const 
+  inline BOOST_CXX14_CONSTEXPR
+  bool period<point_rep,duration_rep>::intersects(const period<point_rep,duration_rep>& other) const
   { 
-    return ( contains(other.begin_) ||
-             other.contains(begin_) ||
-             ((other.begin_ < begin_) && (other.last_ >= begin_)));
+    return !is_null() && !other.is_null() && (begin_ < other.end()) && (other.begin_ < end());
   }
 
   //! Returns the period of intersection or invalid range no intersection
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   period<point_rep,duration_rep>
   period<point_rep,duration_rep>::intersection(const period<point_rep,duration_rep>& other) const 
   {
@@ -333,7 +329,7 @@ namespace date_time {
   /*! 
    */
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   period<point_rep,duration_rep>
   period<point_rep,duration_rep>::merge(const period<point_rep,duration_rep>& other) const 
   {
@@ -360,7 +356,7 @@ namespace date_time {
    *@endcode
    */
   template<class point_rep, class duration_rep>
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   period<point_rep,duration_rep>
   period<point_rep,duration_rep>::span(const period<point_rep,duration_rep>& other) const 
   {

include/boost/date_time/period_formatter.hpp

@@ -3,14 +3,17 @@
 #define DATETIME_PERIOD_FORMATTER_HPP___
 
 /* Copyright (c) 2002-2004 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$
  */
 
-
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <iterator>
 
 namespace boost { namespace date_time {
 
@@ -19,14 +22,14 @@ namespace boost { namespace date_time {
   /*! Provides settings for the following:
    *   - period_separator -- default '/'
    *   - period_open_start_delimeter -- default '['
-   *   - period_open_range_end_delimeter -- default ')' 
-   *   - period_closed_range_end_delimeter -- default ']' 
+   *   - period_open_range_end_delimeter -- default ')'
+   *   - period_closed_range_end_delimeter -- default ']'
    *   - display_as_open_range, display_as_closed_range -- default closed_range
    *
    *  Thus the default formatting for a period is as follows:
    *@code
    *  [period.start()/period.last()]
-   *@endcode 
+   *@endcode
    *  So for a typical date_period this would be
    *@code
    *  [2004-Jan-04/2004-Feb-01]
@@ -34,13 +37,13 @@ namespace boost { namespace date_time {
    * where the date formatting is controlled by the date facet
    */
   template <class CharT, class OutItrT = std::ostreambuf_iterator<CharT, std::char_traits<CharT> > >
-  class period_formatter { 
+  class period_formatter {
   public:
     typedef std::basic_string<CharT> string_type;
     typedef CharT                    char_type;
     typedef typename std::basic_string<char_type>::const_iterator const_itr_type;
     typedef std::vector<std::basic_string<CharT> > collection_type;
-    
+
     static const char_type default_period_separator[2];
     static const char_type default_period_start_delimeter[2];
     static const char_type default_period_open_range_end_delimeter[2];
@@ -49,8 +52,8 @@ namespace boost { namespace date_time {
     enum range_display_options { AS_OPEN_RANGE, AS_CLOSED_RANGE };
 
     //! Constructor that sets up period formatter options -- default should suffice most cases.
-    period_formatter(range_display_options range_option_in = AS_CLOSED_RANGE, 
-                     const char_type* const period_separator = default_period_separator, 
+    period_formatter(range_display_options range_option_in = AS_CLOSED_RANGE,
+                     const char_type* const period_separator = default_period_separator,
                      const char_type* const period_start_delimeter = default_period_start_delimeter,
                      const char_type* const period_open_range_end_delimeter = default_period_open_range_end_delimeter,
                      const char_type* const period_closed_range_end_delimeter = default_period_closed_range_end_delimeter) :
@@ -62,7 +65,7 @@ namespace boost { namespace date_time {
     {}
 
     //! Puts the characters between period elements into stream -- default is /
-    OutItrT put_period_separator(OutItrT& oitr) const 
+    OutItrT put_period_separator(OutItrT& oitr) const
     {
       const_itr_type ci = m_period_separator.begin();
       while (ci != m_period_separator.end()) {
@@ -73,7 +76,7 @@ namespace boost { namespace date_time {
     }
 
     //! Puts the period start characters into stream -- default is [
-    OutItrT put_period_start_delimeter(OutItrT& oitr) const 
+    OutItrT put_period_start_delimeter(OutItrT& oitr) const
     {
       const_itr_type ci = m_period_start_delimeter.begin();
       while (ci != m_period_start_delimeter.end()) {
@@ -84,9 +87,9 @@ namespace boost { namespace date_time {
     }
 
     //! Puts the period end characters into stream as controled by open/closed range setting.
-    OutItrT put_period_end_delimeter(OutItrT& oitr) const 
+    OutItrT put_period_end_delimeter(OutItrT& oitr) const
     {
-      
+
       const_itr_type ci, end;
       if (m_range_option == AS_OPEN_RANGE) {
         ci = m_open_range_end_delimeter.begin();
@@ -102,40 +105,41 @@ namespace boost { namespace date_time {
       }
       return oitr;
     }
-   
+
     range_display_options range_option() const
     {
       return m_range_option;
     }
 
     //! Reset the range_option control
-    void 
+    void
     range_option(range_display_options option) const
     {
       m_range_option = option;
     }
+
+    //! Change the delimiter strings
     void delimiter_strings(const string_type& separator,
                            const string_type& start_delim,
                            const string_type& open_end_delim,
                            const string_type& closed_end_delim)
     {
-      m_period_separator;
-      m_period_start_delimeter;
-      m_open_range_end_delimeter;
-      m_closed_range_end_delimeter;
+        m_period_separator = separator;
+        m_period_start_delimeter = start_delim;
+        m_open_range_end_delimeter = open_end_delim;
+        m_closed_range_end_delimeter = closed_end_delim;
     }
 
-
     //! Generic code to output a period -- no matter the period type.
     /*! This generic code will output any period using a facet to
      *  to output the 'elements'.  For example, in the case of a date_period
-     *  the elements will be instances of a date which will be formatted 
+     *  the elements will be instances of a date which will be formatted
      *  according the to setup in the passed facet parameter.
-     * 
+     *
      *  The steps for formatting a period are always the same:
      *  - put the start delimiter
      *  - put start element
-     *  - put the separator 
+     *  - put the separator
      *  - put either last or end element depending on range settings
      *  - put end delimeter depending on range settings
      *
@@ -148,9 +152,9 @@ namespace boost { namespace date_time {
      *@endcode
      */
     template<class period_type, class facet_type>
-    OutItrT put_period(OutItrT next, 
-                       std::ios_base& a_ios, 
-                       char_type a_fill, 
+    OutItrT put_period(OutItrT next,
+                       std::ios_base& a_ios,
+                       char_type a_fill,
                        const period_type& p,
                        const facet_type& facet) const {
       put_period_start_delimeter(next);
@@ -166,29 +170,29 @@ namespace boost { namespace date_time {
       return next;
     }
 
-      
+
   private:
-    range_display_options m_range_option;    
+    range_display_options m_range_option;
     string_type m_period_separator;
     string_type m_period_start_delimeter;
     string_type m_open_range_end_delimeter;
     string_type m_closed_range_end_delimeter;
   };
 
-  template <class CharT, class OutItrT>  
-  const typename period_formatter<CharT, OutItrT>::char_type 
+  template <class CharT, class OutItrT>
+  const typename period_formatter<CharT, OutItrT>::char_type
   period_formatter<CharT, OutItrT>::default_period_separator[2] = {'/'};
 
-  template <class CharT, class OutItrT>  
-  const typename period_formatter<CharT, OutItrT>::char_type 
+  template <class CharT, class OutItrT>
+  const typename period_formatter<CharT, OutItrT>::char_type
   period_formatter<CharT, OutItrT>::default_period_start_delimeter[2] = {'['};
 
-  template <class CharT, class OutItrT>  
-  const typename period_formatter<CharT, OutItrT>::char_type 
+  template <class CharT, class OutItrT>
+  const typename period_formatter<CharT, OutItrT>::char_type
   period_formatter<CharT, OutItrT>::default_period_open_range_end_delimeter[2] = {')'};
 
-  template <class CharT, class OutItrT>  
-  const typename period_formatter<CharT, OutItrT>::char_type 
+  template <class CharT, class OutItrT>
+  const typename period_formatter<CharT, OutItrT>::char_type
   period_formatter<CharT, OutItrT>::default_period_closed_range_end_delimeter[2] = {']'};
 
  } } //namespace boost::date_time

include/boost/date_time/period_parser.hpp

@@ -3,26 +3,32 @@
 #define DATETIME_PERIOD_PARSER_HPP___
 
 /* Copyright (c) 2002-2004 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$
  */
 
-#include "boost/date_time/string_parse_tree.hpp"
-#include "boost/date_time/string_convert.hpp"
+#include <ios>
+#include <string>
+#include <vector>
+#include <iterator>
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/string_parse_tree.hpp>
+#include <boost/date_time/string_convert.hpp>
 
 
 namespace boost { namespace date_time {
 
 
-  //! Not a facet, but a class used to specify and control period parsing 
+  //! Not a facet, but a class used to specify and control period parsing
   /*! Provides settings for the following:
    *   - period_separator -- default '/'
    *   - period_open_start_delimeter -- default '['
-   *   - period_open_range_end_delimeter -- default ')' 
-   *   - period_closed_range_end_delimeter -- default ']' 
+   *   - period_open_range_end_delimeter -- default ')'
+   *   - period_closed_range_end_delimeter -- default ']'
    *   - display_as_open_range, display_as_closed_range -- default closed_range
    *
    *  For a typical date_period, the contents of the input stream would be
@@ -32,7 +38,7 @@ namespace boost { namespace date_time {
    * where the date format is controlled by the date facet
    */
   template<class date_type, typename CharT>
-  class period_parser { 
+  class period_parser {
   public:
     typedef std::basic_string<CharT> string_type;
     typedef CharT                    char_type;
@@ -41,7 +47,7 @@ namespace boost { namespace date_time {
     typedef string_parse_tree<CharT> parse_tree_type;
     typedef typename parse_tree_type::parse_match_result_type match_results;
     typedef std::vector<std::basic_string<CharT> > collection_type;
-    
+
     static const char_type default_period_separator[2];
     static const char_type default_period_start_delimeter[2];
     static const char_type default_period_open_range_end_delimeter[2];
@@ -50,12 +56,12 @@ namespace boost { namespace date_time {
     enum period_range_option { AS_OPEN_RANGE, AS_CLOSED_RANGE };
 
     //! Constructor that sets up period parser options
-    period_parser(period_range_option range_option = AS_CLOSED_RANGE, 
-                  const char_type* const period_separator = default_period_separator, 
+    period_parser(period_range_option range_opt = AS_CLOSED_RANGE,
+                  const char_type* const period_separator = default_period_separator,
                   const char_type* const period_start_delimeter = default_period_start_delimeter,
                   const char_type* const period_open_range_end_delimeter = default_period_open_range_end_delimeter,
                   const char_type* const period_closed_range_end_delimeter = default_period_closed_range_end_delimeter)
-      : m_range_option(range_option)
+      : m_range_option(range_opt)
     {
       delimiters.push_back(string_type(period_separator));
       delimiters.push_back(string_type(period_start_delimeter));
@@ -63,12 +69,6 @@ namespace boost { namespace date_time {
       delimiters.push_back(string_type(period_closed_range_end_delimeter));
     }
 
-    period_parser(const period_parser<date_type,CharT>& p_parser)
-    {
-      this->delimiters = p_parser.delimiters;
-      this->m_range_option = p_parser.m_range_option;
-    }
-
     period_range_option range_option() const
     {
       return m_range_option;
@@ -98,11 +98,11 @@ namespace boost { namespace date_time {
      *  to get the 'elements'.  For example, in the case of a date_period
      *  the elements will be instances of a date which will be parsed
      *  according the to setup in the passed facet parameter.
-     * 
+     *
      *  The steps for parsing a period are always the same:
      *  - consume the start delimiter
      *  - get start element
-     *  - consume the separator 
+     *  - consume the separator
      *  - get either last or end element depending on range settings
      *  - consume the end delimeter depending on range settings
      *
@@ -116,16 +116,16 @@ namespace boost { namespace date_time {
      *@endcode
      */
     template<class period_type, class duration_type, class facet_type>
-    period_type get_period(stream_itr_type& sitr, 
+    period_type get_period(stream_itr_type& sitr,
                            stream_itr_type& stream_end,
-                           std::ios_base& a_ios, 
-                           const period_type& p,
+                           std::ios_base& a_ios,
+                           const period_type& /* p */,
                            const duration_type& dur_unit,
-                           const facet_type& facet) const 
+                           const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-     
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
       typedef typename period_type::point_type point_type;
       point_type p1(not_a_date_time), p2(not_a_date_time);
 
@@ -144,14 +144,14 @@ namespace boost { namespace date_time {
       else {
         consume_delim(sitr, stream_end, delimiters[OPEN_END]);  // end delim
       }
-    
+
       return period_type(p1, p2);
     }
-      
+
   private:
-    collection_type delimiters; 
-    period_range_option m_range_option;    
-    
+    collection_type delimiters;
+    period_range_option m_range_option;
+
     enum delim_ids { SEPARATOR, START, OPEN_END, CLOSED_END };
 
     //! throws ios_base::failure if delimiter and parsed data do not match
@@ -159,10 +159,10 @@ namespace boost { namespace date_time {
                        stream_itr_type& stream_end,
                        const string_type& delim) const
     {
-      /* string_parse_tree will not parse a string of punctuation characters 
+      /* string_parse_tree will not parse a string of punctuation characters
        * without knowing exactly how many characters to process
-       * Ex [2000. Will not parse out the '[' string without knowing 
-       * to process only one character. By using length of the delimiter 
+       * Ex [2000. Will not parse out the '[' string without knowing
+       * to process only one character. By using length of the delimiter
        * string we can safely iterate past it. */
       string_type s;
       for(unsigned int i = 0; i < delim.length() && sitr != stream_end; ++i) {
@@ -170,25 +170,26 @@ namespace boost { namespace date_time {
         ++sitr;
       }
       if(s != delim) {
-        throw std::ios_base::failure("Parse failed. Expected '" + convert_string_type<char_type,char>(delim) + "' but found '" + convert_string_type<char_type,char>(s) + "'");
+        boost::throw_exception(std::ios_base::failure("Parse failed. Expected '"
+          + convert_string_type<char_type,char>(delim) + "' but found '" + convert_string_type<char_type,char>(s) + "'"));
       }
     }
   };
 
-  template <class date_type, class char_type>  
-  const typename period_parser<date_type, char_type>::char_type 
+  template <class date_type, class char_type>
+  const typename period_parser<date_type, char_type>::char_type
   period_parser<date_type, char_type>::default_period_separator[2] = {'/'};
 
-  template <class date_type, class char_type>  
-  const typename period_parser<date_type, char_type>::char_type 
+  template <class date_type, class char_type>
+  const typename period_parser<date_type, char_type>::char_type
   period_parser<date_type, char_type>::default_period_start_delimeter[2] = {'['};
 
-  template <class date_type, class char_type>  
-  const typename period_parser<date_type, char_type>::char_type 
+  template <class date_type, class char_type>
+  const typename period_parser<date_type, char_type>::char_type
   period_parser<date_type, char_type>::default_period_open_range_end_delimeter[2] = {')'};
 
-  template <class date_type, class char_type>  
-  const typename period_parser<date_type, char_type>::char_type 
+  template <class date_type, class char_type>
+  const typename period_parser<date_type, char_type>::char_type
   period_parser<date_type, char_type>::default_period_closed_range_end_delimeter[2] = {']'};
 
  } } //namespace boost::date_time

include/boost/date_time/posix_time/conversion.hpp

@@ -2,56 +2,59 @@
 #define POSIX_TIME_CONVERSION_HPP___
 
 /* Copyright (c) 2002-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$
  */
 
-#include "boost/date_time/posix_time/ptime.hpp"
-#include "boost/date_time/posix_time/posix_time_duration.hpp"
-#include "boost/date_time/filetime_functions.hpp"
-#include "boost/date_time/c_time.hpp"
-#include "boost/date_time/gregorian/conversion.hpp"
+#include <cstring>
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/ptime.hpp>
+#include <boost/date_time/posix_time/posix_time_duration.hpp>
+#include <boost/date_time/filetime_functions.hpp>
+#include <boost/date_time/c_time.hpp>
+#include <boost/date_time/time_resolution_traits.hpp> // absolute_value
+#include <boost/date_time/gregorian/conversion.hpp>
 
 namespace boost {
 
 namespace posix_time {
 
-
   //! Function that converts a time_t into a ptime.
   inline
-  ptime from_time_t(std::time_t t) 
+  ptime from_time_t(std::time_t t)
   {
-    ptime start(gregorian::date(1970,1,1));
-    return start + seconds(static_cast<long>(t));
+    return ptime(gregorian::date(1970,1,1)) + seconds(t);
   }
 
-  //! Convert a time to a tm structure truncating any fractional seconds 
+  //! Function that converts a ptime into a time_t
+  inline
+  std::time_t to_time_t(ptime pt)
+  {
+    return (pt - ptime(gregorian::date(1970,1,1))).total_seconds();
+  }
+
+  //! Convert a time to a tm structure truncating any fractional seconds
   inline
   std::tm to_tm(const boost::posix_time::ptime& t) {
     std::tm timetm = boost::gregorian::to_tm(t.date());
     boost::posix_time::time_duration td = t.time_of_day();
-    timetm.tm_hour = td.hours(); 
-    timetm.tm_min = td.minutes(); 
-    timetm.tm_sec = td.seconds();
-    timetm.tm_isdst = -1; // -1 used when dst info is unknown 
+    timetm.tm_hour = static_cast<int>(td.hours());
+    timetm.tm_min = static_cast<int>(td.minutes());
+    timetm.tm_sec = static_cast<int>(td.seconds());
+    timetm.tm_isdst = -1; // -1 used when dst info is unknown
     return timetm;
   }
-  //! Convert a time_duration to a tm structure truncating any fractional seconds and zeroing fields for date components 
+  //! Convert a time_duration to a tm structure truncating any fractional seconds and zeroing fields for date components
   inline
   std::tm to_tm(const boost::posix_time::time_duration& td) {
     std::tm timetm;
-    timetm.tm_year = 0;
-    timetm.tm_mon = 0;
-    timetm.tm_mday = 0;
-    timetm.tm_wday = 0;
-    timetm.tm_yday = 0;
-    
-    timetm.tm_hour = date_time::absolute_value(td.hours()); 
-    timetm.tm_min = date_time::absolute_value(td.minutes());
-    timetm.tm_sec = date_time::absolute_value(td.seconds());
+    std::memset(&timetm, 0, sizeof(timetm));
+    timetm.tm_hour = static_cast<int>(date_time::absolute_value(td.hours()));
+    timetm.tm_min = static_cast<int>(date_time::absolute_value(td.minutes()));
+    timetm.tm_sec = static_cast<int>(date_time::absolute_value(td.seconds()));
     timetm.tm_isdst = -1; // -1 used when dst info is unknown
     return timetm;
   }
@@ -65,21 +68,25 @@ namespace posix_time {
 
 
 #if defined(BOOST_HAS_FTIME)
-  
+
   //! Function to create a time object from an initialized FILETIME struct.
   /*! Function to 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. 
+   * 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.
    *
-   * Note ftime is part of the Win32 API, so it is not portable to non-windows
+   * \note FILETIME is part of the Win32 API, so it is not portable to non-windows
    * platforms.
+   *
+   * \note The function is templated on the FILETIME type, so that
+   *       it can be used with both native FILETIME and the ad-hoc
+   *       boost::detail::winapi::FILETIME_ type.
    */
-  template<class time_type>
+  template< typename TimeT, typename FileTimeT >
   inline
-  time_type from_ftime(const FILETIME& ft)
+  TimeT from_ftime(const FileTimeT& ft)
   {
-    return boost::date_time::time_from_ftime<time_type>(ft);
+    return boost::date_time::time_from_ftime<TimeT>(ft);
   }
 
 #endif // BOOST_HAS_FTIME

include/boost/date_time/posix_time/date_duration_operators.hpp

@@ -1,6 +1,6 @@
 #ifndef DATE_DURATION_OPERATORS_HPP___
 #define DATE_DURATION_OPERATORS_HPP___
-                                                                                
+
 /* Copyright (c) 2004 CrystalClear Software, Inc.
  * Subject to the Boost Software License, Version 1.0. 
  * (See accompanying file LICENSE_1_0.txt or 
@@ -26,7 +26,7 @@ namespace posix_time {
   /*! Adds a months object and a ptime. Result will be same 
    * day-of-month as ptime unless original day was the last day of month.
    * see date_time::months_duration for more details */
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   ptime 
   operator+(const ptime& t, const boost::gregorian::months& m)
   {
@@ -36,7 +36,7 @@ namespace posix_time {
   /*! Adds a months object to a ptime. Result will be same 
    * day-of-month as ptime unless original day was the last day of month.
    * see date_time::months_duration for more details */
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   ptime 
   operator+=(ptime& t, const boost::gregorian::months& m)
   {
@@ -47,7 +47,7 @@ namespace posix_time {
   /*! Subtracts a months object and a ptime. Result will be same 
    * day-of-month as ptime unless original day was the last day of month.
    * see date_time::months_duration for more details */
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   ptime 
   operator-(const ptime& t, const boost::gregorian::months& m)
   {
@@ -58,7 +58,7 @@ namespace posix_time {
   /*! Subtracts a months object from a ptime. Result will be same 
    * day-of-month as ptime unless original day was the last day of month.
    * see date_time::months_duration for more details */
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   ptime 
   operator-=(ptime& t, const boost::gregorian::months& m)
   {
@@ -70,7 +70,7 @@ namespace posix_time {
   /*! Adds a years object and a ptime. Result will be same 
    * month and day-of-month as ptime unless original day was the 
    * last day of month. see date_time::years_duration for more details */
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   ptime 
   operator+(const ptime& t, const boost::gregorian::years& y)
   {
@@ -80,7 +80,7 @@ namespace posix_time {
   /*! Adds a years object to a ptime. Result will be same 
    * month and day-of-month as ptime unless original day was the 
    * last day of month. see date_time::years_duration for more details */
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   ptime 
   operator+=(ptime& t, const boost::gregorian::years& y)
   {
@@ -90,7 +90,7 @@ namespace posix_time {
   /*! Subtracts a years object and a ptime. Result will be same 
    * month and day-of-month as ptime unless original day was the 
    * last day of month. see date_time::years_duration for more details */
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   ptime 
   operator-(const ptime& t, const boost::gregorian::years& y)
   {
@@ -101,7 +101,7 @@ namespace posix_time {
   /*! Subtracts a years object from a ptime. Result will be same 
    * month and day-of-month as ptime unless original day was the 
    * last day of month. see date_time::years_duration for more details */
-  inline
+  inline BOOST_CXX14_CONSTEXPR
   ptime 
   operator-=(ptime& t, const boost::gregorian::years& y)
   {

include/boost/date_time/posix_time/posix_time_config.hpp

@@ -1,60 +1,47 @@
 #ifndef POSIX_TIME_CONFIG_HPP___
 #define POSIX_TIME_CONFIG_HPP___
 
-/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+/* Copyright (c) 2002,2003,2005,2020 CrystalClear Software, Inc.
+ * 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$
  */
 
-#include "boost/date_time/time_duration.hpp"
-#include "boost/date_time/time_resolution_traits.hpp"
-#include "boost/date_time/gregorian/gregorian_types.hpp"
-#include "boost/date_time/wrapping_int.hpp"
-#include "boost/limits.hpp"
-#include "boost/date_time/compiler_config.hpp"
-#include "boost/cstdint.hpp"
-#include <boost/config/no_tr1/cmath.hpp>
 #include <cstdlib> //for MCW 7.2 std::abs(long long)
+#include <boost/limits.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/config/no_tr1/cmath.hpp>
+#include <boost/date_time/time_duration.hpp>
+#include <boost/date_time/time_resolution_traits.hpp>
+#include <boost/date_time/gregorian/gregorian_types.hpp>
+#include <boost/date_time/wrapping_int.hpp>
+#include <boost/date_time/compiler_config.hpp>
 
 namespace boost {
 namespace posix_time {
 
-//Remove the following line if you want 64 bit millisecond resolution time
-//#define BOOST_GDTL_POSIX_TIME_STD_CONFIG
 
 #ifdef BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
   // set up conditional test compilations
-#define BOOST_DATE_TIME_HAS_MILLISECONDS
-#define BOOST_DATE_TIME_HAS_MICROSECONDS
 #define BOOST_DATE_TIME_HAS_NANOSECONDS
-  typedef date_time::time_resolution_traits<boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::nano, 
+  typedef date_time::time_resolution_traits<boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::nano,
     1000000000, 9 > time_res_traits;
 #else
   // set up conditional test compilations
-#define BOOST_DATE_TIME_HAS_MILLISECONDS
-#define BOOST_DATE_TIME_HAS_MICROSECONDS
 #undef  BOOST_DATE_TIME_HAS_NANOSECONDS
   typedef date_time::time_resolution_traits<
-    boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro, 
+    boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro,
                                             1000000, 6 > time_res_traits;
 
-
-// #undef BOOST_DATE_TIME_HAS_MILLISECONDS
-// #undef BOOST_DATE_TIME_HAS_MICROSECONDS
-// #undef BOOST_DATE_TIME_HAS_NANOSECONDS
-//   typedef date_time::time_resolution_traits<boost::int64_t, boost::date_time::tenth, 
-//                                              10, 0 > time_res_traits;
-
 #endif
 
 
   //! Base time duration type
   /*! \ingroup time_basics
    */
-  class time_duration :
+  class BOOST_SYMBOL_VISIBLE time_duration :
     public date_time::time_duration<time_duration, time_res_traits>
   {
   public:
@@ -66,24 +53,24 @@ namespace posix_time {
     typedef time_res_traits::fractional_seconds_type fractional_seconds_type;
     typedef time_res_traits::tick_type tick_type;
     typedef time_res_traits::impl_type impl_type;
-    time_duration(hour_type hour,
-                  min_type min,
-                  sec_type sec,
-                  fractional_seconds_type fs=0) :
+    BOOST_CXX14_CONSTEXPR time_duration(hour_type hour,
+                                        min_type min,
+                                        sec_type sec,
+                                        fractional_seconds_type fs=0) :
       date_time::time_duration<time_duration, time_res_traits>(hour,min,sec,fs)
     {}
-    time_duration() :
+   BOOST_CXX14_CONSTEXPR time_duration() :
       date_time::time_duration<time_duration, time_res_traits>(0,0,0)
     {}
     //! Construct from special_values
-    time_duration(boost::date_time::special_values sv) :
+    BOOST_CXX14_CONSTEXPR time_duration(boost::date_time::special_values sv) :
       date_time::time_duration<time_duration, time_res_traits>(sv)
     {}
     //Give duration access to ticks constructor -- hide from users
     friend class date_time::time_duration<time_duration, time_res_traits>;
-  private:
-    explicit time_duration(impl_type ticks) :
-      date_time::time_duration<time_duration, time_res_traits>(ticks)
+  protected:
+    BOOST_CXX14_CONSTEXPR explicit time_duration(impl_type tick_count) :
+      date_time::time_duration<time_duration, time_res_traits>(tick_count)
     {}
   };
 
@@ -94,7 +81,7 @@ namespace posix_time {
   {
     typedef gregorian::date      date_type;
     typedef time_duration        time_duration_type;
-    simple_time_rep(date_type d, time_duration_type tod) :
+    BOOST_CXX14_CONSTEXPR simple_time_rep(date_type d, time_duration_type tod) :
       day(d),
       time_of_day(tod)
     {
@@ -116,25 +103,25 @@ namespace posix_time {
     }
     date_type day;
     time_duration_type time_of_day;
-    bool is_special()const
+    BOOST_CXX14_CONSTEXPR bool is_special()const
     {
       return(is_pos_infinity() || is_neg_infinity() || is_not_a_date_time());
     }
-    bool is_pos_infinity()const
+    BOOST_CXX14_CONSTEXPR bool is_pos_infinity()const
     {
       return(day.is_pos_infinity() || time_of_day.is_pos_infinity());
     }
-    bool is_neg_infinity()const
+    BOOST_CXX14_CONSTEXPR bool is_neg_infinity()const
     {
       return(day.is_neg_infinity() || time_of_day.is_neg_infinity());
     }
-    bool is_not_a_date_time()const
+    BOOST_CXX14_CONSTEXPR bool is_not_a_date_time()const
     {
       return(day.is_not_a_date() || time_of_day.is_not_a_date_time());
     }
   };
 
-  class posix_time_system_config 
+  class BOOST_SYMBOL_VISIBLE posix_time_system_config
   {
    public:
     typedef simple_time_rep time_rep_type;
@@ -143,7 +130,7 @@ namespace posix_time {
     typedef time_duration time_duration_type;
     typedef time_res_traits::tick_type int_type;
     typedef time_res_traits resolution_traits;
-#if (defined(BOOST_DATE_TIME_NO_MEMBER_INIT)) //help bad compilers 
+#if (defined(BOOST_DATE_TIME_NO_MEMBER_INIT)) //help bad compilers
 #else
     BOOST_STATIC_CONSTANT(boost::int64_t, tick_per_second = 1000000000);
 #endif
@@ -151,7 +138,7 @@ namespace posix_time {
 
 #else
 
-  class millisec_posix_time_system_config 
+  class millisec_posix_time_system_config
   {
    public:
     typedef boost::int64_t time_rep_type;
@@ -162,7 +149,7 @@ namespace posix_time {
     typedef time_res_traits::tick_type int_type;
     typedef time_res_traits::impl_type impl_type;
     typedef time_res_traits resolution_traits;
-#if (defined(BOOST_DATE_TIME_NO_MEMBER_INIT)) //help bad compilers 
+#if (defined(BOOST_DATE_TIME_NO_MEMBER_INIT)) //help bad compilers
 #else
     BOOST_STATIC_CONSTANT(boost::int64_t, tick_per_second = 1000000);
 #endif

include/boost/date_time/posix_time/posix_time_duration.hpp

@@ -1,7 +1,7 @@
 #ifndef POSIX_TIME_DURATION_HPP___
 #define POSIX_TIME_DURATION_HPP___
 
-/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+/* Copyright (c) 2002,2003, 2020 CrystalClear Software, Inc.
  * 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)
@@ -9,41 +9,54 @@
  * $Date$
  */
 
-#include "boost/date_time/posix_time/posix_time_config.hpp"
+#include <boost/core/enable_if.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/posix_time/posix_time_config.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+#include <boost/type_traits/is_integral.hpp>
 
 namespace boost {
 namespace posix_time {
 
   //! Allows expression of durations as an hour count
+  //! The argument must be an integral type
   /*! \ingroup time_basics
    */
-  class hours : public time_duration
+  class BOOST_SYMBOL_VISIBLE hours : public time_duration
   {
   public:
-    explicit hours(long h) :
-      time_duration(h,0,0)
+      template <typename T>
+      BOOST_CXX14_CONSTEXPR explicit hours(T const& h,
+          typename boost::enable_if<boost::is_integral<T>, void>::type* = BOOST_DATE_TIME_NULLPTR) :
+      time_duration(numeric_cast<hour_type>(h), 0, 0)
     {}
   };
 
   //! Allows expression of durations as a minute count
+  //! The argument must be an integral type
   /*! \ingroup time_basics
    */
-  class minutes : public time_duration
+  class BOOST_SYMBOL_VISIBLE minutes : public time_duration
   {
   public:
-    explicit minutes(long m) :
-      time_duration(0,m,0)
+      template <typename T>
+      BOOST_CXX14_CONSTEXPR explicit minutes(T const& m,
+          typename boost::enable_if<boost::is_integral<T>, void>::type* = BOOST_DATE_TIME_NULLPTR) :
+      time_duration(0, numeric_cast<min_type>(m),0)
     {}
   };
 
   //! Allows expression of durations as a seconds count
+  //! The argument must be an integral type
   /*! \ingroup time_basics
    */
-  class seconds : public time_duration
+  class BOOST_SYMBOL_VISIBLE seconds : public time_duration
   {
   public:
-    explicit seconds(long s) :
-      time_duration(0,0,s)
+      template <typename T>
+      BOOST_CXX14_CONSTEXPR explicit seconds(T const& s,
+          typename boost::enable_if<boost::is_integral<T>, void>::type* = BOOST_DATE_TIME_NULLPTR) :
+      time_duration(0,0, numeric_cast<sec_type>(s))
     {}
   };
 
@@ -69,12 +82,8 @@ namespace posix_time {
   typedef date_time::subsecond_duration<time_duration,1000000000> nanosec;
   typedef date_time::subsecond_duration<time_duration,1000000000> nanoseconds;
 
-
 #endif
 
-
-
-
 } }//namespace posix_time
 
 

include/boost/date_time/posix_time/posix_time_io.hpp

@@ -9,14 +9,16 @@
  * $Date$
  */
 
-#include "boost/date_time/time_facet.hpp"
-#include "boost/date_time/period_formatter.hpp"
-#include "boost/date_time/posix_time/time_period.hpp"
-#include "boost/date_time/posix_time/posix_time_duration.hpp"
-//#include "boost/date_time/gregorian/gregorian_io.hpp"
-#include "boost/io/ios_state.hpp"
-#include <iostream>
 #include <locale>
+#include <iostream>
+#include <iterator> // i/ostreambuf_iterator
+#include <boost/io/ios_state.hpp>
+#include <boost/date_time/time_facet.hpp>
+#include <boost/date_time/period_formatter.hpp>
+#include <boost/date_time/posix_time/ptime.hpp>
+#include <boost/date_time/posix_time/time_period.hpp>
+#include <boost/date_time/posix_time/posix_time_duration.hpp>
+#include <boost/date_time/posix_time/conversion.hpp> // to_tm will be needed in the facets
 
 namespace boost {
 namespace posix_time {
@@ -39,13 +41,12 @@ namespace posix_time {
   typedef boost::date_time::time_input_facet<ptime, char>         time_input_facet;
 
   template <class CharT, class TraitsT>
-  inline 
+  inline
   std::basic_ostream<CharT, TraitsT>&
-  operator<<(std::basic_ostream<CharT, TraitsT>& os, 
+  operator<<(std::basic_ostream<CharT, TraitsT>& os,
              const ptime& p) {
     boost::io::ios_flags_saver iflags(os);
     typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
-    typedef std::time_put<CharT>                  std_ptime_facet;
     std::ostreambuf_iterator<CharT> oitr(os);
     if (std::has_facet<custom_ptime_facet>(os.getloc()))
       std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), p);
@@ -55,7 +56,6 @@ namespace posix_time {
       //since we would always need to reconstruct for every time period
       //if the locale did not already exist.  Of course this will be overridden
       //if the user imbues as some later point.
-      std::ostreambuf_iterator<CharT> oitr(os);
       custom_ptime_facet* f = new custom_ptime_facet();
       std::locale l = std::locale(os.getloc(), f);
       os.imbue(l);
@@ -71,51 +71,48 @@ namespace posix_time {
   operator>>(std::basic_istream<CharT, Traits>& is, ptime& pt)
   {
     boost::io::ios_flags_saver iflags(is);
-    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
+    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
     if (strm_sentry) {
       try {
-        typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
-        
+        typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet_local;
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<time_input_facet>(is.getloc())) {
-          std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, pt);
+        if(std::has_facet<time_input_facet_local>(is.getloc())) {
+          std::use_facet<time_input_facet_local>(is.getloc()).get(sit, str_end, is, pt);
         }
         else {
-          time_input_facet* f = new time_input_facet();
+          time_input_facet_local* f = new time_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, pt);
         }
       }
-      catch(...) { 
+      catch(...) {
         // mask tells us what exceptions are turned on
         std::ios_base::iostate exception_mask = is.exceptions();
         // if the user wants exceptions on failbit, we'll rethrow our 
         // date_time exception & set the failbit
         if(std::ios_base::failbit & exception_mask) {
-          try { is.setstate(std::ios_base::failbit); } 
+          try { is.setstate(std::ios_base::failbit); }
           catch(std::ios_base::failure&) {} // ignore this one
           throw; // rethrow original exception
         }
         else {
-          // if the user want's to fail quietly, we simply set the failbit
-          is.setstate(std::ios_base::failbit); 
-        } 
-            
+          // if the user wants to fail quietly, we simply set the failbit
+          is.setstate(std::ios_base::failbit);
+        }
       }
     }
     return is;
   }
-  
+
 
   template <class CharT, class TraitsT>
   inline 
   std::basic_ostream<CharT, TraitsT>&
-  operator<<(std::basic_ostream<CharT, TraitsT>& os, 
+  operator<<(std::basic_ostream<CharT, TraitsT>& os,
              const boost::posix_time::time_period& p) {
     boost::io::ios_flags_saver iflags(os);
     typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
-    typedef std::time_put<CharT>                  std_time_facet;
     std::ostreambuf_iterator<CharT> oitr(os);
     if (std::has_facet<custom_ptime_facet>(os.getloc())) {
       std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), p);
@@ -126,7 +123,6 @@ namespace posix_time {
       //since we would always need to reconstruct for every time period
       //if the local did not already exist.  Of course this will be overridden
       //if the user imbues as some later point.
-      std::ostreambuf_iterator<CharT> oitr(os);
       custom_ptime_facet* f = new custom_ptime_facet();
       std::locale l = std::locale(os.getloc(), f);
       os.imbue(l);
@@ -142,38 +138,36 @@ namespace posix_time {
   operator>>(std::basic_istream<CharT, Traits>& is, time_period& tp)
   {
     boost::io::ios_flags_saver iflags(is);
-    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
+    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
     if (strm_sentry) {
       try {
-        typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
-
+        typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet_local;
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<time_input_facet>(is.getloc())) {
-          std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, tp);
+        if(std::has_facet<time_input_facet_local>(is.getloc())) {
+          std::use_facet<time_input_facet_local>(is.getloc()).get(sit, str_end, is, tp);
         }
         else {
-          time_input_facet* f = new time_input_facet();
+          time_input_facet_local* f = new time_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, tp);
         }
       }
-      catch(...) { 
+      catch(...) {
         std::ios_base::iostate exception_mask = is.exceptions();
         if(std::ios_base::failbit & exception_mask) {
-          try { is.setstate(std::ios_base::failbit); } 
+          try { is.setstate(std::ios_base::failbit); }
           catch(std::ios_base::failure&) {}
           throw; // rethrow original exception
         }
         else {
-          is.setstate(std::ios_base::failbit); 
-        } 
-            
+          is.setstate(std::ios_base::failbit);
+        }
       }
     }
     return is;
   }
-  
+
 
   //! ostream operator for posix_time::time_duration 
   //  todo fix to use facet --  place holder for now...
@@ -184,7 +178,6 @@ namespace posix_time {
   {
     boost::io::ios_flags_saver iflags(os);
     typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
-    typedef std::time_put<CharT>                  std_ptime_facet;
     std::ostreambuf_iterator<CharT> oitr(os);
     if (std::has_facet<custom_ptime_facet>(os.getloc()))
       std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), td);
@@ -194,7 +187,6 @@ namespace posix_time {
       //since we would always need to reconstruct for every time period
       //if the locale did not already exist.  Of course this will be overridden
       //if the user imbues as some later point.
-      std::ostreambuf_iterator<CharT> oitr(os);
       custom_ptime_facet* f = new custom_ptime_facet();
       std::locale l = std::locale(os.getloc(), f);
       os.imbue(l);
@@ -210,37 +202,35 @@ namespace posix_time {
   operator>>(std::basic_istream<CharT, Traits>& is, time_duration& td)
   {
     boost::io::ios_flags_saver iflags(is);
-    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
+    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
     if (strm_sentry) {
       try {
-        typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
-
+        typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet_local;
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
-        if(std::has_facet<time_input_facet>(is.getloc())) {
-          std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, td);
+        if(std::has_facet<time_input_facet_local>(is.getloc())) {
+          std::use_facet<time_input_facet_local>(is.getloc()).get(sit, str_end, is, td);
         }
         else {
-          time_input_facet* f = new time_input_facet();
+          time_input_facet_local* f = new time_input_facet_local();
           std::locale l = std::locale(is.getloc(), f);
           is.imbue(l);
           f->get(sit, str_end, is, td);
         }
       }
-      catch(...) { 
+      catch(...) {
         std::ios_base::iostate exception_mask = is.exceptions();
         if(std::ios_base::failbit & exception_mask) {
-          try { is.setstate(std::ios_base::failbit); } 
+          try { is.setstate(std::ios_base::failbit); }
           catch(std::ios_base::failure&) {}
           throw; // rethrow original exception
         }
         else {
-          is.setstate(std::ios_base::failbit); 
-        } 
-            
+          is.setstate(std::ios_base::failbit);
+        }
       }
     }
     return is;
   }
-  
+
 } } // namespaces
 #endif // DATE_TIME_POSIX_TIME_IO_HPP__

include/boost/date_time/posix_time/posix_time_legacy_io.hpp

@@ -80,7 +80,7 @@ namespace posix_time {
     // any marker (such as '\0').
     typename std::basic_string<charT>::iterator e = inp_s.end();
     while(b != e){
-      out_ss << out_ss.narrow(*b, 0);
+      out_ss << is.narrow(*b, 0);
       ++b;
     }
 

include/boost/date_time/posix_time/ptime.hpp

@@ -9,8 +9,9 @@
  * $Date$
  */
 
-#include "boost/date_time/posix_time/posix_time_system.hpp"
-#include "boost/date_time/time.hpp"
+#include <boost/date_time/posix_time/posix_time_system.hpp>
+#include <boost/date_time/time.hpp>
+#include <boost/date_time/compiler_config.hpp>
 
 namespace boost {
 
@@ -24,11 +25,11 @@ namespace posix_time {
   using date_time::not_a_date_time;
   using date_time::max_date_time;
   using date_time::min_date_time; 
-  
+
   //! Time type with no timezone or other adjustments
   /*! \ingroup time_basics
    */
-  class ptime : public date_time::base_time<ptime, posix_time_system>
+  class BOOST_SYMBOL_VISIBLE ptime : public date_time::base_time<ptime, posix_time_system>
   {
   public:
     typedef posix_time_system time_system_type;
@@ -36,26 +37,44 @@ namespace posix_time {
     typedef time_system_type::time_duration_type time_duration_type;
     typedef ptime time_type;
     //! Construct with date and offset in day
-    ptime(gregorian::date d,time_duration_type td) : date_time::base_time<time_type,time_system_type>(d,td)
+    BOOST_CXX14_CONSTEXPR 
+    ptime(gregorian::date d,time_duration_type td) :
+      date_time::base_time<time_type,time_system_type>(d,td)
     {}
     //! Construct a time at start of the given day (midnight)
-    explicit ptime(gregorian::date d) : date_time::base_time<time_type,time_system_type>(d,time_duration_type(0,0,0))
+    BOOST_CXX14_CONSTEXPR 
+    explicit ptime(gregorian::date d) :
+      date_time::base_time<time_type,time_system_type>(d,time_duration_type(0,0,0))
     {}
     //! Copy from time_rep
+    BOOST_CXX14_CONSTEXPR 
     ptime(const time_rep_type& rhs):
       date_time::base_time<time_type,time_system_type>(rhs)
     {}
     //! Construct from special value
-    ptime(const special_values sv) : date_time::base_time<time_type,time_system_type>(sv)
+    BOOST_CXX14_CONSTEXPR 
+    ptime(const special_values sv) :
+      date_time::base_time<time_type,time_system_type>(sv)
     {}
 #if !defined(DATE_TIME_NO_DEFAULT_CONSTRUCTOR)
     // Default constructor constructs to not_a_date_time
-    ptime() : date_time::base_time<time_type,time_system_type>(gregorian::date(not_a_date_time), time_duration_type(not_a_date_time))
+    BOOST_CXX14_CONSTEXPR 
+    ptime() :
+      date_time::base_time<time_type,time_system_type>(gregorian::date(not_a_date_time),
+                                                       time_duration_type(not_a_date_time))
     {}
 #endif // DATE_TIME_NO_DEFAULT_CONSTRUCTOR
-      
+
+    friend BOOST_CXX14_CONSTEXPR
+    bool operator==(const ptime& lhs, const ptime& rhs);
+
   };
 
+  inline BOOST_CXX14_CONSTEXPR
+  bool operator==(const ptime& lhs, const ptime& rhs)
+  {
+    return ptime::time_system_type::is_equal(lhs.time_,rhs.time_);
+  }
 
 
 } }//namespace posix_time

include/boost/date_time/posix_time/time_formatters.hpp

@@ -2,24 +2,24 @@
 #define POSIXTIME_FORMATTERS_HPP___
 
 /* Copyright (c) 2002-2004 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$
  */
 
-#include "boost/date_time/gregorian/gregorian.hpp"
-#include "boost/date_time/compiler_config.hpp"
-#include "boost/date_time/iso_format.hpp"
-#include "boost/date_time/date_format_simple.hpp"
-#include "boost/date_time/posix_time/posix_time_types.hpp"
-#include "boost/date_time/time_formatting_streams.hpp"
+#include <boost/date_time/gregorian/gregorian.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/iso_format.hpp>
+#include <boost/date_time/date_format_simple.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/date_time/time_formatting_streams.hpp>
+#include <boost/date_time/time_resolution_traits.hpp> // absolute_value
+#include <boost/date_time/time_parsing.hpp>
 
-#include "boost/date_time/time_parsing.hpp"
-
-/* NOTE: The "to_*_string" code for older compilers, ones that define 
- * BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS, is located in 
+/* NOTE: The "to_*_string" code for older compilers, ones that define
+ * BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS, is located in
  * formatters_limited.hpp
  */
 
@@ -57,27 +57,27 @@ namespace posix_time {
       if(td.is_negative()) {
         ss << '-';
       }
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.hours()) << ":";
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.minutes()) << ":";
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.seconds());
       //TODO the following is totally non-generic, yelling FIXME
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
-      boost::int64_t frac_sec = 
+      boost::int64_t frac_sec =
         date_time::absolute_value(td.fractional_seconds());
       // JDG [7/6/02 VC++ compatibility]
       charT buff[32];
       _i64toa(frac_sec, buff, 10);
 #else
-      time_duration::fractional_seconds_type frac_sec = 
+      time_duration::fractional_seconds_type frac_sec =
         date_time::absolute_value(td.fractional_seconds());
 #endif
       if (frac_sec != 0) {
         ss  << "." << std::setw(time_duration::num_fractional_digits())
             << std::setfill(fill_char)
-          
+
           // JDG [7/6/02 VC++ compatibility]
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
             << buff;
@@ -99,7 +99,7 @@ namespace posix_time {
   // template function called by wrapper functions:
   // to_*_string(time_duration) & to_*_wstring(time_duration)
   template<class charT>
-  inline std::basic_string<charT> to_iso_string_type(time_duration td) 
+  inline std::basic_string<charT> to_iso_string_type(time_duration td)
   {
     std::basic_ostringstream<charT> ss;
     if(td.is_special()) {
@@ -126,27 +126,27 @@ namespace posix_time {
       if(td.is_negative()) {
         ss << '-';
       }
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.hours());
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.minutes());
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.seconds());
       //TODO the following is totally non-generic, yelling FIXME
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
-      boost::int64_t frac_sec = 
+      boost::int64_t frac_sec =
         date_time::absolute_value(td.fractional_seconds());
       // JDG [7/6/02 VC++ compatibility]
       charT buff[32];
       _i64toa(frac_sec, buff, 10);
 #else
-      time_duration::fractional_seconds_type frac_sec = 
+      time_duration::fractional_seconds_type frac_sec =
         date_time::absolute_value(td.fractional_seconds());
 #endif
       if (frac_sec != 0) {
         ss  << "." << std::setw(time_duration::num_fractional_digits())
             << std::setfill(fill_char)
-          
+
           // JDG [7/6/02 VC++ compatibility]
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
             << buff;
@@ -157,7 +157,7 @@ namespace posix_time {
     }// else
     return ss.str();
   }
-  //! Time duration in iso format -hhmmss,fffffff Example: 10:09:03,0123456
+  //! Time duration in ISO 8601 format -hhmmss.fffffff. Example: 10:09:03.0123456
   /*!\ingroup time_format
    */
   inline std::string to_iso_string(time_duration td){
@@ -168,7 +168,7 @@ namespace posix_time {
   /*!\ingroup time_format
    */
   template<class charT>
-  inline std::basic_string<charT> to_simple_string_type(ptime t) 
+  inline std::basic_string<charT> to_simple_string_type(ptime t)
   {
     // can't use this w/gcc295, no to_simple_string_type<>(td) available
     std::basic_string<charT> ts = gregorian::to_simple_string_type<charT>(t.date());// + " ";
@@ -184,10 +184,10 @@ namespace posix_time {
     return to_simple_string_type<char>(t);
   }
 
-  // function called by wrapper functions to_*_string(time_period) 
+  // function called by wrapper functions to_*_string(time_period)
   // & to_*_wstring(time_period)
   template<class charT>
-  inline std::basic_string<charT> to_simple_string_type(time_period tp) 
+  inline std::basic_string<charT> to_simple_string_type(time_period tp)
   {
     charT beg = '[', mid = '/', end = ']';
     std::basic_string<charT> d1(to_simple_string_type<charT>(tp.begin()));
@@ -201,10 +201,10 @@ namespace posix_time {
     return to_simple_string_type<char>(tp);
   }
 
-  // function called by wrapper functions to_*_string(time_period) 
+  // function called by wrapper functions to_*_string(time_period)
   // & to_*_wstring(time_period)
   template<class charT>
-  inline std::basic_string<charT> to_iso_string_type(ptime t) 
+  inline std::basic_string<charT> to_iso_string_type(ptime t)
   {
     std::basic_string<charT> ts = gregorian::to_iso_string_type<charT>(t.date());// + "T";
     if(!t.time_of_day().is_special()) {
@@ -215,7 +215,7 @@ namespace posix_time {
       return ts;
     }
   }
-  //! Convert iso short form YYYYMMDDTHHMMSS where T is the date-time separator
+  //! Convert ISO 8601 short form YYYYMMDDTHHMMSS where T is the date-time separator
   /*!\ingroup time_format
    */
   inline std::string to_iso_string(ptime t){
@@ -223,10 +223,10 @@ namespace posix_time {
   }
 
 
-  // function called by wrapper functions to_*_string(time_period) 
+  // function called by wrapper functions to_*_string(time_period)
   // & to_*_wstring(time_period)
   template<class charT>
-  inline std::basic_string<charT> to_iso_extended_string_type(ptime t) 
+  inline std::basic_string<charT> to_iso_extended_string_type(ptime t)
   {
     std::basic_string<charT> ts = gregorian::to_iso_extended_string_type<charT>(t.date());// + "T";
     if(!t.time_of_day().is_special()) {
@@ -251,7 +251,7 @@ namespace posix_time {
   inline std::wstring to_simple_wstring(time_duration td) {
     return to_simple_string_type<wchar_t>(td);
   }
-  //! Time duration in iso format -hhmmss,fffffff Example: 10:09:03,0123456
+  //! Time duration in ISO 8601 format -hhmmss.fffffff. Example: 10:09:03.0123456
   /*!\ingroup time_format
    */
   inline std::wstring to_iso_wstring(time_duration td){
@@ -266,7 +266,7 @@ namespace posix_time {
   inline std::wstring to_simple_wstring(time_period tp){
     return to_simple_string_type<wchar_t>(tp);
   }
-  //! Convert iso short form YYYYMMDDTHHMMSS where T is the date-time separator
+  //! Convert ISO 8601 short form YYYYMMDDTHHMMSS where T is the date-time separator
   /*!\ingroup time_format
    */
   inline std::wstring to_iso_wstring(ptime t){

include/boost/date_time/posix_time/time_formatters_limited.hpp

@@ -2,20 +2,21 @@
 #define POSIXTIME_FORMATTERS_LIMITED_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$
  */
 
-#include "boost/date_time/gregorian/gregorian.hpp"
-#include "boost/date_time/compiler_config.hpp"
-#include "boost/date_time/iso_format.hpp"
-#include "boost/date_time/date_format_simple.hpp"
-#include "boost/date_time/posix_time/posix_time_types.hpp"
-#include "boost/date_time/time_formatting_streams.hpp"
- 
+#include <boost/date_time/gregorian/gregorian.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/iso_format.hpp>
+#include <boost/date_time/date_format_simple.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/date_time/time_formatting_streams.hpp>
+#include <boost/date_time/time_resolution_traits.hpp> // absolute_value
+
 namespace boost {
 
 namespace posix_time {
@@ -49,27 +50,27 @@ namespace posix_time {
       if(td.is_negative()) {
         ss << '-';
       }
-      ss  << std::setw(2) << std::setfill('0') 
+      ss  << std::setw(2) << std::setfill('0')
           << date_time::absolute_value(td.hours()) << ":";
-      ss  << std::setw(2) << std::setfill('0') 
+      ss  << std::setw(2) << std::setfill('0')
           << date_time::absolute_value(td.minutes()) << ":";
-      ss  << std::setw(2) << std::setfill('0') 
+      ss  << std::setw(2) << std::setfill('0')
           << date_time::absolute_value(td.seconds());
       //TODO the following is totally non-generic, yelling FIXME
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
-      boost::int64_t frac_sec = 
+      boost::int64_t frac_sec =
         date_time::absolute_value(td.fractional_seconds());
       // JDG [7/6/02 VC++ compatibility]
       char buff[32];
       _i64toa(frac_sec, buff, 10);
 #else
-      time_duration::fractional_seconds_type frac_sec = 
+      time_duration::fractional_seconds_type frac_sec =
         date_time::absolute_value(td.fractional_seconds());
 #endif
       if (frac_sec != 0) {
         ss  << "." << std::setw(time_duration::num_fractional_digits())
             << std::setfill('0')
-          
+
           // JDG [7/6/02 VC++ compatibility]
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
             << buff;
@@ -81,12 +82,12 @@ namespace posix_time {
     return ss.str();
   }
 
-  //! Time duration in iso format -hhmmss,fffffff Example: 10:09:03,0123456
+  //! Time duration in ISO 8601 format -hhmmss.fffffff. Example: 10:09:03.0123456
   /*!\ingroup time_format
    */
-  inline 
-  std::string 
-  to_iso_string(time_duration td) 
+  inline
+  std::string
+  to_iso_string(time_duration td)
   {
     std::ostringstream ss;
     if(td.is_special()) {
@@ -112,27 +113,27 @@ namespace posix_time {
       if(td.is_negative()) {
         ss << '-';
       }
-      ss  << std::setw(2) << std::setfill('0') 
+      ss  << std::setw(2) << std::setfill('0')
           << date_time::absolute_value(td.hours());
-      ss  << std::setw(2) << std::setfill('0') 
+      ss  << std::setw(2) << std::setfill('0')
           << date_time::absolute_value(td.minutes());
-      ss  << std::setw(2) << std::setfill('0') 
+      ss  << std::setw(2) << std::setfill('0')
           << date_time::absolute_value(td.seconds());
       //TODO the following is totally non-generic, yelling FIXME
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
-      boost::int64_t frac_sec = 
+      boost::int64_t frac_sec =
         date_time::absolute_value(td.fractional_seconds());
       // JDG [7/6/02 VC++ compatibility]
       char buff[32];
       _i64toa(frac_sec, buff, 10);
 #else
-      time_duration::fractional_seconds_type frac_sec = 
+      time_duration::fractional_seconds_type frac_sec =
         date_time::absolute_value(td.fractional_seconds());
 #endif
       if (frac_sec != 0) {
         ss  << "." << std::setw(time_duration::num_fractional_digits())
             << std::setfill('0')
-          
+
           // JDG [7/6/02 VC++ compatibility]
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
             << buff;
@@ -147,9 +148,9 @@ namespace posix_time {
   //! Time to simple format CCYY-mmm-dd hh:mm:ss.fffffff
   /*!\ingroup time_format
    */
-  inline 
-  std::string 
-  to_simple_string(ptime t) 
+  inline
+  std::string
+  to_simple_string(ptime t)
   {
     std::string ts = gregorian::to_simple_string(t.date());// + " ";
     if(!t.time_of_day().is_special()) {
@@ -163,20 +164,20 @@ namespace posix_time {
   //! Convert to string of form [YYYY-mmm-DD HH:MM::SS.ffffff/YYYY-mmm-DD HH:MM::SS.fffffff]
   /*!\ingroup time_format
    */
-  inline 
-  std::string 
-  to_simple_string(time_period tp) 
+  inline
+  std::string
+  to_simple_string(time_period tp)
   {
     std::string d1(to_simple_string(tp.begin()));
     std::string d2(to_simple_string(tp.last()));
     return std::string("[" + d1 + "/" + d2 +"]");
   }
 
-  //! Convert iso short form YYYYMMDDTHHMMSS where T is the date-time separator
+  //! Convert ISO 8601 short form YYYYMMDDTHHMMSS where T is the date-time separator
   /*!\ingroup time_format
    */
-  inline 
-  std::string to_iso_string(ptime t) 
+  inline
+  std::string to_iso_string(ptime t)
   {
     std::string ts = gregorian::to_iso_string(t.date());// + "T";
     if(!t.time_of_day().is_special()) {
@@ -190,9 +191,9 @@ namespace posix_time {
   //! Convert to form YYYY-MM-DDTHH:MM:SS where T is the date-time separator
   /*!\ingroup time_format
    */
-  inline 
-  std::string 
-  to_iso_extended_string(ptime t) 
+  inline
+  std::string
+  to_iso_extended_string(ptime t)
   {
     std::string ts = gregorian::to_iso_extended_string(t.date());// + "T";
     if(!t.time_of_day().is_special()) {

include/boost/date_time/posix_time/time_parsers.hpp

@@ -35,6 +35,14 @@ namespace posix_time {
     return date_time::parse_iso_time<ptime>(s, 'T');
   }
 
+  inline ptime from_iso_extended_string(const std::string& s) {
+    if (s.size() == 10) { //assume we just have a date which is 10 chars
+      gregorian::date d = gregorian::from_simple_string(s);
+      return ptime( d );
+    }
+    return date_time::parse_delimited_time<ptime>(s, 'T');
+  }
+
 
 
 } } //namespace posix_time

include/boost/date_time/posix_time/time_serialize.hpp

@@ -11,19 +11,45 @@
 
 #include "boost/date_time/posix_time/posix_time.hpp"
 #include "boost/date_time/gregorian/greg_serialize.hpp"
-#include "boost/serialization/split_free.hpp"
+#include "boost/core/nvp.hpp"
+#include "boost/numeric/conversion/cast.hpp"
+#include "boost/type_traits/integral_constant.hpp"
 
-
-// macros to split serialize functions into save & load functions
-// NOTE: these macros define template functions in the boost::serialization namespace.
-// They must be expanded *outside* of any namespace
-BOOST_SERIALIZATION_SPLIT_FREE(boost::posix_time::ptime)
-BOOST_SERIALIZATION_SPLIT_FREE(boost::posix_time::time_duration)
-BOOST_SERIALIZATION_SPLIT_FREE(boost::posix_time::time_period)
+// Define versions for serialization compatibility
+// alows the unit tests to make an older version to check compatibility
+#ifndef BOOST_DATE_TIME_POSIX_TIME_DURATION_VERSION
+#define BOOST_DATE_TIME_POSIX_TIME_DURATION_VERSION 1
+#endif
 
 namespace boost {
 namespace serialization {
 
+template<typename T>
+struct version;
+
+template<>
+struct version<boost::posix_time::time_duration>
+  : integral_constant<int, BOOST_DATE_TIME_POSIX_TIME_DURATION_VERSION>
+{
+};
+
+// A macro to split serialize functions into save & load functions.
+// It is here to avoid dependency on Boost.Serialization just for the
+// BOOST_SERIALIZATION_SPLIT_FREE macro
+#define BOOST_DATE_TIME_SPLIT_FREE(T)                                         \
+template<class Archive>                                                       \
+inline void serialize(Archive & ar,                                           \
+                      T & t,                                                  \
+                      const unsigned int file_version)                        \
+{                                                                             \
+  split_free(ar, t, file_version);                                            \
+}
+
+BOOST_DATE_TIME_SPLIT_FREE(boost::posix_time::ptime)
+BOOST_DATE_TIME_SPLIT_FREE(boost::posix_time::time_duration)
+BOOST_DATE_TIME_SPLIT_FREE(boost::posix_time::time_period)
+
+#undef BOOST_DATE_TIME_SPLIT_FREE
 
 /*** time_duration ***/
 
@@ -32,10 +58,23 @@ namespace serialization {
  * types are hour_type, min_type, sec_type, and fractional_seconds_type
  * as defined in the time_duration class
  */
+template<class TimeResTraitsSize, class Archive>
+void save_td(Archive& ar, const posix_time::time_duration& td)
+{
+    TimeResTraitsSize h = boost::numeric_cast<TimeResTraitsSize>(td.hours());
+    TimeResTraitsSize m = boost::numeric_cast<TimeResTraitsSize>(td.minutes());
+    TimeResTraitsSize s = boost::numeric_cast<TimeResTraitsSize>(td.seconds());
+    posix_time::time_duration::fractional_seconds_type fs = td.fractional_seconds();
+    ar & make_nvp("time_duration_hours", h);
+    ar & make_nvp("time_duration_minutes", m);
+    ar & make_nvp("time_duration_seconds", s);
+    ar & make_nvp("time_duration_fractional_seconds", fs);
+}
+
 template<class Archive>
 void save(Archive & ar, 
           const posix_time::time_duration& td, 
-          unsigned int /*version*/)
+          unsigned int version)
 {
   // serialize a bool so we know how to read this back in later
   bool is_special = td.is_special();
@@ -45,14 +84,13 @@ void save(Archive & ar,
     ar & make_nvp("sv_time_duration", s);
   }
   else {
-    typename posix_time::time_duration::hour_type h = td.hours();
-    typename posix_time::time_duration::min_type m = td.minutes();
-    typename posix_time::time_duration::sec_type s = td.seconds();
-    typename posix_time::time_duration::fractional_seconds_type fs = td.fractional_seconds();
-    ar & make_nvp("time_duration_hours", h);
-    ar & make_nvp("time_duration_minutes", m);
-    ar & make_nvp("time_duration_seconds", s);
-    ar & make_nvp("time_duration_fractional_seconds", fs);
+    // Write support for earlier versions allows for upgrade compatibility testing
+    // See load comments for version information
+    if (version == 0) {
+        save_td<int32_t>(ar, td);
+    } else {
+        save_td<int64_t>(ar, td);
+    }
   }
 }
 
@@ -61,10 +99,24 @@ void save(Archive & ar,
  * types are hour_type, min_type, sec_type, and fractional_seconds_type
  * as defined in the time_duration class
  */
+template<class TimeResTraitsSize, class Archive>
+void load_td(Archive& ar, posix_time::time_duration& td)
+{
+    TimeResTraitsSize h(0);
+    TimeResTraitsSize m(0);
+    TimeResTraitsSize s(0);
+    posix_time::time_duration::fractional_seconds_type fs(0);
+    ar & make_nvp("time_duration_hours", h);
+    ar & make_nvp("time_duration_minutes", m);
+    ar & make_nvp("time_duration_seconds", s);
+    ar & make_nvp("time_duration_fractional_seconds", fs);
+    td = posix_time::time_duration(h, m, s, fs);
+}
+
 template<class Archive>
 void load(Archive & ar, 
           posix_time::time_duration & td, 
-          unsigned int /*version*/)
+          unsigned int version)
 {
   bool is_special = false;
   ar & make_nvp("is_special", is_special);
@@ -75,15 +127,25 @@ void load(Archive & ar,
     td = posix_time::time_duration(sv);
   }
   else {
-    typename posix_time::time_duration::hour_type h(0);
-    typename posix_time::time_duration::min_type m(0);
-    typename posix_time::time_duration::sec_type s(0);
-    typename posix_time::time_duration::fractional_seconds_type fs(0);
-    ar & make_nvp("time_duration_hours", h);
-    ar & make_nvp("time_duration_minutes", m);
-    ar & make_nvp("time_duration_seconds", s);
-    ar & make_nvp("time_duration_fractional_seconds", fs);
-    td = posix_time::time_duration(h,m,s,fs);
+    // Version "0"   (Boost 1.65.1 or earlier, which used int32_t for day/hour/minute/second and
+    //                therefore suffered from the year 2038 issue.)
+    // Version "0.5" (Boost 1.66.0 changed to std::time_t but did not increase the version;
+    //                it was missed in the original change, all code reviews, and there were no
+    //                static assertions to protect the code; further std::time_t can be 32-bit
+    //                or 64-bit so it reduced portability.  This makes 1.66.0 hard to handle...)
+    // Version "1"   (Boost 1.67.0 or later uses int64_t and is properly versioned)
+
+    // If the size of any of these items changes, a new version is needed.
+    BOOST_STATIC_ASSERT(sizeof(posix_time::time_duration::hour_type) == sizeof(boost::int64_t));
+    BOOST_STATIC_ASSERT(sizeof(posix_time::time_duration::min_type) == sizeof(boost::int64_t));
+    BOOST_STATIC_ASSERT(sizeof(posix_time::time_duration::sec_type) == sizeof(boost::int64_t));
+    BOOST_STATIC_ASSERT(sizeof(posix_time::time_duration::fractional_seconds_type) == sizeof(boost::int64_t));
+
+    if (version == 0) {
+        load_td<int32_t>(ar, td);
+    } else {
+        load_td<int64_t>(ar, td);
+    }
   }
 }
 
@@ -103,10 +165,10 @@ void save(Archive & ar,
 {
   // from_iso_string does not include fractional seconds
   // therefore date and time_duration are used
-  typename posix_time::ptime::date_type d = pt.date();
+  posix_time::ptime::date_type d = pt.date();
   ar & make_nvp("ptime_date", d);
   if(!pt.is_special()) {
-    typename posix_time::ptime::time_duration_type td = pt.time_of_day();
+    posix_time::ptime::time_duration_type td = pt.time_of_day();
     ar & make_nvp("ptime_time_duration", td);
   }
 }
@@ -122,8 +184,8 @@ void load(Archive & ar,
 {
   // from_iso_string does not include fractional seconds
   // therefore date and time_duration are used
-  typename posix_time::ptime::date_type d(posix_time::not_a_date_time);
-  typename posix_time::ptime::time_duration_type td;
+  posix_time::ptime::date_type d(posix_time::not_a_date_time);
+  posix_time::ptime::time_duration_type td;
   ar & make_nvp("ptime_date", d);
   if(!d.is_special()) {
     ar & make_nvp("ptime_time_duration", td);
@@ -137,7 +199,7 @@ void load(Archive & ar,
 
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 posix_time::ptime* pt, 
                                 const unsigned int /*file_version*/)
 {
@@ -183,7 +245,7 @@ void load(Archive & ar,
 
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 boost::posix_time::time_period* tp, 
                                 const unsigned int /*file_version*/)
 {

include/boost/date_time/special_values_formatter.hpp

@@ -12,6 +12,7 @@
 
 #include <vector>
 #include <string>
+#include <iterator>
 #include "boost/date_time/special_defs.hpp"
 
 namespace boost { namespace date_time {

include/boost/date_time/special_values_parser.hpp

@@ -34,14 +34,9 @@ namespace boost { namespace date_time {
   {
    public:
     typedef std::basic_string<charT>        string_type;
-    //typedef std::basic_stringstream<charT>  stringstream_type;
+    typedef std::basic_stringstream<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;
-    //typedef typename date_type::month_type month_type;
     typedef typename date_type::duration_type duration_type;
-    //typedef typename date_type::day_of_week_type day_of_week_type;
-    //typedef typename date_type::day_type day_type;
     typedef string_parse_tree<charT> parse_tree_type;
     typedef typename parse_tree_type::parse_match_result_type match_results;
     typedef std::vector<std::basic_string<charT> > collection_type;
@@ -80,11 +75,6 @@ namespace boost { namespace date_time {
       m_sv_strings = parse_tree_type(phrases, static_cast<int>(not_a_date_time));
     }
 
-    special_values_parser(const special_values_parser<date_type,charT>& svp)
-    {
-      this->m_sv_strings = svp.m_sv_strings;
-    }
-
     //! Replace special value strings
     void sv_strings(const string_type& nadt_str,
                     const string_type& neg_inf_str,
@@ -101,11 +91,37 @@ namespace boost { namespace date_time {
       m_sv_strings = parse_tree_type(phrases, static_cast<int>(not_a_date_time));
     }
 
-    /* Does not return a special_value because if the parsing fails, 
-     * the return value will always be not_a_date_time 
-     * (mr.current_match retains its default value of -1 on a failed 
-     * parse and that casts to not_a_date_time). */
-    //! Sets match_results.current_match to the corresponding special_value or -1
+    //! The parser is expensive to create, and not thread-safe so it cannot be static
+    //! therefore given a string, determine if it is likely to be a special value.
+    //! A negative response is a definite no, whereas a positive is only likely and
+    //! match() should be called and return value checked.
+    //! \param[in]  str  the string to check
+    //! \returns  false if it is definitely not a special value
+    static bool should_call_match(const string_type& str)
+    {
+        if (!str.empty()) {
+            switch (str[0]) {
+                // See string definitions at the end of this class..
+                case '+':
+                case '-':
+                case 'n':
+                case 'm':
+                    return true;
+
+                default:
+                    break;
+            }
+        }
+
+        return false;
+    }
+
+    //! Given an input iterator, attempt to match it to a known special value
+    //! \param[in]  sitr  the start iterator
+    //! \param[in]  str_end  the end iterator
+    //! \param[out]  mr  the match result:
+    //!                  mr.current_match is set to the corresponding special_value or -1
+    //! \returns  whether something matched
     bool match(stream_itr_type& sitr, 
                         stream_itr_type& str_end,
                         match_results& mr) const
@@ -114,18 +130,6 @@ namespace boost { namespace date_time {
       m_sv_strings.match(sitr, str_end, mr, level);
       return (mr.current_match != match_results::PARSE_ERROR);
     }
-    /*special_values match(stream_itr_type& sitr, 
-                        stream_itr_type& str_end,
-                        match_results& mr) const
-    {
-      unsigned int level = 0;
-      m_sv_strings.match(sitr, str_end, mr, level);
-      if(mr.current_match == match_results::PARSE_ERROR) {
-        throw std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'");
-      }
-      return static_cast<special_values>(mr.current_match);
-    }*/
-                     
 
    private:
     parse_tree_type m_sv_strings;

include/boost/date_time/string_convert.hpp

@@ -21,7 +21,6 @@ namespace date_time {
   inline
   std::basic_string<OutputT> convert_string_type(const std::basic_string<InputT>& inp_str)
   {
-    typedef std::basic_string<InputT> input_type;
     typedef std::basic_string<OutputT> output_type;
     output_type result;
     result.insert(result.begin(), inp_str.begin(), inp_str.end());