Added the ability to parse years back to 1601 to support the NT epoch.

BillyONeal · BillyONeal · commit a3da3e9fe386 · 2021-01-25T20:51:18.000-08:00
diff --git a/Release/include/cpprest/asyncrt_utils.h b/Release/include/cpprest/asyncrt_utils.h
@@ -628,6 +628,8 @@ class datetime
     /// </summary>
     interval_type to_interval() const { return m_interval; }
 
+    static datetime from_interval(interval_type interval) { return datetime(interval); }
+
     datetime operator-(interval_type value) const { return datetime(m_interval - value); }
 
     datetime operator+(interval_type value) const { return datetime(m_interval + value); }
diff --git a/Release/src/utilities/asyncrt_utils.cpp b/Release/src/utilities/asyncrt_utils.cpp
@@ -620,14 +620,12 @@ utf16string __cdecl conversions::to_utf16string(const std::string& value) { retu
 
 static const int64_t NtToUnixOffsetSeconds = 11644473600; // diff between windows and unix epochs (seconds)
 
-static bool year_is_leap_year_1601(int year)
+static bool year_is_leap_year_1601(int yearsSince1601)
 {
-    int decimal_year = year + 1601;
-    return (decimal_year % 4 == 0 && (decimal_year % 100 != 0 || decimal_year % 400 == 0));
+    int decimalYear = yearsSince1601 + 1601;
+    return (decimalYear % 4 == 0 && (decimalYear % 100 != 0 || decimalYear % 400 == 0));
 }
 
-static bool year_is_leap_year(int year) { return year_is_leap_year_1601(year + 299); }
-
 static const int SecondsInMinute = 60;
 static const int SecondsInHour = SecondsInMinute * 60;
 static const int SecondsInDay = SecondsInHour * 24;
@@ -641,9 +639,6 @@ static const int SecondsInYear = SecondsInDay * DaysInYear;
 static const int SecondsIn4Years = SecondsInDay * DaysIn4Years;
 static const int64_t SecondsIn100Years = static_cast<int64_t>(SecondsInDay) * DaysIn100Years;
 static const int64_t SecondsIn400Years = static_cast<int64_t>(SecondsInDay) * DaysIn400Years;
-static const int64_t SecondsFrom1900To2001 = INT64_C(3187296000);
-
-static const int64_t NtTo1900OffsetInterval = INT64_C(0x014F373BFDE04000);
 
 static int count_leap_years_1601(int yearsSince1601)
 {
@@ -660,12 +655,6 @@ static int count_leap_years_1601(int yearsSince1601)
     return result;
 }
 
-static int count_leap_years(const int yearsSince1900)
-{
-    // shift into 1601, the first 400 year cycle including 1900, then subtract leap years from 1601->1900
-    return count_leap_years_1601(yearsSince1900 + 299) - 72;
-}
-
 // The following table assumes no leap year; leap year is added separately
 static const unsigned short cumulative_days_to_month[12] = {
     0,   // Jan
@@ -749,23 +738,37 @@ static compute_year_result compute_year_1601(int64_t secondsSince1601)
     return {year400 * 400 + year100 * 100 + year4 * 4 + year1, secondsInt};
 }
 
-static const int64_t secondsFrom1601To1900 = INT64_C(9435484800);
-static compute_year_result compute_year(int64_t secondsSince1900)
-{
-    // shift to start of this 400 year cycle
-    auto partialResult = compute_year_1601(secondsSince1900 + secondsFrom1601To1900);
-    // shift back to 1900
-    return {partialResult.year - 299, partialResult.secondsLeftThisYear};
-}
+// The constant below was calculated by running the following test program on a Windows machine:
+// #include <windows.h>
+// #include <stdio.h>
+
+// int main() {
+//     SYSTEMTIME st;
+//     st.wYear = 9999;
+//     st.wMonth = 12;
+//     st.wDayOfWeek = 5;
+//     st.wDay = 31;
+//     st.wHour = 23;
+//     st.wMinute = 59;
+//     st.wSecond = 59;
+//     st.wMilliseconds = 999;
+
+//     unsigned long long ft;
+//     if (SystemTimeToFileTime(&st, reinterpret_cast<FILETIME*>(&ft))) {
+//         printf("0x%016llX\n", ft);
+//     } else {
+//         puts("failed!");
+//     }
+// }
 
 utility::string_t datetime::to_string(date_format format) const
 {
-    if (m_interval > INT64_C(2650467743990000000))
+    const int64_t interval = static_cast<int64_t>(m_interval);
+    if (interval > INT64_C(0x24C85A5ED1C018F0))
     {
         throw std::out_of_range("The requested year exceeds the year 9999.");
     }
 
-    const int64_t interval = static_cast<int64_t>(m_interval);
     const int64_t secondsSince1601 = interval / _secondTicks; // convert to seconds
     const int fracSec = static_cast<int>(interval % _secondTicks);
 
@@ -899,12 +902,12 @@ static const unsigned char max_days_in_month[12] = {
     31  // Dec
 };
 
-static bool validate_day_month(int day, int month, int year)
+static bool validate_day_month_1601(int day, int month, int year)
 {
     int maxDaysThisMonth;
     if (month == 1)
     { // Feb needs leap year testing
-        maxDaysThisMonth = 28 + year_is_leap_year(year);
+        maxDaysThisMonth = 28 + year_is_leap_year_1601(year);
     }
     else
     {
@@ -914,9 +917,9 @@ static bool validate_day_month(int day, int month, int year)
     return day >= 1 && day <= maxDaysThisMonth;
 }
 
-static int get_year_day(int month, int monthDay, int year)
+static int get_year_day_1601(int month, int monthDay, int year)
 {
-    return cumulative_days_to_month[month] + monthDay + (year_is_leap_year(year) && month > 1) - 1;
+    return cumulative_days_to_month[month] + monthDay + (year_is_leap_year_1601(year) && month > 1) - 1;
 }
 
 template<class CharT>
@@ -1009,7 +1012,7 @@ datetime __cdecl datetime::from_string(const utility::string_t& dateString, date
 datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& dateString, date_format format)
 {
     datetime result = datetime::maximum();
-    int64_t secondsSince1900;
+    int64_t secondsSince1601;
     uint64_t fracSec = 0;
     auto str = dateString.c_str();
     if (format == RFC_1123)
@@ -1076,19 +1079,21 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da
 
         int year = (str[0] - _XPLATSTR('0')) * 1000 + (str[1] - _XPLATSTR('0')) * 100 + (str[2] - _XPLATSTR('0')) * 10 +
                    (str[3] - _XPLATSTR('0'));
-        if (year < 1900)
+        if (year < 1601)
         {
             return result;
         }
 
+        year -= 1601;
+
         // days in month validity check
-        if (!validate_day_month(monthDay, month, year))
+        if (!validate_day_month_1601(monthDay, month, year))
         {
             return result;
         }
 
         str += 5; // parsed year
-        const int yearDay = get_year_day(month, monthDay, year);
+        const int yearDay = get_year_day_1601(month, monthDay, year);
 
         if (!ascii_isdigit2(str[0]) || !ascii_isdigit(str[1]) || str[2] != _XPLATSTR(':') || !ascii_isdigit5(str[3]) ||
             !ascii_isdigit(str[4]))
@@ -1132,21 +1137,20 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da
             return result;
         }
 
-        year -= 1900;
-        int daysSince1900 = year * DaysInYear + count_leap_years(year) + yearDay;
+        int daysSince1601 = year * DaysInYear + count_leap_years_1601(year) + yearDay;
 
         if (parsedWeekday != 7)
         {
-            const int actualWeekday = (daysSince1900 + 1) % 7;
+            const int actualWeekday = (daysSince1601 + 1) % 7;
 
             if (parsedWeekday != actualWeekday)
             {
                 return result;
             }
         }
 
-        secondsSince1900 =
-            static_cast<int64_t>(daysSince1900) * SecondsInDay + hour * SecondsInHour + minute * SecondsInMinute + sec;
+        secondsSince1601 =
+            static_cast<int64_t>(daysSince1601) * SecondsInDay + hour * SecondsInHour + minute * SecondsInMinute + sec;
 
         if (!string_starts_with(str, "GMT") && !string_starts_with(str, "UT"))
         {
@@ -1186,8 +1190,8 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da
                 return result;
             }
 
-            secondsSince1900 = timezone_adjust(secondsSince1900, static_cast<unsigned char>(tzCh), tzHours, tzMinutes);
-            if (secondsSince1900 < 0)
+            secondsSince1601 = timezone_adjust(secondsSince1601, static_cast<unsigned char>(tzCh), tzHours, tzMinutes);
+            if (secondsSince1601 < 0)
             {
                 return result;
             }
@@ -1203,11 +1207,13 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da
 
         int year = (str[0] - _XPLATSTR('0')) * 1000 + (str[1] - _XPLATSTR('0')) * 100 + (str[2] - _XPLATSTR('0')) * 10 +
                    (str[3] - _XPLATSTR('0'));
-        if (year < 1900)
+        if (year < 1601)
         {
             return result;
         }
 
+        year -= 1601;
+
         str += 4;
         if (*str == _XPLATSTR('-'))
         {
@@ -1241,24 +1247,22 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da
         }
 
         int monthDay = atoi2(str);
-        if (!validate_day_month(monthDay, month, year))
+        if (!validate_day_month_1601(monthDay, month, year))
         {
             return result;
         }
 
-        const int yearDay = get_year_day(month, monthDay, year);
+        const int yearDay = get_year_day_1601(month, monthDay, year);
 
         str += 2;
-        year -= 1900;
-        int daysSince1900 = year * DaysInYear + count_leap_years(year) + yearDay;
+        int daysSince1601 = year * DaysInYear + count_leap_years_1601(year) + yearDay;
 
         if (str[0] != _XPLATSTR('T') && str[0] != _XPLATSTR('t'))
         {
             // No time
-            secondsSince1900 = static_cast<int64_t>(daysSince1900) * SecondsInDay;
+            secondsSince1601 = static_cast<int64_t>(daysSince1601) * SecondsInDay;
 
-            result.m_interval =
-                static_cast<interval_type>(secondsSince1900 * _secondTicks + fracSec + NtTo1900OffsetInterval);
+            result.m_interval = static_cast<interval_type>(secondsSince1601 * _secondTicks + fracSec);
             return result;
         }
 
@@ -1347,8 +1351,8 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da
             }
         }
 
-        secondsSince1900 =
-            static_cast<int64_t>(daysSince1900) * SecondsInDay + hour * SecondsInHour + minute * SecondsInMinute + sec;
+        secondsSince1601 =
+            static_cast<int64_t>(daysSince1601) * SecondsInDay + hour * SecondsInHour + minute * SecondsInMinute + sec;
 
         if (str[0] == _XPLATSTR('Z') || str[0] == _XPLATSTR('z'))
         {
@@ -1363,8 +1367,8 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da
                 return result;
             }
 
-            secondsSince1900 = timezone_adjust(secondsSince1900, offsetDirection, atoi2(str + 1), atoi2(str + 4));
-            if (secondsSince1900 < 0)
+            secondsSince1601 = timezone_adjust(secondsSince1601, offsetDirection, atoi2(str + 1), atoi2(str + 4));
+            if (secondsSince1601 < 0)
             {
                 return result;
             }
@@ -1379,7 +1383,7 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da
         throw std::invalid_argument("unrecognized date format");
     }
 
-    result.m_interval = static_cast<interval_type>(secondsSince1900 * _secondTicks + fracSec + NtTo1900OffsetInterval);
+    result.m_interval = static_cast<interval_type>(secondsSince1601 * _secondTicks + fracSec);
     return result;
 }
 
diff --git a/Release/tests/functional/utils/datetime.cpp b/Release/tests/functional/utils/datetime.cpp
@@ -138,6 +138,14 @@ SUITE(datetime)
 
     TEST(parsing_time_roundtrip_year_2021) { TestDateTimeRoundtrip(_XPLATSTR("2021-01-01T20:59:59Z")); }
 
+    TEST(parsing_time_roundtrip_year_1601) { TestDateTimeRoundtrip(_XPLATSTR("1601-01-01T00:00:00Z")); }
+
+    TEST(parsing_time_roundtrip_year_1602) { TestDateTimeRoundtrip(_XPLATSTR("1602-01-01T00:00:00Z")); }
+
+    TEST(parsing_time_roundtrip_year_1603) { TestDateTimeRoundtrip(_XPLATSTR("1603-01-01T00:00:00Z")); }
+
+    TEST(parsing_time_roundtrip_year_1604) { TestDateTimeRoundtrip(_XPLATSTR("1604-01-01T00:00:00Z")); }
+
     TEST(emitting_time_correct_day)
     {
         const auto test = utility::datetime() + UINT64_C(132004507640000000); // 2019-04-22T23:52:44 is a Monday
@@ -287,7 +295,7 @@ SUITE(datetime)
             _XPLATSTR("Thu, 01 Jan 1970 00:00:00 G"),
             _XPLATSTR("Thu, 01 Jan 1970 00:00:00 GM"),
             _XPLATSTR("Fri, 01 Jan 1970 00:00:00 GMT"), // wrong day
-            _XPLATSTR("01 Jan 1899 00:00:00 GMT"),      // year too small
+            _XPLATSTR("01 Jan 1600 00:00:00 GMT"),      // year too small
             _XPLATSTR("01 Xxx 1971 00:00:00 GMT"),      // month bad
             _XPLATSTR("00 Jan 1971 00:00:00 GMT"),      // day too small
             _XPLATSTR("32 Jan 1971 00:00:00 GMT"),      // day too big
@@ -308,7 +316,7 @@ SUITE(datetime)
             _XPLATSTR("01 Jan 1971 00:60:00 GMT"), // minute too big
             _XPLATSTR("01 Jan 1971 00:00:70 GMT"), // second too big
             _XPLATSTR("01 Jan 1971 00:00:61 GMT"),
-            _XPLATSTR("01 Jan 1899 00:00:00 GMT"),   // underflow
+            _XPLATSTR("01 Jan 1600 00:00:00 GMT"),   // underflow
             _XPLATSTR("01 Jan 1969 00:00:00 CEST"),  // bad tz
             _XPLATSTR("14 Jan 2019 23:16:21 G0100"), // bad tzoffsets
             _XPLATSTR("01 Jan 1970 00:00:00 +2400"),
@@ -454,7 +462,7 @@ SUITE(datetime)
             _XPLATSTR("1970-01-01T00:00:"),
             _XPLATSTR("1970-01-01T00:00:0"),
             // _XPLATSTR("1970-01-01T00:00:00"), // accepted as invalid timezone above
-            _XPLATSTR("1899-01-01T00:00:00Z"), // year too small
+            _XPLATSTR("1600-01-01T00:00:00Z"), // year too small
             _XPLATSTR("1971-00-01T00:00:00Z"), // month too small
             _XPLATSTR("1971-20-01T00:00:00Z"), // month too big
             _XPLATSTR("1971-13-01T00:00:00Z"),
@@ -477,8 +485,8 @@ SUITE(datetime)
             _XPLATSTR("1971-01-01T00:60:00Z"), // minute too big
             _XPLATSTR("1971-01-01T00:00:70Z"), // second too big
             _XPLATSTR("1971-01-01T00:00:61Z"),
-            _XPLATSTR("1899-01-01T00:00:00Z"),      // underflow
-            _XPLATSTR("1900-01-01T00:00:00+00:01"), // time zone underflow
+            _XPLATSTR("1600-01-01T00:00:00Z"),      // underflow
+            _XPLATSTR("1601-01-01T00:00:00+00:01"), // time zone underflow
             // _XPLATSTR("1970-01-01T00:00:00.Z"), // accepted as invalid timezone above
             _XPLATSTR("1970-01-01T00:00:00+24:00"), // bad tzoffsets
             _XPLATSTR("1970-01-01T00:00:00-30:00"),
@@ -508,6 +516,39 @@ SUITE(datetime)
         auto result = utility::datetime {}.to_string(utility::datetime::ISO_8601);
         VERIFY_ARE_EQUAL(_XPLATSTR("1601-01-01T00:00:00Z"), result);
     }
+
+    TEST(can_emit_year_9999_rfc_1123)
+    {
+        auto result =
+            utility::datetime::from_interval(INT64_C(0x24C85A5ED1C018F0)).to_string(utility::datetime::RFC_1123);
+        VERIFY_ARE_EQUAL(_XPLATSTR("Fri, 31 Dec 9999 23:59:59 GMT"), result);
+    }
+
+    TEST(can_emit_year_9999_iso_8601)
+    {
+        auto result =
+            utility::datetime::from_interval(INT64_C(0x24C85A5ED1C018F0)).to_string(utility::datetime::ISO_8601);
+        VERIFY_ARE_EQUAL(_XPLATSTR("9999-12-31T23:59:59.999Z"), result);
+    }
+
+    TEST(can_parse_nt_epoch_zero_rfc_1123)
+    {
+        auto dt =
+            utility::datetime::from_string(_XPLATSTR("Mon, 01 Jan 1601 00:00:00 GMT"), utility::datetime::RFC_1123);
+        VERIFY_ARE_EQUAL(0U, dt.to_interval());
+        auto dt_me = utility::datetime::from_string_maximum_error(_XPLATSTR("Mon, 01 Jan 1601 00:00:00 GMT"),
+                                                                  utility::datetime::RFC_1123);
+        VERIFY_ARE_EQUAL(0U, dt_me.to_interval());
+    }
+
+    TEST(can_parse_nt_epoch_zero_iso_8601)
+    {
+        auto dt = utility::datetime::from_string(_XPLATSTR("1601-01-01T00:00:00Z"), utility::datetime::ISO_8601);
+        VERIFY_ARE_EQUAL(0U, dt.to_interval());
+        auto dt_me = utility::datetime::from_string_maximum_error(_XPLATSTR("1601-01-01T00:00:00Z"),
+                                                                  utility::datetime::ISO_8601);
+        VERIFY_ARE_EQUAL(0U, dt_me.to_interval());
+    }
 } // SUITE(datetime)
 
 } // namespace utils_tests

Original file line number	Diff line number	Diff line change
`@@ -620,14 +620,12 @@ utf16string __cdecl conversions::to_utf16string(const std::string& value) { retu`
`620`	`620`
`621`	`621`	`static const int64_t NtToUnixOffsetSeconds = 11644473600; // diff between windows and unix epochs (seconds)`
`622`	`622`
`623`		`-static bool year_is_leap_year_1601(int year)`
	`623`	`+static bool year_is_leap_year_1601(int yearsSince1601)`
`624`	`624`	`{`
`625`		`- int decimal_year = year + 1601;`
`626`		`- return (decimal_year % 4 == 0 && (decimal_year % 100 != 0 \|\| decimal_year % 400 == 0));`
	`625`	`+ int decimalYear = yearsSince1601 + 1601;`
	`626`	`+ return (decimalYear % 4 == 0 && (decimalYear % 100 != 0 \|\| decimalYear % 400 == 0));`
`627`	`627`	`}`
`628`	`628`
`629`		`-static bool year_is_leap_year(int year) { return year_is_leap_year_1601(year + 299); }`
`630`		`-`
`631`	`629`	`static const int SecondsInMinute = 60;`
`632`	`630`	`static const int SecondsInHour = SecondsInMinute * 60;`
`633`	`631`	`static const int SecondsInDay = SecondsInHour * 24;`
`@@ -641,9 +639,6 @@ static const int SecondsInYear = SecondsInDay * DaysInYear;`
`641`	`639`	`static const int SecondsIn4Years = SecondsInDay * DaysIn4Years;`
`642`	`640`	`static const int64_t SecondsIn100Years = static_cast<int64_t>(SecondsInDay) * DaysIn100Years;`
`643`	`641`	`static const int64_t SecondsIn400Years = static_cast<int64_t>(SecondsInDay) * DaysIn400Years;`
`644`		`-static const int64_t SecondsFrom1900To2001 = INT64_C(3187296000);`
`645`		`-`
`646`		`-static const int64_t NtTo1900OffsetInterval = INT64_C(0x014F373BFDE04000);`
`647`	`642`
`648`	`643`	`static int count_leap_years_1601(int yearsSince1601)`
`649`	`644`	`{`
`@@ -660,12 +655,6 @@ static int count_leap_years_1601(int yearsSince1601)`
`660`	`655`	`return result;`
`661`	`656`	`}`
`662`	`657`
`663`		`-static int count_leap_years(const int yearsSince1900)`
`664`		`-{`
`665`		`- // shift into 1601, the first 400 year cycle including 1900, then subtract leap years from 1601->1900`
`666`		`- return count_leap_years_1601(yearsSince1900 + 299) - 72;`
`667`		`-}`
`668`		`-`
`669`	`658`	`// The following table assumes no leap year; leap year is added separately`
`670`	`659`	`static const unsigned short cumulative_days_to_month[12] = {`
`671`	`660`	`0, // Jan`
`@@ -749,23 +738,37 @@ static compute_year_result compute_year_1601(int64_t secondsSince1601)`
`749`	`738`	`return {year400 * 400 + year100 * 100 + year4 * 4 + year1, secondsInt};`
`750`	`739`	`}`
`751`	`740`
`752`		`-static const int64_t secondsFrom1601To1900 = INT64_C(9435484800);`
`753`		`-static compute_year_result compute_year(int64_t secondsSince1900)`
`754`		`-{`
`755`		`- // shift to start of this 400 year cycle`
`756`		`- auto partialResult = compute_year_1601(secondsSince1900 + secondsFrom1601To1900);`
`757`		`- // shift back to 1900`
`758`		`- return {partialResult.year - 299, partialResult.secondsLeftThisYear};`
`759`		`-}`
	`741`	`+// The constant below was calculated by running the following test program on a Windows machine:`
	`742`	`+// #include <windows.h>`
	`743`	`+// #include <stdio.h>`
	`744`	`+`
	`745`	`+// int main() {`
	`746`	`+// SYSTEMTIME st;`
	`747`	`+// st.wYear = 9999;`
	`748`	`+// st.wMonth = 12;`
	`749`	`+// st.wDayOfWeek = 5;`
	`750`	`+// st.wDay = 31;`
	`751`	`+// st.wHour = 23;`
	`752`	`+// st.wMinute = 59;`
	`753`	`+// st.wSecond = 59;`
	`754`	`+// st.wMilliseconds = 999;`
	`755`	`+`
	`756`	`+// unsigned long long ft;`
	`757`	`+// if (SystemTimeToFileTime(&st, reinterpret_cast<FILETIME*>(&ft))) {`
	`758`	`+// printf("0x%016llX\n", ft);`
	`759`	`+// } else {`
	`760`	`+// puts("failed!");`
	`761`	`+// }`
	`762`	`+// }`
`760`	`763`
`761`	`764`	`utility::string_t datetime::to_string(date_format format) const`
`762`	`765`	`{`
`763`		`- if (m_interval > INT64_C(2650467743990000000))`
	`766`	`+ const int64_t interval = static_cast<int64_t>(m_interval);`
	`767`	`+ if (interval > INT64_C(0x24C85A5ED1C018F0))`
`764`	`768`	`{`
`765`	`769`	`throw std::out_of_range("The requested year exceeds the year 9999.");`
`766`	`770`	`}`
`767`	`771`
`768`		`- const int64_t interval = static_cast<int64_t>(m_interval);`
`769`	`772`	`const int64_t secondsSince1601 = interval / _secondTicks; // convert to seconds`
`770`	`773`	`const int fracSec = static_cast<int>(interval % _secondTicks);`
`771`	`774`
`@@ -899,12 +902,12 @@ static const unsigned char max_days_in_month[12] = {`
`899`	`902`	`31 // Dec`
`900`	`903`	`};`
`901`	`904`
`902`		`-static bool validate_day_month(int day, int month, int year)`
	`905`	`+static bool validate_day_month_1601(int day, int month, int year)`
`903`	`906`	`{`
`904`	`907`	`int maxDaysThisMonth;`
`905`	`908`	`if (month == 1)`
`906`	`909`	`{ // Feb needs leap year testing`
`907`		`- maxDaysThisMonth = 28 + year_is_leap_year(year);`
	`910`	`+ maxDaysThisMonth = 28 + year_is_leap_year_1601(year);`
`908`	`911`	`}`
`909`	`912`	`else`
`910`	`913`	`{`
`@@ -914,9 +917,9 @@ static bool validate_day_month(int day, int month, int year)`
`914`	`917`	`return day >= 1 && day <= maxDaysThisMonth;`
`915`	`918`	`}`
`916`	`919`
`917`		`-static int get_year_day(int month, int monthDay, int year)`
	`920`	`+static int get_year_day_1601(int month, int monthDay, int year)`
`918`	`921`	`{`
`919`		`- return cumulative_days_to_month[month] + monthDay + (year_is_leap_year(year) && month > 1) - 1;`
	`922`	`+ return cumulative_days_to_month[month] + monthDay + (year_is_leap_year_1601(year) && month > 1) - 1;`
`920`	`923`	`}`
`921`	`924`
`922`	`925`	`template<class CharT>`
`@@ -1009,7 +1012,7 @@ datetime __cdecl datetime::from_string(const utility::string_t& dateString, date`
`1009`	`1012`	`datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& dateString, date_format format)`
`1010`	`1013`	`{`
`1011`	`1014`	`datetime result = datetime::maximum();`
`1012`		`- int64_t secondsSince1900;`
	`1015`	`+ int64_t secondsSince1601;`
`1013`	`1016`	`uint64_t fracSec = 0;`
`1014`	`1017`	`auto str = dateString.c_str();`
`1015`	`1018`	`if (format == RFC_1123)`
`@@ -1076,19 +1079,21 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da`
`1076`	`1079`
`1077`	`1080`	`int year = (str[0] - _XPLATSTR('0')) * 1000 + (str[1] - _XPLATSTR('0')) * 100 + (str[2] - _XPLATSTR('0')) * 10 +`
`1078`	`1081`	`(str[3] - _XPLATSTR('0'));`
`1079`		`- if (year < 1900)`
	`1082`	`+ if (year < 1601)`
`1080`	`1083`	`{`
`1081`	`1084`	`return result;`
`1082`	`1085`	`}`
`1083`	`1086`
	`1087`	`+ year -= 1601;`
	`1088`	`+`
`1084`	`1089`	`// days in month validity check`
`1085`		`- if (!validate_day_month(monthDay, month, year))`
	`1090`	`+ if (!validate_day_month_1601(monthDay, month, year))`
`1086`	`1091`	`{`
`1087`	`1092`	`return result;`
`1088`	`1093`	`}`
`1089`	`1094`
`1090`	`1095`	`str += 5; // parsed year`
`1091`		`- const int yearDay = get_year_day(month, monthDay, year);`
	`1096`	`+ const int yearDay = get_year_day_1601(month, monthDay, year);`
`1092`	`1097`
`1093`	`1098`	`if (!ascii_isdigit2(str[0]) \|\| !ascii_isdigit(str[1]) \|\| str[2] != _XPLATSTR(':') \|\| !ascii_isdigit5(str[3]) \|\|`
`1094`	`1099`	`!ascii_isdigit(str[4]))`
`@@ -1132,21 +1137,20 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da`
`1132`	`1137`	`return result;`
`1133`	`1138`	`}`
`1134`	`1139`
`1135`		`- year -= 1900;`
`1136`		`- int daysSince1900 = year * DaysInYear + count_leap_years(year) + yearDay;`
	`1140`	`+ int daysSince1601 = year * DaysInYear + count_leap_years_1601(year) + yearDay;`
`1137`	`1141`
`1138`	`1142`	`if (parsedWeekday != 7)`
`1139`	`1143`	`{`
`1140`		`- const int actualWeekday = (daysSince1900 + 1) % 7;`
	`1144`	`+ const int actualWeekday = (daysSince1601 + 1) % 7;`
`1141`	`1145`
`1142`	`1146`	`if (parsedWeekday != actualWeekday)`
`1143`	`1147`	`{`
`1144`	`1148`	`return result;`
`1145`	`1149`	`}`
`1146`	`1150`	`}`
`1147`	`1151`
`1148`		`- secondsSince1900 =`
`1149`		`- static_cast<int64_t>(daysSince1900) * SecondsInDay + hour * SecondsInHour + minute * SecondsInMinute + sec;`
	`1152`	`+ secondsSince1601 =`
	`1153`	`+ static_cast<int64_t>(daysSince1601) * SecondsInDay + hour * SecondsInHour + minute * SecondsInMinute + sec;`
`1150`	`1154`
`1151`	`1155`	`if (!string_starts_with(str, "GMT") && !string_starts_with(str, "UT"))`
`1152`	`1156`	`{`
`@@ -1186,8 +1190,8 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da`
`1186`	`1190`	`return result;`
`1187`	`1191`	`}`
`1188`	`1192`
`1189`		`- secondsSince1900 = timezone_adjust(secondsSince1900, static_cast<unsigned char>(tzCh), tzHours, tzMinutes);`
`1190`		`- if (secondsSince1900 < 0)`
	`1193`	`+ secondsSince1601 = timezone_adjust(secondsSince1601, static_cast<unsigned char>(tzCh), tzHours, tzMinutes);`
	`1194`	`+ if (secondsSince1601 < 0)`
`1191`	`1195`	`{`
`1192`	`1196`	`return result;`
`1193`	`1197`	`}`
`@@ -1203,11 +1207,13 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da`
`1203`	`1207`
`1204`	`1208`	`int year = (str[0] - _XPLATSTR('0')) * 1000 + (str[1] - _XPLATSTR('0')) * 100 + (str[2] - _XPLATSTR('0')) * 10 +`
`1205`	`1209`	`(str[3] - _XPLATSTR('0'));`
`1206`		`- if (year < 1900)`
	`1210`	`+ if (year < 1601)`
`1207`	`1211`	`{`
`1208`	`1212`	`return result;`
`1209`	`1213`	`}`
`1210`	`1214`
	`1215`	`+ year -= 1601;`
	`1216`	`+`
`1211`	`1217`	`str += 4;`
`1212`	`1218`	`if (*str == _XPLATSTR('-'))`
`1213`	`1219`	`{`
`@@ -1241,24 +1247,22 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da`
`1241`	`1247`	`}`
`1242`	`1248`
`1243`	`1249`	`int monthDay = atoi2(str);`
`1244`		`- if (!validate_day_month(monthDay, month, year))`
	`1250`	`+ if (!validate_day_month_1601(monthDay, month, year))`
`1245`	`1251`	`{`
`1246`	`1252`	`return result;`
`1247`	`1253`	`}`
`1248`	`1254`
`1249`		`- const int yearDay = get_year_day(month, monthDay, year);`
	`1255`	`+ const int yearDay = get_year_day_1601(month, monthDay, year);`
`1250`	`1256`
`1251`	`1257`	`str += 2;`
`1252`		`- year -= 1900;`
`1253`		`- int daysSince1900 = year * DaysInYear + count_leap_years(year) + yearDay;`
	`1258`	`+ int daysSince1601 = year * DaysInYear + count_leap_years_1601(year) + yearDay;`
`1254`	`1259`
`1255`	`1260`	`if (str[0] != _XPLATSTR('T') && str[0] != _XPLATSTR('t'))`
`1256`	`1261`	`{`
`1257`	`1262`	`// No time`
`1258`		`- secondsSince1900 = static_cast<int64_t>(daysSince1900) * SecondsInDay;`
	`1263`	`+ secondsSince1601 = static_cast<int64_t>(daysSince1601) * SecondsInDay;`
`1259`	`1264`
`1260`		`- result.m_interval =`
`1261`		`- static_cast<interval_type>(secondsSince1900 * _secondTicks + fracSec + NtTo1900OffsetInterval);`
	`1265`	`+ result.m_interval = static_cast<interval_type>(secondsSince1601 * _secondTicks + fracSec);`
`1262`	`1266`	`return result;`
`1263`	`1267`	`}`
`1264`	`1268`
`@@ -1347,8 +1351,8 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da`
`1347`	`1351`	`}`
`1348`	`1352`	`}`
`1349`	`1353`
`1350`		`- secondsSince1900 =`
`1351`		`- static_cast<int64_t>(daysSince1900) * SecondsInDay + hour * SecondsInHour + minute * SecondsInMinute + sec;`
	`1354`	`+ secondsSince1601 =`
	`1355`	`+ static_cast<int64_t>(daysSince1601) * SecondsInDay + hour * SecondsInHour + minute * SecondsInMinute + sec;`
`1352`	`1356`
`1353`	`1357`	`if (str[0] == _XPLATSTR('Z') \|\| str[0] == _XPLATSTR('z'))`
`1354`	`1358`	`{`
`@@ -1363,8 +1367,8 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da`
`1363`	`1367`	`return result;`
`1364`	`1368`	`}`
`1365`	`1369`
`1366`		`- secondsSince1900 = timezone_adjust(secondsSince1900, offsetDirection, atoi2(str + 1), atoi2(str + 4));`
`1367`		`- if (secondsSince1900 < 0)`
	`1370`	`+ secondsSince1601 = timezone_adjust(secondsSince1601, offsetDirection, atoi2(str + 1), atoi2(str + 4));`
	`1371`	`+ if (secondsSince1601 < 0)`
`1368`	`1372`	`{`
`1369`	`1373`	`return result;`
`1370`	`1374`	`}`
`@@ -1379,7 +1383,7 @@ datetime __cdecl datetime::from_string_maximum_error(const utility::string_t& da`
`1379`	`1383`	`throw std::invalid_argument("unrecognized date format");`
`1380`	`1384`	`}`
`1381`	`1385`
`1382`		`- result.m_interval = static_cast<interval_type>(secondsSince1900 * _secondTicks + fracSec + NtTo1900OffsetInterval);`
	`1386`	`+ result.m_interval = static_cast<interval_type>(secondsSince1601 * _secondTicks + fracSec);`
`1383`	`1387`	`return result;`
`1384`	`1388`	`}`
`1385`	`1389`