diff options
Diffstat (limited to '')
| -rw-r--r-- | externals/tz/tz/tz.cpp | 1636 |
1 files changed, 1636 insertions, 0 deletions
diff --git a/externals/tz/tz/tz.cpp b/externals/tz/tz/tz.cpp new file mode 100644 index 000000000..0c8b68217 --- /dev/null +++ b/externals/tz/tz/tz.cpp @@ -0,0 +1,1636 @@ +// SPDX-FileCopyrightText: 2023 yuzu Emulator Project +// SPDX-FileCopyrightText: 1996 Arthur David Olson +// SPDX-License-Identifier: BSD-2-Clause + +#include <climits> +#include <cstring> +#include <ctime> + +#include "tz.h" + +namespace Tz { + +namespace { +#define EINVAL 22 + +static Rule gmtmem{}; +static Rule* const gmtptr = &gmtmem; + +struct TzifHeader { + std::array<char, 4> tzh_magic; // "TZif" + std::array<char, 1> tzh_version; + std::array<char, 15> tzh_reserved; + std::array<char, 4> tzh_ttisutcnt; + std::array<char, 4> tzh_ttisstdcnt; + std::array<char, 4> tzh_leapcnt; + std::array<char, 4> tzh_timecnt; + std::array<char, 4> tzh_typecnt; + std::array<char, 4> tzh_charcnt; +}; +static_assert(sizeof(TzifHeader) == 0x2C, "TzifHeader has the wrong size!"); + +struct local_storage { + // Binary layout: + // char buf[2 * sizeof(TzifHeader) + 2 * sizeof(Rule) + 4 * TZ_MAX_TIMES]; + std::span<const u8> binary; + Rule state; +}; +static local_storage tzloadbody_local_storage; + +enum rtype : s32 { + JULIAN_DAY = 0, + DAY_OF_YEAR = 1, + MONTH_NTH_DAY_OF_WEEK = 2, +}; + +struct tzrule { + rtype r_type; + int r_day; + int r_week; + int r_mon; + s64 r_time; +}; +static_assert(sizeof(tzrule) == 0x18, "tzrule has the wrong size!"); + +constexpr static char UNSPEC[] = "-00"; +constexpr static char TZDEFRULESTRING[] = ",M3.2.0,M11.1.0"; + +enum { + SECSPERMIN = 60, + MINSPERHOUR = 60, + SECSPERHOUR = SECSPERMIN * MINSPERHOUR, + HOURSPERDAY = 24, + DAYSPERWEEK = 7, + DAYSPERNYEAR = 365, + DAYSPERLYEAR = DAYSPERNYEAR + 1, + MONSPERYEAR = 12, + YEARSPERREPEAT = 400 /* years before a Gregorian repeat */ +}; + +#define SECSPERDAY ((s64)SECSPERHOUR * HOURSPERDAY) + +#define DAYSPERREPEAT ((s64)400 * 365 + 100 - 4 + 1) +#define SECSPERREPEAT ((int_fast64_t)DAYSPERREPEAT * SECSPERDAY) +#define AVGSECSPERYEAR (SECSPERREPEAT / YEARSPERREPEAT) + +enum { + TM_SUNDAY, + TM_MONDAY, + TM_TUESDAY, + TM_WEDNESDAY, + TM_THURSDAY, + TM_FRIDAY, + TM_SATURDAY, +}; + +enum { + TM_JANUARY, + TM_FEBRUARY, + TM_MARCH, + TM_APRIL, + TM_MAY, + TM_JUNE, + TM_JULY, + TM_AUGUST, + TM_SEPTEMBER, + TM_OCTOBER, + TM_NOVEMBER, + TM_DECEMBER, +}; + +constexpr s32 TM_YEAR_BASE = 1900; +constexpr s32 TM_WDAY_BASE = TM_MONDAY; +constexpr s32 EPOCH_YEAR = 1970; +constexpr s32 EPOCH_WDAY = TM_THURSDAY; + +#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0)) + +static constexpr std::array<std::array<int, MONSPERYEAR>, 2> mon_lengths = { { + {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, + {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, +} }; + +static constexpr std::array<int, 2> year_lengths = { + DAYSPERNYEAR, + DAYSPERLYEAR, +}; + +constexpr static time_t leaps_thru_end_of_nonneg(time_t y) { + return y / 4 - y / 100 + y / 400; +} + +constexpr static time_t leaps_thru_end_of(time_t y) { + return (y < 0 ? -1 - leaps_thru_end_of_nonneg(-1 - y) : leaps_thru_end_of_nonneg(y)); +} + +#define TWOS_COMPLEMENT(t) ((t) ~(t)0 < 0) + +s32 detzcode(const char* const codep) { + s32 result; + int i; + s32 one = 1; + s32 halfmaxval = one << (32 - 2); + s32 maxval = halfmaxval - 1 + halfmaxval; + s32 minval = -1 - maxval; + + result = codep[0] & 0x7f; + for (i = 1; i < 4; ++i) { + result = (result << 8) | (codep[i] & 0xff); + } + + if (codep[0] & 0x80) { + /* Do two's-complement negation even on non-two's-complement machines. + If the result would be minval - 1, return minval. */ + result -= !TWOS_COMPLEMENT(s32) && result != 0; + result += minval; + } + return result; +} + +int_fast64_t detzcode64(const char* const codep) { + int_fast64_t result; + int i; + int_fast64_t one = 1; + int_fast64_t halfmaxval = one << (64 - 2); + int_fast64_t maxval = halfmaxval - 1 + halfmaxval; + int_fast64_t minval = -static_cast<int_fast64_t>(TWOS_COMPLEMENT(int_fast64_t)) - maxval; + + result = codep[0] & 0x7f; + for (i = 1; i < 8; ++i) { + result = (result << 8) | (codep[i] & 0xff); + } + + if (codep[0] & 0x80) { + /* Do two's-complement negation even on non-two's-complement machines. + If the result would be minval - 1, return minval. */ + result -= !TWOS_COMPLEMENT(int_fast64_t) && result != 0; + result += minval; + } + return result; +} + +/* Initialize *S to a value based on UTOFF, ISDST, and DESIGIDX. */ +constexpr void init_ttinfo(ttinfo* s, s64 utoff, bool isdst, int desigidx) { + s->tt_utoff = static_cast<s32>(utoff); + s->tt_isdst = isdst; + s->tt_desigidx = desigidx; + s->tt_ttisstd = false; + s->tt_ttisut = false; +} + +/* Return true if SP's time type I does not specify local time. */ +bool ttunspecified(struct Rule const* sp, int i) { + char const* abbr = &sp->chars[sp->ttis[i].tt_desigidx]; + /* memcmp is likely faster than strcmp, and is safe due to CHARS_EXTRA. */ + return memcmp(abbr, UNSPEC, sizeof(UNSPEC)) == 0; +} + +bool typesequiv(const Rule* sp, int a, int b) { + bool result; + + if (sp == nullptr || a < 0 || a >= sp->typecnt || b < 0 || b >= sp->typecnt) { + result = false; + } + else { + /* Compare the relevant members of *AP and *BP. + Ignore tt_ttisstd and tt_ttisut, as they are + irrelevant now and counting them could cause + sp->goahead to mistakenly remain false. */ + const ttinfo* ap = &sp->ttis[a]; + const ttinfo* bp = &sp->ttis[b]; + result = (ap->tt_utoff == bp->tt_utoff && ap->tt_isdst == bp->tt_isdst && + (strcmp(&sp->chars[ap->tt_desigidx], &sp->chars[bp->tt_desigidx]) == 0)); + } + return result; +} + +constexpr const char* getqzname(const char* strp, const int delim) { + int c; + + while ((c = *strp) != '\0' && c != delim) { + ++strp; + } + return strp; +} + +/* Is C an ASCII digit? */ +constexpr bool is_digit(char c) { + return '0' <= c && c <= '9'; +} + +/* +** Given a pointer into a timezone string, scan until a character that is not +** a valid character in a time zone abbreviation is found. +** Return a pointer to that character. +*/ + +constexpr const char* getzname(const char* strp) { + char c; + + while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' && c != '+') { + ++strp; + } + return strp; +} + +static const char* getnum(const char* strp, int* const nump, const int min, const int max) { + char c; + int num; + + if (strp == nullptr || !is_digit(c = *strp)) { + return nullptr; + } + num = 0; + do { + num = num * 10 + (c - '0'); + if (num > max) { + return nullptr; /* illegal value */ + } + c = *++strp; + } while (is_digit(c)); + if (num < min) { + return nullptr; /* illegal value */ + } + *nump = num; + return strp; +} + +/* +** Given a pointer into a timezone string, extract a number of seconds, +** in hh[:mm[:ss]] form, from the string. +** If any error occurs, return NULL. +** Otherwise, return a pointer to the first character not part of the number +** of seconds. +*/ + +const char* getsecs(const char* strp, s64* const secsp) { + int num; + s64 secsperhour = SECSPERHOUR; + + /* + ** 'HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like + ** "M10.4.6/26", which does not conform to Posix, + ** but which specifies the equivalent of + ** "02:00 on the first Sunday on or after 23 Oct". + */ + strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1); + if (strp == nullptr) { + return nullptr; + } + *secsp = num * secsperhour; + if (*strp == ':') { + ++strp; + strp = getnum(strp, &num, 0, MINSPERHOUR - 1); + if (strp == nullptr) { + return nullptr; + } + *secsp += num * SECSPERMIN; + if (*strp == ':') { + ++strp; + /* 'SECSPERMIN' allows for leap seconds. */ + strp = getnum(strp, &num, 0, SECSPERMIN); + if (strp == nullptr) { + return nullptr; + } + *secsp += num; + } + } + return strp; +} + +/* +** Given a pointer into a timezone string, extract an offset, in +** [+-]hh[:mm[:ss]] form, from the string. +** If any error occurs, return NULL. +** Otherwise, return a pointer to the first character not part of the time. +*/ + +const char* getoffset(const char* strp, s64* const offsetp) { + bool neg = false; + + if (*strp == '-') { + neg = true; + ++strp; + } + else if (*strp == '+') { + ++strp; + } + strp = getsecs(strp, offsetp); + if (strp == nullptr) { + return nullptr; /* illegal time */ + } + if (neg) { + *offsetp = -*offsetp; + } + return strp; +} + +constexpr const char* getrule(const char* strp, tzrule* const rulep) { + if (*strp == 'J') { + /* + ** Julian day. + */ + rulep->r_type = JULIAN_DAY; + ++strp; + strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR); + } + else if (*strp == 'M') { + /* + ** Month, week, day. + */ + rulep->r_type = MONTH_NTH_DAY_OF_WEEK; + ++strp; + strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR); + if (strp == nullptr) { + return nullptr; + } + if (*strp++ != '.') { + return nullptr; + } + strp = getnum(strp, &rulep->r_week, 1, 5); + if (strp == nullptr) { + return nullptr; + } + if (*strp++ != '.') { + return nullptr; + } + strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1); + } + else if (is_digit(*strp)) { + /* + ** Day of year. + */ + rulep->r_type = DAY_OF_YEAR; + strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1); + } + else { + return nullptr; + } /* invalid format */ + if (strp == nullptr) { + return nullptr; + } + if (*strp == '/') { + /* + ** Time specified. + */ + ++strp; + strp = getoffset(strp, &rulep->r_time); + } + else { + rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */ + } + return strp; +} + +constexpr bool increment_overflow(int* ip, int j) { + int const i = *ip; + + /* + ** If i >= 0 there can only be overflow if i + j > INT_MAX + ** or if j > INT_MAX - i; given i >= 0, INT_MAX - i cannot overflow. + ** If i < 0 there can only be overflow if i + j < INT_MIN + ** or if j < INT_MIN - i; given i < 0, INT_MIN - i cannot overflow. + */ + if ((i >= 0) ? (j > INT_MAX - i) : (j < INT_MIN - i)) { + return true; + } + *ip += j; + return false; +} + +constexpr bool increment_overflow32(s64* const lp, int const m) { + s64 const l = *lp; + + if ((l >= 0) ? (m > INT_FAST32_MAX - l) : (m < INT_FAST32_MIN - l)) + return true; + *lp += m; + return false; +} + +constexpr bool increment_overflow_time(time_t* tp, s64 j) { + /* + ** This is like + ** 'if (! (TIME_T_MIN <= *tp + j && *tp + j <= TIME_T_MAX)) ...', + ** except that it does the right thing even if *tp + j would overflow. + */ + if (!(j < 0 ? (std::is_signed_v<time_t> ? TIME_T_MIN - j <= *tp : -1 - j < *tp) + : *tp <= TIME_T_MAX - j)) { + return true; + } + *tp += j; + return false; +} + +CalendarTimeInternal* timesub(const time_t* timep, s64 offset, const Rule* sp, + CalendarTimeInternal* tmp) { + time_t tdays; + const int* ip; + s64 idays, rem, dayoff, dayrem; + time_t y; + + /* Calculate the year, avoiding integer overflow even if + time_t is unsigned. */ + tdays = *timep / SECSPERDAY; + rem = *timep % SECSPERDAY; + rem += offset % SECSPERDAY + 3 * SECSPERDAY; + dayoff = offset / SECSPERDAY + rem / SECSPERDAY - 3; + rem %= SECSPERDAY; + /* y = (EPOCH_YEAR + + floor((tdays + dayoff) / DAYSPERREPEAT) * YEARSPERREPEAT), + sans overflow. But calculate against 1570 (EPOCH_YEAR - + YEARSPERREPEAT) instead of against 1970 so that things work + for localtime values before 1970 when time_t is unsigned. */ + dayrem = tdays % DAYSPERREPEAT; + dayrem += dayoff % DAYSPERREPEAT; + y = (EPOCH_YEAR - YEARSPERREPEAT + + ((1ull + dayoff / DAYSPERREPEAT + dayrem / DAYSPERREPEAT - ((dayrem % DAYSPERREPEAT) < 0) + + tdays / DAYSPERREPEAT) * + YEARSPERREPEAT)); + /* idays = (tdays + dayoff) mod DAYSPERREPEAT, sans overflow. */ + idays = tdays % DAYSPERREPEAT; + idays += dayoff % DAYSPERREPEAT + 2 * DAYSPERREPEAT; + idays %= DAYSPERREPEAT; + /* Increase Y and decrease IDAYS until IDAYS is in range for Y. */ + while (year_lengths[isleap(y)] <= idays) { + s64 tdelta = idays / DAYSPERLYEAR; + s64 ydelta = tdelta + !tdelta; + time_t newy = y + ydelta; + int leapdays; + leapdays = static_cast<s32>(leaps_thru_end_of(newy - 1) - leaps_thru_end_of(y - 1)); + idays -= ydelta * DAYSPERNYEAR; + idays -= leapdays; + y = newy; + } + + if constexpr (!std::is_signed_v<time_t> && y < TM_YEAR_BASE) { + int signed_y = static_cast<s32>(y); + tmp->tm_year = signed_y - TM_YEAR_BASE; + } + else if ((!std::is_signed_v<time_t> || std::numeric_limits<s32>::min() + TM_YEAR_BASE <= y) && + y - TM_YEAR_BASE <= std::numeric_limits<s32>::max()) { + tmp->tm_year = static_cast<s32>(y - TM_YEAR_BASE); + } + else { + // errno = EOVERFLOW; + return nullptr; + } + + tmp->tm_yday = static_cast<s32>(idays); + /* + ** The "extra" mods below avoid overflow problems. + */ + tmp->tm_wday = static_cast<s32>( + TM_WDAY_BASE + ((tmp->tm_year % DAYSPERWEEK) * (DAYSPERNYEAR % DAYSPERWEEK)) + + leaps_thru_end_of(y - 1) - leaps_thru_end_of(TM_YEAR_BASE - 1) + idays); + tmp->tm_wday %= DAYSPERWEEK; + if (tmp->tm_wday < 0) { + tmp->tm_wday += DAYSPERWEEK; + } + tmp->tm_hour = static_cast<s32>(rem / SECSPERHOUR); + rem %= SECSPERHOUR; + tmp->tm_min = static_cast<s32>(rem / SECSPERMIN); + tmp->tm_sec = static_cast<s32>(rem % SECSPERMIN); + + ip = mon_lengths[isleap(y)].data(); + for (tmp->tm_mon = 0; idays >= ip[tmp->tm_mon]; ++(tmp->tm_mon)) { + idays -= ip[tmp->tm_mon]; + } + tmp->tm_mday = static_cast<s32>(idays + 1); + tmp->tm_isdst = 0; + return tmp; +} + +CalendarTimeInternal* gmtsub([[maybe_unused]] Rule const* sp, time_t const* timep, + s64 offset, CalendarTimeInternal* tmp) { + CalendarTimeInternal* result; + + result = timesub(timep, offset, gmtptr, tmp); + return result; +} + +CalendarTimeInternal* localsub(Rule const* sp, time_t const* timep, s64 setname, + CalendarTimeInternal* const tmp) { + const ttinfo* ttisp; + int i; + CalendarTimeInternal* result; + const time_t t = *timep; + + if (sp == nullptr) { + /* Don't bother to set tzname etc.; tzset has already done it. */ + return gmtsub(gmtptr, timep, 0, tmp); + } + if ((sp->goback && t < sp->ats[0]) || (sp->goahead && t > sp->ats[sp->timecnt - 1])) { + time_t newt; + time_t seconds; + time_t years; + + if (t < sp->ats[0]) { + seconds = sp->ats[0] - t; + } + else { + seconds = t - sp->ats[sp->timecnt - 1]; + } + --seconds; + + /* Beware integer overflow, as SECONDS might + be close to the maximum time_t. */ + years = seconds / SECSPERREPEAT * YEARSPERREPEAT; + seconds = years * AVGSECSPERYEAR; + years += YEARSPERREPEAT; + if (t < sp->ats[0]) { + newt = t + seconds + SECSPERREPEAT; + } + else { + newt = t - seconds - SECSPERREPEAT; + } + + if (newt < sp->ats[0] || newt > sp->ats[sp->timecnt - 1]) { + return nullptr; /* "cannot happen" */ + } + result = localsub(sp, &newt, setname, tmp); + if (result) { + int_fast64_t newy; + + newy = result->tm_year; + if (t < sp->ats[0]) { + newy -= years; + } + else { + newy += years; + } + if (!(std::numeric_limits<s32>::min() <= newy && + newy <= std::numeric_limits<s32>::max())) { + return nullptr; + } + result->tm_year = static_cast<s32>(newy); + } + return result; + } + if (sp->timecnt == 0 || t < sp->ats[0]) { + i = sp->defaulttype; + } + else { + int lo = 1; + int hi = sp->timecnt; + + while (lo < hi) { + int mid = (lo + hi) >> 1; + + if (t < sp->ats[mid]) + hi = mid; + else + lo = mid + 1; + } + i = sp->types[lo - 1]; + } + ttisp = &sp->ttis[i]; + /* + ** To get (wrong) behavior that's compatible with System V Release 2.0 + ** you'd replace the statement below with + ** t += ttisp->tt_utoff; + ** timesub(&t, 0L, sp, tmp); + */ + result = timesub(&t, ttisp->tt_utoff, sp, tmp); + if (result) { + result->tm_isdst = ttisp->tt_isdst; + + if (ttisp->tt_desigidx > static_cast<s32>(sp->chars.size() - CHARS_EXTRA)) { + return nullptr; + } + + auto num_chars_to_copy{ + std::min(sp->chars.size() - ttisp->tt_desigidx, result->tm_zone.size()) - 1 }; + std::strncpy(result->tm_zone.data(), &sp->chars[ttisp->tt_desigidx], num_chars_to_copy); + result->tm_zone[num_chars_to_copy] = '\0'; + + auto original_size{ std::strlen(&sp->chars[ttisp->tt_desigidx]) }; + if (original_size > num_chars_to_copy) { + return nullptr; + } + + result->tm_utoff = ttisp->tt_utoff; + result->time_index = i; + } + return result; +} + +/* +** Given a year, a rule, and the offset from UT at the time that rule takes +** effect, calculate the year-relative time that rule takes effect. +*/ + +constexpr s64 transtime(const int year, const tzrule* const rulep, + const s64 offset) { + bool leapyear; + s64 value; + int i; + int d, m1, yy0, yy1, yy2, dow; + + leapyear = isleap(year); + switch (rulep->r_type) { + case JULIAN_DAY: + /* + ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap + ** years. + ** In non-leap years, or if the day number is 59 or less, just + ** add SECSPERDAY times the day number-1 to the time of + ** January 1, midnight, to get the day. + */ + value = (rulep->r_day - 1) * SECSPERDAY; + if (leapyear && rulep->r_day >= 60) { + value += SECSPERDAY; + } + break; + + case DAY_OF_YEAR: + /* + ** n - day of year. + ** Just add SECSPERDAY times the day number to the time of + ** January 1, midnight, to get the day. + */ + value = rulep->r_day * SECSPERDAY; + break; + + case MONTH_NTH_DAY_OF_WEEK: + /* + ** Mm.n.d - nth "dth day" of month m. + */ + + /* + ** Use Zeller's Congruence to get day-of-week of first day of + ** month. + */ + m1 = (rulep->r_mon + 9) % 12 + 1; + yy0 = (rulep->r_mon <= 2) ? (year - 1) : year; + yy1 = yy0 / 100; + yy2 = yy0 % 100; + dow = ((26 * m1 - 2) / 10 + 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7; + if (dow < 0) { + dow += DAYSPERWEEK; + } + + /* + ** "dow" is the day-of-week of the first day of the month. Get + ** the day-of-month (zero-origin) of the first "dow" day of the + ** month. + */ + d = rulep->r_day - dow; + if (d < 0) { + d += DAYSPERWEEK; + } + for (i = 1; i < rulep->r_week; ++i) { + if (d + DAYSPERWEEK >= mon_lengths[leapyear][rulep->r_mon - 1]) { + break; + } + d += DAYSPERWEEK; + } + + /* + ** "d" is the day-of-month (zero-origin) of the day we want. + */ + value = d * SECSPERDAY; + for (i = 0; i < rulep->r_mon - 1; ++i) { + value += mon_lengths[leapyear][i] * SECSPERDAY; + } + break; + + default: + //UNREACHABLE(); + break; + } + + /* + ** "value" is the year-relative time of 00:00:00 UT on the day in + ** question. To get the year-relative time of the specified local + ** time on that day, add the transition time and the current offset + ** from UT. + */ + return value + rulep->r_time + offset; +} + +bool tzparse(const char* name, Rule* sp) { + const char* stdname{}; + const char* dstname{}; + s64 stdoffset; + s64 dstoffset; + char* cp; + ptrdiff_t stdlen; + ptrdiff_t dstlen{}; + ptrdiff_t charcnt; + time_t atlo = TIME_T_MIN, leaplo = TIME_T_MIN; + + stdname = name; + if (*name == '<') { + name++; + stdname = name; + name = getqzname(name, '>'); + if (*name != '>') { + return false; + } + stdlen = name - stdname; + name++; + } + else { + name = getzname(name); + stdlen = name - stdname; + } + if (!(0 < stdlen && stdlen <= TZNAME_MAXIMUM)) { + return false; + } + name = getoffset(name, &stdoffset); + if (name == nullptr) { + return false; + } + charcnt = stdlen + 1; + if (charcnt > TZ_MAX_CHARS) { + return false; + } + if (*name != '\0') { + if (*name == '<') { + dstname = ++name; + name = getqzname(name, '>'); + if (*name != '>') + return false; + dstlen = name - dstname; + name++; + } + else { + dstname = name; + name = getzname(name); + dstlen = name - dstname; /* length of DST abbr. */ + } + if (!(0 < dstlen && dstlen <= TZNAME_MAXIMUM)) { + return false; + } + charcnt += dstlen + 1; + if (charcnt > TZ_MAX_CHARS) { + return false; + } + if (*name != '\0' && *name != ',' && *name != ';') { + name = getoffset(name, &dstoffset); + if (name == nullptr) { + return false; + } + } + else { + dstoffset = stdoffset - SECSPERHOUR; + } + if (*name == '\0') { + name = TZDEFRULESTRING; + } + if (*name == ',' || *name == ';') { + struct tzrule start; + struct tzrule end; + int year; + int timecnt; + time_t janfirst; + s64 janoffset = 0; + int yearbeg, yearlim; + + ++name; + if ((name = getrule(name, &start)) == nullptr) { + return false; + } + if (*name++ != ',') { + return false; + } + if ((name = getrule(name, &end)) == nullptr) { + return false; + } + if (*name != '\0') { + return false; + } + sp->typecnt = 2; /* standard time and DST */ + /* + ** Two transitions per year, from EPOCH_YEAR forward. + */ + init_ttinfo(&sp->ttis[0], -stdoffset, false, 0); + init_ttinfo(&sp->ttis[1], -dstoffset, true, static_cast<s32>(stdlen + 1)); + sp->defaulttype = 0; + timecnt = 0; + janfirst = 0; + yearbeg = EPOCH_YEAR; + + do { + s64 yearsecs = year_lengths[isleap(yearbeg - 1)] * SECSPERDAY; + yearbeg--; + if (increment_overflow_time(&janfirst, -yearsecs)) { + janoffset = -yearsecs; + break; + } + } while (atlo < janfirst && EPOCH_YEAR - YEARSPERREPEAT / 2 < yearbeg); + + while (true) { + s64 yearsecs = year_lengths[isleap(yearbeg)] * SECSPERDAY; + int yearbeg1 = yearbeg; + time_t janfirst1 = janfirst; + if (increment_overflow_time(&janfirst1, yearsecs) || + increment_overflow(&yearbeg1, 1) || atlo <= janfirst1) { + break; + } + yearbeg = yearbeg1; + janfirst = janfirst1; + } + + yearlim = yearbeg; + if (increment_overflow(&yearlim, YEARSPERREPEAT + 1)) { + yearlim = INT_MAX; + } + for (year = yearbeg; year < yearlim; year++) { + s64 starttime = transtime(year, &start, stdoffset), + endtime = transtime(year, &end, dstoffset); + s64 yearsecs = (year_lengths[isleap(year)] * SECSPERDAY); + bool reversed = endtime < starttime; + if (reversed) { + s64 swap = starttime; + starttime = endtime; + endtime = swap; + } + if (reversed || (starttime < endtime && endtime - starttime < yearsecs)) { + if (TZ_MAX_TIMES - 2 < timecnt) { + break; + } + sp->ats[timecnt] = janfirst; + if (!increment_overflow_time(reinterpret_cast<time_t*>(&sp->ats[timecnt]), janoffset + starttime) && + atlo <= sp->ats[timecnt]) { + sp->types[timecnt++] = !reversed; + } + sp->ats[timecnt] = janfirst; + if (!increment_overflow_time(reinterpret_cast<time_t*>(&sp->ats[timecnt]), janoffset + endtime) && + atlo <= sp->ats[timecnt]) { + sp->types[timecnt++] = reversed; + } + } + if (endtime < leaplo) { + yearlim = year; + if (increment_overflow(&yearlim, YEARSPERREPEAT + 1)) { + yearlim = INT_MAX; + } + } + if (increment_overflow_time(&janfirst, janoffset + yearsecs)) { + break; + } + janoffset = 0; + } + sp->timecnt = timecnt; + if (!timecnt) { + sp->ttis[0] = sp->ttis[1]; + sp->typecnt = 1; /* Perpetual DST. */ + } + else if (YEARSPERREPEAT < year - yearbeg) { + sp->goback = sp->goahead = true; + } + } + else { + s64 theirstdoffset; + s64 theirdstoffset; + s64 theiroffset; + bool isdst; + int i; + int j; + + if (*name != '\0') { + return false; + } + /* + ** Initial values of theirstdoffset and theirdstoffset. + */ + theirstdoffset = 0; + for (i = 0; i < sp->timecnt; ++i) { + j = sp->types[i]; + if (!sp->ttis[j].tt_isdst) { + theirstdoffset = -sp->ttis[j].tt_utoff; + break; + } + } + theirdstoffset = 0; + for (i = 0; i < sp->timecnt; ++i) { + j = sp->types[i]; + if (sp->ttis[j].tt_isdst) { + theirdstoffset = -sp->ttis[j].tt_utoff; + break; + } + } + /* + ** Initially we're assumed to be in standard time. + */ + isdst = false; + /* + ** Now juggle transition times and types + ** tracking offsets as you do. + */ + for (i = 0; i < sp->timecnt; ++i) { + j = sp->types[i]; + sp->types[i] = sp->ttis[j].tt_isdst; + if (sp->ttis[j].tt_ttisut) { + /* No adjustment to transition time */ + } + else { + /* + ** If daylight saving time is in + ** effect, and the transition time was + ** not specified as standard time, add + ** the daylight saving time offset to + ** the transition time; otherwise, add + ** the standard time offset to the + ** transition time. + */ + /* + ** Transitions from DST to DDST + ** will effectively disappear since + ** POSIX provides for only one DST + ** offset. + */ + if (isdst && !sp->ttis[j].tt_ttisstd) { + sp->ats[i] += dstoffset - theirdstoffset; + } + else { + sp->ats[i] += stdoffset - theirstdoffset; + } + } + theiroffset = -sp->ttis[j].tt_utoff; + if (sp->ttis[j].tt_isdst) { + theirdstoffset = theiroffset; + } + else { + theirstdoffset = theiroffset; + } + } + /* + ** Finally, fill in ttis. + */ + init_ttinfo(&sp->ttis[0], -stdoffset, false, 0); + init_ttinfo(&sp->ttis[1], -dstoffset, true, static_cast<s32>(stdlen + 1)); + sp->typecnt = 2; + sp->defaulttype = 0; + } + } + else { + dstlen = 0; + sp->typecnt = 1; /* only standard time */ + sp->timecnt = 0; + init_ttinfo(&sp->ttis[0], -stdoffset, false, 0); + sp->defaulttype = 0; + } + sp->charcnt = static_cast<s32>(charcnt); + cp = &sp->chars[0]; + memcpy(cp, stdname, stdlen); + cp += stdlen; + *cp++ = '\0'; + if (dstlen != 0) { + memcpy(cp, dstname, dstlen); + *(cp + dstlen) = '\0'; + } + return true; +} + +int tzloadbody(Rule* sp, local_storage& local_storage) { + int i; + int stored; + size_t nread{ local_storage.binary.size_bytes() }; + int tzheadsize = sizeof(struct TzifHeader); + TzifHeader header{}; + + //ASSERT(local_storage.binary.size_bytes() >= sizeof(TzifHeader)); + std::memcpy(&header, local_storage.binary.data(), sizeof(TzifHeader)); + + sp->goback = sp->goahead = false; + + for (stored = 8; stored <= 8; stored *= 2) { + s64 datablock_size; + s32 ttisstdcnt = detzcode(header.tzh_ttisstdcnt.data()); + s32 ttisutcnt = detzcode(header.tzh_ttisutcnt.data()); + s32 leapcnt = detzcode(header.tzh_leapcnt.data()); + s32 timecnt = detzcode(header.tzh_timecnt.data()); + s32 typecnt = detzcode(header.tzh_typecnt.data()); + s32 charcnt = detzcode(header.tzh_charcnt.data()); + /* Although tzfile(5) currently requires typecnt to be nonzero, + support future formats that may allow zero typecnt + in files that have a TZ string and no transitions. */ + if (!(0 <= leapcnt && leapcnt < TZ_MAX_LEAPS && 0 <= typecnt && typecnt < TZ_MAX_TYPES && + 0 <= timecnt && timecnt < TZ_MAX_TIMES && 0 <= charcnt && charcnt < TZ_MAX_CHARS && + 0 <= ttisstdcnt && ttisstdcnt < TZ_MAX_TYPES && 0 <= ttisutcnt && + ttisutcnt < TZ_MAX_TYPES)) { + return EINVAL; + } + datablock_size = (timecnt * stored /* ats */ + + timecnt /* types */ + + typecnt * 6 /* ttinfos */ + + charcnt /* chars */ + + leapcnt * (stored + 4) /* lsinfos */ + + ttisstdcnt /* ttisstds */ + + ttisutcnt); /* ttisuts */ + if (static_cast<s32>(local_storage.binary.size_bytes()) < tzheadsize + datablock_size) { + return EINVAL; + } + if (!((ttisstdcnt == typecnt || ttisstdcnt == 0) && + (ttisutcnt == typecnt || ttisutcnt == 0))) { + return EINVAL; + } + + char const* p = (const char*)local_storage.binary.data() + tzheadsize; + + sp->timecnt = timecnt; + sp->typecnt = typecnt; + sp->charcnt = charcnt; + + /* Read transitions, discarding those out of time_t range. + But pretend the last transition before TIME_T_MIN + occurred at TIME_T_MIN. */ + timecnt = 0; + for (i = 0; i < sp->timecnt; ++i) { + int_fast64_t at = stored == 4 ? detzcode(p) : detzcode64(p); + sp->types[i] = at <= TIME_T_MAX; + if (sp->types[i]) { + time_t attime = + ((std::is_signed_v<time_t> ? at < TIME_T_MIN : at < 0) ? TIME_T_MIN : at); + if (timecnt && attime <= sp->ats[timecnt - 1]) { + if (attime < sp->ats[timecnt - 1]) + return EINVAL; + sp->types[i - 1] = 0; + timecnt--; + } + sp->ats[timecnt++] = attime; + } + p += stored; + } + + timecnt = 0; + for (i = 0; i < sp->timecnt; ++i) { + unsigned char typ = *p++; + if (sp->typecnt <= typ) { + return EINVAL; + } + if (sp->types[i]) { + sp->types[timecnt++] = typ; + } + } + sp->timecnt = timecnt; + for (i = 0; i < sp->typecnt; ++i) { + struct ttinfo* ttisp; + unsigned char isdst, desigidx; + + ttisp = &sp->ttis[i]; + ttisp->tt_utoff = detzcode(p); + p += 4; + isdst = *p++; + if (!(isdst < 2)) { + return EINVAL; + } + ttisp->tt_isdst = isdst != 0; + desigidx = *p++; + if (!(desigidx < sp->charcnt)) { + return EINVAL; + } + ttisp->tt_desigidx = desigidx; + } + for (i = 0; i < sp->charcnt; ++i) { + sp->chars[i] = *p++; + } + /* Ensure '\0'-terminated, and make it safe to call + ttunspecified later. */ + memset(&sp->chars[i], 0, CHARS_EXTRA); + + for (i = 0; i < sp->typecnt; ++i) { + struct ttinfo* ttisp; + + ttisp = &sp->ttis[i]; + if (ttisstdcnt == 0) { + ttisp->tt_ttisstd = false; + } + else { + if (*(bool*)p != true && *(bool*)p != false) { + return EINVAL; + } + ttisp->tt_ttisstd = *(bool*)p++; + } + } + for (i = 0; i < sp->typecnt; ++i) { + struct ttinfo* ttisp; + + ttisp = &sp->ttis[i]; + if (ttisutcnt == 0) { + ttisp->tt_ttisut = false; + } + else { + if (*(bool*)p != true && *(bool*)p != false) { + return EINVAL; + } + ttisp->tt_ttisut = *(bool*)p++; + } + } + + nread += (ptrdiff_t)local_storage.binary.data() - (ptrdiff_t)p; + if (nread < 0) { + return EINVAL; + } + } + + std::array<char, 256> buf{}; + if (nread > buf.size()) { + //ASSERT(false); + return EINVAL; + } + memmove(buf.data(), &local_storage.binary[local_storage.binary.size_bytes() - nread], nread); + + if (nread > 2 && buf[0] == '\n' && buf[nread - 1] == '\n' && sp->typecnt + 2 <= TZ_MAX_TYPES) { + Rule* ts = &local_storage.state; + + buf[nread - 1] = '\0'; + if (tzparse(&buf[1], ts) && local_storage.state.typecnt == 2) { + + /* Attempt to reuse existing abbreviations. + Without this, America/Anchorage would be right on + the edge after 2037 when TZ_MAX_CHARS is 50, as + sp->charcnt equals 40 (for LMT AST AWT APT AHST + AHDT YST AKDT AKST) and ts->charcnt equals 10 + (for AKST AKDT). Reusing means sp->charcnt can + stay 40 in this example. */ + int gotabbr = 0; + int charcnt = sp->charcnt; + for (i = 0; i < ts->typecnt; i++) { + char* tsabbr = &ts->chars[ts->ttis[i].tt_desigidx]; + int j; + for (j = 0; j < charcnt; j++) + if (strcmp(&sp->chars[j], tsabbr) == 0) { + ts->ttis[i].tt_desigidx = j; + gotabbr++; + break; + } + if (!(j < charcnt)) { + int tsabbrlen = static_cast<s32>(strlen(tsabbr)); + if (j + tsabbrlen < TZ_MAX_CHARS) { + strcpy(&sp->chars[j], tsabbr); + charcnt = j + tsabbrlen + 1; + ts->ttis[i].tt_desigidx = j; + gotabbr++; + } + } + } + if (gotabbr == ts->typecnt) { + sp->charcnt = charcnt; + + /* Ignore any trailing, no-op transitions generated + by zic as they don't help here and can run afoul + of bugs in zic 2016j or earlier. */ + while (1 < sp->timecnt && + (sp->types[sp->timecnt - 1] == sp->types[sp->timecnt - 2])) { + sp->timecnt--; + } + + for (i = 0; i < ts->timecnt && sp->timecnt < TZ_MAX_TIMES; i++) { + time_t t = ts->ats[i]; + if (0 < sp->timecnt && t <= sp->ats[sp->timecnt - 1]) { + continue; + } + sp->ats[sp->timecnt] = t; + sp->types[sp->timecnt] = static_cast<u8>(sp->typecnt + ts->types[i]); + sp->timecnt++; + } + for (i = 0; i < ts->typecnt; i++) { + sp->ttis[sp->typecnt++] = ts->ttis[i]; + } + } + } + } + if (sp->typecnt == 0) { + return EINVAL; + } + + if (sp->timecnt > 1) { + if (sp->ats[0] <= TIME_T_MAX - SECSPERREPEAT) { + time_t repeatat = sp->ats[0] + SECSPERREPEAT; + int repeattype = sp->types[0]; + for (i = 1; i < sp->timecnt; ++i) { + if (sp->ats[i] == repeatat && typesequiv(sp, sp->types[i], repeattype)) { + sp->goback = true; + break; + } + } + } + if (TIME_T_MIN + SECSPERREPEAT <= sp->ats[sp->timecnt - 1]) { + time_t repeatat = sp->ats[sp->timecnt - 1] - SECSPERREPEAT; + int repeattype = sp->types[sp->timecnt - 1]; + for (i = sp->timecnt - 2; i >= 0; --i) { + if (sp->ats[i] == repeatat && typesequiv(sp, sp->types[i], repeattype)) { + sp->goahead = true; + break; + } + } + } + } + + /* Infer sp->defaulttype from the data. Although this default + type is always zero for data from recent tzdb releases, + things are trickier for data from tzdb 2018e or earlier. + + The first set of heuristics work around bugs in 32-bit data + generated by tzdb 2013c or earlier. The workaround is for + zones like Australia/Macquarie where timestamps before the + first transition have a time type that is not the earliest + standard-time type. See: + https://mm.icann.org/pipermail/tz/2013-May/019368.html */ + /* + ** If type 0 does not specify local time, or is unused in transitions, + ** it's the type to use for early times. + */ + for (i = 0; i < sp->timecnt; ++i) { + if (sp->types[i] == 0) { + break; + } + } + i = i < sp->timecnt && !ttunspecified(sp, 0) ? -1 : 0; + /* + ** Absent the above, + ** if there are transition times + ** and the first transition is to a daylight time + ** find the standard type less than and closest to + ** the type of the first transition. + */ + if (i < 0 && sp->timecnt > 0 && sp->ttis[sp->types[0]].tt_isdst) { + i = sp->types[0]; + while (--i >= 0) { + if (!sp->ttis[i].tt_isdst) { + break; + } + } + } + /* The next heuristics are for data generated by tzdb 2018e or + earlier, for zones like EST5EDT where the first transition + is to DST. */ + /* + ** If no result yet, find the first standard type. + ** If there is none, punt to type zero. + */ + if (i < 0) { + i = 0; + while (sp->ttis[i].tt_isdst) { + if (++i >= sp->typecnt) { + i = 0; + break; + } + } + } + /* A simple 'sp->defaulttype = 0;' would suffice here if we + didn't have to worry about 2018e-or-earlier data. Even + simpler would be to remove the defaulttype member and just + use 0 in its place. */ + sp->defaulttype = i; + + return 0; +} + +constexpr int tmcomp(const CalendarTimeInternal* const atmp, + const CalendarTimeInternal* const btmp) { + int result; + + if (atmp->tm_year != btmp->tm_year) { + return atmp->tm_year < btmp->tm_year ? -1 : 1; + } + if ((result = (atmp->tm_mon - btmp->tm_mon)) == 0 && + (result = (atmp->tm_mday - btmp->tm_mday)) == 0 && + (result = (atmp->tm_hour - btmp->tm_hour)) == 0 && + (result = (atmp->tm_min - btmp->tm_min)) == 0) { + result = atmp->tm_sec - btmp->tm_sec; + } + return result; +} + +/* Copy to *DEST from *SRC. Copy only the members needed for mktime, + as other members might not be initialized. */ +constexpr void mktmcpy(struct CalendarTimeInternal* dest, struct CalendarTimeInternal const* src) { + dest->tm_sec = src->tm_sec; + dest->tm_min = src->tm_min; + dest->tm_hour = src->tm_hour; + dest->tm_mday = src->tm_mday; + dest->tm_mon = src->tm_mon; + dest->tm_year = src->tm_year; + dest->tm_isdst = src->tm_isdst; + dest->tm_zone = src->tm_zone; + dest->tm_utoff = src->tm_utoff; + dest->time_index = src->time_index; +} + +constexpr bool normalize_overflow(int* const tensptr, int* const unitsptr, const int base) { + int tensdelta; + + tensdelta = (*unitsptr >= 0) ? (*unitsptr / base) : (-1 - (-1 - *unitsptr) / base); + *unitsptr -= tensdelta * base; + return increment_overflow(tensptr, tensdelta); +} + +constexpr bool normalize_overflow32(s64* tensptr, int* unitsptr, int base) { + int tensdelta; + + tensdelta = (*unitsptr >= 0) ? (*unitsptr / base) : (-1 - (-1 - *unitsptr) / base); + *unitsptr -= tensdelta * base; + return increment_overflow32(tensptr, tensdelta); +} + +int time2sub(time_t* out_time, CalendarTimeInternal* const tmp, + CalendarTimeInternal* (*funcp)(Rule const*, time_t const*, s64, + CalendarTimeInternal*), + Rule const* sp, const s64 offset, bool* okayp, bool do_norm_secs) { + int dir; + int i, j; + int saved_seconds; + s64 li; + time_t lo; + time_t hi; + s64 y; + time_t newt; + time_t t; + CalendarTimeInternal yourtm, mytm; + + *okayp = false; + mktmcpy(&yourtm, tmp); + + if (do_norm_secs) { + if (normalize_overflow(&yourtm.tm_min, &yourtm.tm_sec, SECSPERMIN)) { + return 1; + } + } + if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR)) { + return 1; + } + if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY)) { + return 1; + } + y = yourtm.tm_year; + if (normalize_overflow32(&y, &yourtm.tm_mon, MONSPERYEAR)) { + return 1; + } + /* + ** Turn y into an actual year number for now. + ** It is converted back to an offset from TM_YEAR_BASE later. + */ + if (increment_overflow32(&y, TM_YEAR_BASE)) { + return 1; + } + while (yourtm.tm_mday <= 0) { + if (increment_overflow32(&y, -1)) { + return 1; + } + li = y + (1 < yourtm.tm_mon); + yourtm.tm_mday += year_lengths[isleap(li)]; + } + while (yourtm.tm_mday > DAYSPERLYEAR) { + li = y + (1 < yourtm.tm_mon); + yourtm.tm_mday -= year_lengths[isleap(li)]; + if (increment_overflow32(&y, 1)) { + return 1; + } + } + for (;;) { + i = mon_lengths[isleap(y)][yourtm.tm_mon]; + if (yourtm.tm_mday <= i) { + break; + } + yourtm.tm_mday -= i; + if (++yourtm.tm_mon >= MONSPERYEAR) { + yourtm.tm_mon = 0; + if (increment_overflow32(&y, 1)) { + return 1; + } + } + } + + if (increment_overflow32(&y, -TM_YEAR_BASE)) { + return 1; + } + if (!(INT_MIN <= y && y <= INT_MAX)) { + return 1; + } + yourtm.tm_year = static_cast<s32>(y); + + if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN) { + saved_seconds = 0; + } + else if (yourtm.tm_year < EPOCH_YEAR - TM_YEAR_BASE) { + /* + ** We can't set tm_sec to 0, because that might push the + ** time below the minimum representable time. + ** Set tm_sec to 59 instead. + ** This assumes that the minimum representable time is + ** not in the same minute that a leap second was deleted from, + ** which is a safer assumption than using 58 would be. + */ + if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN)) { + return 1; + } + saved_seconds = yourtm.tm_sec; + yourtm.tm_sec = SECSPERMIN - 1; + } + else { + saved_seconds = yourtm.tm_sec; + yourtm.tm_sec = 0; + } + /* + ** Do a binary search (this works whatever time_t's type is). + */ + lo = TIME_T_MIN; + hi = TIME_T_MAX; + for (;;) { + t = lo / 2 + hi / 2; + if (t < lo) { + t = lo; + } + else if (t > hi) { + t = hi; + } + if (!funcp(sp, &t, offset, &mytm)) { + /* + ** Assume that t is too extreme to be represented in + ** a struct tm; arrange things so that it is less + ** extreme on the next pass. + */ + dir = (t > 0) ? 1 : -1; + } + else { + dir = tmcomp(&mytm, &yourtm); + } + if (dir != 0) { + if (t == lo) { + if (t == TIME_T_MAX) { + return 2; + } + ++t; + ++lo; + } + else if (t == hi) { + if (t == TIME_T_MIN) { + return 2; + } + --t; + --hi; + } + if (lo > hi) { + return 2; + } + if (dir > 0) { + hi = t; + } + else { + lo = t; + } + continue; + } + + if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst) { + break; + } + /* + ** Right time, wrong type. + ** Hunt for right time, right type. + ** It's okay to guess wrong since the guess + ** gets checked. + */ + if (sp == nullptr) { + return 2; + } + for (i = sp->typecnt - 1; i >= 0; --i) { + if (sp->ttis[i].tt_isdst != static_cast<bool>(yourtm.tm_isdst)) { + continue; + } + for (j = sp->typecnt - 1; j >= 0; --j) { + if (sp->ttis[j].tt_isdst == static_cast<bool>(yourtm.tm_isdst)) { + continue; + } + if (ttunspecified(sp, j)) { + continue; + } + newt = (t + sp->ttis[j].tt_utoff - sp->ttis[i].tt_utoff); + if (!funcp(sp, &newt, offset, &mytm)) { + continue; + } + if (tmcomp(&mytm, &yourtm) != 0) { + continue; + } + if (mytm.tm_isdst != yourtm.tm_isdst) { + continue; + } + /* + ** We have a match. + */ + t = newt; + goto label; + } + } + return 2; + } +label: + newt = t + saved_seconds; + t = newt; + if (funcp(sp, &t, offset, tmp) || *okayp) { + *okayp = true; + *out_time = t; + return 0; + } + return 2; +} + +int time2(time_t* out_time, struct CalendarTimeInternal* const tmp, + struct CalendarTimeInternal* (*funcp)(struct Rule const*, time_t const*, s64, + struct CalendarTimeInternal*), + struct Rule const* sp, const s64 offset, bool* okayp) { + int res; + + /* + ** First try without normalization of seconds + ** (in case tm_sec contains a value associated with a leap second). + ** If that fails, try with normalization of seconds. + */ + res = time2sub(out_time, tmp, funcp, sp, offset, okayp, false); + return *okayp ? res : time2sub(out_time, tmp, funcp, sp, offset, okayp, true); +} + +int time1(time_t* out_time, CalendarTimeInternal* const tmp, + CalendarTimeInternal* (*funcp)(Rule const*, time_t const*, s64, + CalendarTimeInternal*), + Rule const* sp, const s64 offset) { + int samei, otheri; + int sameind, otherind; + int i; + int nseen; + char seen[TZ_MAX_TYPES]; + unsigned char types[TZ_MAX_TYPES]; + bool okay; + + if (tmp->tm_isdst > 1) { + tmp->tm_isdst = 1; + } + auto res = time2(out_time, tmp, funcp, sp, offset, &okay); + if (res == 0) { + return res; + } + if (tmp->tm_isdst < 0) { + return res; + } + /* + ** We're supposed to assume that somebody took a time of one type + ** and did some math on it that yielded a "struct tm" that's bad. + ** We try to divine the type they started from and adjust to the + ** type they need. + */ + for (i = 0; i < sp->typecnt; ++i) { + seen[i] = false; + } + + if (sp->timecnt < 1) { + return 2; + } + + nseen = 0; + for (i = sp->timecnt - 1; i >= 0; --i) { + if (!seen[sp->types[i]] && !ttunspecified(sp, sp->types[i])) { + seen[sp->types[i]] = true; + types[nseen++] = sp->types[i]; + } + } + + if (nseen < 1) { + return 2; + } + + for (sameind = 0; sameind < nseen; ++sameind) { + samei = types[sameind]; + if (sp->ttis[samei].tt_isdst != static_cast<bool>(tmp->tm_isdst)) { + continue; + } + for (otherind = 0; otherind < nseen; ++otherind) { + otheri = types[otherind]; + if (sp->ttis[otheri].tt_isdst == static_cast<bool>(tmp->tm_isdst)) { + continue; + } + tmp->tm_sec += (sp->ttis[otheri].tt_utoff - sp->ttis[samei].tt_utoff); + tmp->tm_isdst = !tmp->tm_isdst; + res = time2(out_time, tmp, funcp, sp, offset, &okay); + if (res == 0) { + return res; + } + tmp->tm_sec -= (sp->ttis[otheri].tt_utoff - sp->ttis[samei].tt_utoff); + tmp->tm_isdst = !tmp->tm_isdst; + } + } + return 2; +} + +} // namespace + +s32 ParseTimeZoneBinary(Rule& out_rule, std::span<const u8> binary) { + tzloadbody_local_storage.binary = binary; + if (tzloadbody(&out_rule, tzloadbody_local_storage)) { + return 3; + } + return 0; +} + +bool localtime_rz(CalendarTimeInternal* tmp, Rule* sp, time_t* timep) { + return localsub(sp, timep, 0, tmp) == nullptr; +} + +u32 mktime_tzname(time_t* out_time, Rule* sp, CalendarTimeInternal* tmp) { + return time1(out_time, tmp, localsub, sp, 0); +} + +} // namespace Tz |