1636 lines
50 KiB
C++
1636 lines
50 KiB
C++
// 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 const* sp, time_t* timep) {
|
|
return localsub(sp, timep, 0, tmp) == nullptr;
|
|
}
|
|
|
|
u32 mktime_tzname(time_t* out_time, Rule const* sp, CalendarTimeInternal* tmp) {
|
|
return time1(out_time, tmp, localsub, sp, 0);
|
|
}
|
|
|
|
} // namespace Tz
|