#ifdef _WIN32

// windows.h will be included directly and indirectly (e.g. by curl).

// We need to define these macros to prevent windows.h bringing in

// more than we need and do it early so windows.h doesn't get included

// without these macros having been defined.

// min/max macros interfere with the C++ versions.

# ifndef NOMINMAX

# define NOMINMAX

# endif

// We don't need all that Windows has to offer.

# ifndef WIN32_LEAN_AND_MEAN

# define WIN32_LEAN_AND_MEAN

# endif

// for wcstombs

# ifndef _CRT_SECURE_NO_WARNINGS

# define _CRT_SECURE_NO_WARNINGS

# endif

// None of this happens with the MS SDK (at least VS14 which I tested), but:

// Compiling with mingw, we get "error: 'KF_FLAG_DEFAULT' was not declared in this scope."

// and error: 'SHGetKnownFolderPath' was not declared in this scope.".

// It seems when using mingw NTDDI_VERSION is undefined and that

// causes KNOWN_FOLDER_FLAG and the KF_ flags to not get defined.

// So we must define NTDDI_VERSION to get those flags on mingw.

// The docs say though here:

// https://msdn.microsoft.com/en-nz/library/windows/desktop/aa383745(v=vs.85).aspx

// that "If you define NTDDI_VERSION, you must also define _WIN32_WINNT."

// So we declare we require Vista or greater.

# ifdef __MINGW32__

# ifndef NTDDI_VERSION

# define NTDDI_VERSION 0x06000000

# define _WIN32_WINNT _WIN32_WINNT_VISTA

# elif NTDDI_VERSION < 0x06000000

# warning "If this fails to compile NTDDI_VERSION may be to low. See comments above."

# endif

// But once we define the values above we then get this linker error:

// "tz.cpp:(.rdata$.refptr.FOLDERID_Downloads[.refptr.FOLDERID_Downloads]+0x0): "

// "undefined reference to `FOLDERID_Downloads'"

// which #include <initguid.h> cures see:

// https://support.microsoft.com/en-us/kb/130869

# include <initguid.h>

// But with <initguid.h> included, the error moves on to:

// error: 'FOLDERID_Downloads' was not declared in this scope

// Which #include <knownfolders.h> cures.

# include <knownfolders.h>

# endif // __MINGW32__

# include <windows.h>

#endif // _WIN32

#include "date/tz_private.h"

#ifdef __APPLE__

# include "date/ios.h"

#else

# define TARGET_OS_IPHONE 0

# define TARGET_OS_SIMULATOR 0

#endif

#if defined(ANDROID) || defined(__ANDROID__)

#include <sys/system_properties.h>

#endif

#if USE_OS_TZDB

# include <dirent.h>

#endif

#include <algorithm>

#include <cctype>

#include <cstdlib>

#include <cstring>

#include <cwchar>

#include <exception>

#include <fstream>

#include <iostream>

#include <iterator>

#include <memory>

#if USE_OS_TZDB

# include <queue>

#endif

#include <sstream>

#include <string>

#include <tuple>

#include <vector>

#include <sys/stat.h>

#ifdef _WIN32

# ifdef WINAPI_FAMILY

# include <winapifamily.h>

# if WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP

# define WINRT

# define INSTALL .

# endif

# endif

# include <io.h> // _unlink etc.

# if defined(__clang__)

struct IUnknown; // fix for issue with static_cast<> in objbase.h

// (see https://github.com/philsquared/Catch/issues/690)

# endif

# include <shlobj.h> // CoTaskFree, ShGetKnownFolderPath etc.

# if HAS_REMOTE_API

# include <direct.h> // _mkdir

# include <shellapi.h> // ShFileOperation etc.

# endif // HAS_REMOTE_API

#else // !_WIN32

# include <unistd.h>

# if !USE_OS_TZDB && !defined(INSTALL)

# include <wordexp.h>

# endif

# include <limits.h>

# include <string.h>

# if !USE_SHELL_API

# include <sys/stat.h>

# include <sys/fcntl.h>

# include <dirent.h>

# include <cstring>

# include <sys/wait.h>

# include <sys/types.h>

# endif //!USE_SHELL_API

#endif // !_WIN32

#if HAS_REMOTE_API

// Note curl includes windows.h so we must include curl AFTER definitions of things

// that affect windows.h such as NOMINMAX.

#if defined(_MSC_VER) && defined(SHORTENED_CURL_INCLUDE)

// For rmt_curl nuget package

# include <curl.h>

#else

# include <curl/curl.h>

#endif

#endif

#ifdef _WIN32

static CONSTDATA char folder_delimiter = '\\';

#else // !_WIN32

static CONSTDATA char folder_delimiter = '/';

#endif // !_WIN32

#if defined(__GNUC__) && __GNUC__ < 5

// GCC 4.9 Bug 61489 Wrong warning with -Wmissing-field-initializers

# pragma GCC diagnostic push

# pragma GCC diagnostic ignored "-Wmissing-field-initializers"

#endif // defined(__GNUC__) && __GNUC__ < 5

#if !USE_OS_TZDB

# ifdef _WIN32

# ifndef WINRT

{

struct task_mem_deleter

};

using co_task_mem_ptr = std::unique_ptr<wchar_t[], task_mem_deleter>;

}

std::wstring

convert_utf8_to_utf16(const std::string& s)

}

std::string

get_known_folder(const GUID& folderid)

}

# ifndef INSTALL

std::string

get_download_folder()

{

return get_known_folder(FOLDERID_Downloads);

}

# endif // !INSTALL

# endif // WINRT

# else // !_WIN32

# if !defined(INSTALL)

std::string

expand_path(std::string path)

}

std::string

get_download_folder()

{

return expand_path("~/Downloads");

}

# endif // !defined(INSTALL)

# endif // !_WIN32

class file_streambuf

};

#endif // !USE_OS_TZDB

namespace date

{

using namespace detail;

#if !USE_OS_TZDB

std::string&

access_install()

{

static std::string install

#ifndef INSTALL

= get_download_folder() + folder_delimiter + "tzdata";

#else // !INSTALL

# define STRINGIZEIMP(x) #x

# define STRINGIZE(x) STRINGIZEIMP(x)

= STRINGIZE(INSTALL) + std::string(1, folder_delimiter) + "tzdata";

#undef STRINGIZEIMP

#undef STRINGIZE

#endif // !INSTALL

return install;

}

set_install(const std::string& install)

{

access_install() = install;

}

const std::string&

get_install()

{

static const std::string& ref = access_install();

return ref;

}

#if HAS_REMOTE_API

std::string

get_download_gz_file(const std::string& version)

}

#endif // HAS_REMOTE_API

#endif // !USE_OS_TZDB

CONSTDATA auto min_year = date::year::min();

CONSTDATA auto max_year = date::year::max();

CONSTDATA auto min_day = date::January/1;

CONSTDATA auto max_day = date::December/31;

#if USE_OS_TZDB

CONSTCD14 const sys_seconds min_seconds = sys_days(min_year/min_day);

#endif // USE_OS_TZDB

#ifndef _WIN32

std::string

discover_tz_dir()

}

const std::string&

get_tz_dir()

{

static const std::string tz_dir = discover_tz_dir();

return tz_dir;

}

#endif

#ifndef _MSC_VER

static_assert(min_year <= max_year, "Configuration error");

#endif

static std::unique_ptr<tzdb> init_tzdb();

tzdb_list::~tzdb_list()

{

const tzdb* ptr = head_;

head_ = nullptr;

while (ptr != nullptr)

{

auto next = ptr->next;

delete ptr;

ptr = next;

}

}

tzdb_list::tzdb_list(tzdb_list&& x) NOEXCEPT

: head_{x.head_.exchange(nullptr)}

{

}

tzdb_list::push_front(tzdb* tzdb) NOEXCEPT

}

tzdb_list::const_iterator

tzdb_list::erase_after(const_iterator p) NOEXCEPT

}

struct tzdb_list::undocumented_helper

{

static void push_front(tzdb_list& db_list, tzdb* tzdb) NOEXCEPT

{

db_list.push_front(tzdb);

}

};

tzdb_list

create_tzdb()

}

tzdb_list&

get_tzdb_list()

{

static tzdb_list tz_db = create_tzdb();

return tz_db;

}

tolower(char c)

{

return static_cast<char>(std::tolower(c));

}

tolower(std::string& s)

}

std::string

get_alpha_word(std::istream& in)

}

is_prefix_of(std::string const& key, std::string const& value)

{

return key.compare(0, key.size(), value, 0, key.size()) == 0;

}

parse_month(std::istream& in)

}

#if !USE_OS_TZDB

#ifdef _WIN32

sort_zone_mappings(std::vector<date::detail::timezone_mapping>& mappings)

}

native_to_standard_timezone_name(const std::string& native_tz_name,

}

std::vector<detail::timezone_mapping>

load_timezone_mappings_from_xml_file(const std::string& input_path)

}

#endif // _WIN32

parse_dow(std::istream& in)

}

std::chrono::seconds

parse_unsigned_time(std::istream& in)

}

std::chrono::seconds

parse_signed_time(std::istream& in)

}

detail::MonthDayTime::MonthDayTime(local_seconds tp, tz timezone)

: zone_(timezone)

{

using namespace date;

const auto dp = date::floor<days>(tp);

const auto hms = make_time(tp - dp);

const auto ymd = year_month_day(dp);

u = ymd.month() / ymd.day();

h_ = hms.hours();

m_ = hms.minutes();

s_ = hms.seconds();

}

detail::MonthDayTime::MonthDayTime(const date::month_day& md, tz timezone)

: zone_(timezone)

{

u = md;

}

date::day

detail::MonthDayTime::day() const

{

switch (type_)

{

case month_day:

return u.month_day_.day();

case month_last_dow:

return date::day{31};

case lteq:

case gteq:

break;

}

return u.month_day_weekday_.month_day_.day();

}

date::month

detail::MonthDayTime::month() const

{

switch (type_)

{

case month_day:

return u.month_day_.month();

case month_last_dow:

return u.month_weekday_last_.month();

case lteq:

case gteq:

break;

}

return u.month_day_weekday_.month_day_.month();

}

detail::MonthDayTime::compare(date::year y, const MonthDayTime& x, date::year yx,

std::chrono::seconds offset, std::chrono::minutes prev_save) const

{

if (zone_ != x.zone_)

{

auto dp0 = to_sys_days(y);

auto dp1 = x.to_sys_days(yx);

if (std::abs((dp0-dp1).count()) > 1)

return dp0 < dp1 ? -1 : 1;

if (zone_ == tz::local)

{

auto tp0 = to_time_point(y) - prev_save;

if (x.zone_ == tz::utc)

tp0 -= offset;

auto tp1 = x.to_time_point(yx);

return tp0 < tp1 ? -1 : tp0 == tp1 ? 0 : 1;

}

else if (zone_ == tz::standard)

{

auto tp0 = to_time_point(y);

auto tp1 = x.to_time_point(yx);

if (x.zone_ == tz::local)

tp1 -= prev_save;

else

tp0 -= offset;

return tp0 < tp1 ? -1 : tp0 == tp1 ? 0 : 1;

}

// zone_ == tz::utc

auto tp0 = to_time_point(y);

auto tp1 = x.to_time_point(yx);

if (x.zone_ == tz::local)

tp1 -= offset + prev_save;

else

tp1 -= offset;

return tp0 < tp1 ? -1 : tp0 == tp1 ? 0 : 1;

}

auto const t0 = to_time_point(y);

auto const t1 = x.to_time_point(yx);

return t0 < t1 ? -1 : t0 == t1 ? 0 : 1;

}

sys_seconds