// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <climits>
#include <limits>
#include "common/assert.h"
#include "common/logging/log.h"
#include "core/file_sys/content_archive.h"
#include "core/file_sys/nca_metadata.h"
#include "core/file_sys/registered_cache.h"
#include "core/hle/service/time/time_zone_manager.h"
#include "core/hle/service/time/time_zone_types.h"
namespace Service::Time::TimeZone {
static constexpr s32 epoch_year{1970};
static constexpr s32 year_base{1900};
static constexpr s32 epoch_week_day{4};
static constexpr s32 seconds_per_minute{60};
static constexpr s32 minutes_per_hour{60};
static constexpr s32 hours_per_day{24};
static constexpr s32 days_per_week{7};
static constexpr s32 days_per_normal_year{365};
static constexpr s32 days_per_leap_year{366};
static constexpr s32 months_per_year{12};
static constexpr s32 seconds_per_hour{seconds_per_minute * minutes_per_hour};
static constexpr s32 seconds_per_day{seconds_per_hour * hours_per_day};
static constexpr s32 years_per_repeat{400};
static constexpr s64 average_seconds_per_year{31556952};
static constexpr s64 seconds_per_repeat{years_per_repeat * average_seconds_per_year};
struct Rule {
enum class Type : u32 { JulianDay, DayOfYear, MonthNthDayOfWeek };
Type rule_type{};
s32 day{};
s32 week{};
s32 month{};
s32 transition_time{};
};
struct CalendarTimeInternal {
s64 year{};
s8 month{};
s8 day{};
s8 hour{};
s8 minute{};
s8 second{};
int Compare(const CalendarTimeInternal& other) const {
if (year != other.year) {
if (year < other.year) {
return -1;
}
return 1;
}
if (month != other.month) {
return month - other.month;
}
if (day != other.day) {
return day - other.day;
}
if (hour != other.hour) {
return hour - other.hour;
}
if (minute != other.minute) {
return minute - other.minute;
}
if (second != other.second) {
return second - other.second;
}
return {};
}
};
template <typename TResult, typename TOperand>
static bool SafeAdd(TResult& result, TOperand op) {
result = result + op;
return true;
}
template <typename TResult, typename TUnit, typename TBase>
static bool SafeNormalize(TResult& result, TUnit& unit, TBase base) {
TUnit delta{};
if (unit >= 0) {
delta = unit / base;
} else {
delta = -1 - (-1 - unit) / base;
}
unit -= delta * base;
return SafeAdd(result, delta);
}
template <typename T>
static constexpr bool IsLeapYear(T year) {
return ((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0);
}
template <typename T>
static constexpr T GetYearLengthInDays(T year) {
return IsLeapYear(year) ? days_per_leap_year : days_per_normal_year;
}
static constexpr s64 GetLeapDaysFromYearPositive(s64 year) {
return year / 4 - year / 100 + year / years_per_repeat;
}
static constexpr s64 GetLeapDaysFromYear(s64 year) {
if (year < 0) {
return -1 - GetLeapDaysFromYearPositive(-1 - year);
} else {
return GetLeapDaysFromYearPositive(year);
}
}
static constexpr s8 GetMonthLength(bool is_leap_year, int month) {
constexpr std::array<s8, 12> month_lengths{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
constexpr std::array<s8, 12> month_lengths_leap{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
return is_leap_year ? month_lengths_leap[month] : month_lengths[month];
}
static constexpr bool IsDigit(char value) {
return value >= '0' && value <= '9';
}
static constexpr int GetQZName(const char* name, int offset, char delimiter) {
while (name[offset] != '\0' && name[offset] != delimiter) {
offset++;
}
return offset;
}
static constexpr int GetTZName(const char* name, int offset) {
char c;
while ((c = name[offset]) != '\0' && !IsDigit(c) && c != ',' && c != '-' && c != '+') {
++offset;
}
return offset;
}
static constexpr bool GetInteger(const char* name, int& offset, int& value, int min, int max) {
value = 0;
char temp{name[offset]};
if (!IsDigit(temp)) {
return {};
}
do {
value = value * 10 + (temp - '0');
if (value > max) {
return {};
}
offset++;
temp = name[offset];
} while (IsDigit(temp));
return value >= min;
}
static constexpr bool GetSeconds(const char* name, int& offset, int& seconds) {
seconds = 0;
int value{};
if (!GetInteger(name, offset, value, 0, hours_per_day * days_per_week - 1)) {
return {};
}
seconds = value * seconds_per_hour;
if (name[offset] == ':') {
offset++;
if (!GetInteger(name, offset, value, 0, minutes_per_hour - 1)) {
return {};
}
seconds += value * seconds_per_minute;
if (name[offset] == ':') {
offset++;
if (!GetInteger(name, offset, value, 0, seconds_per_minute)) {
return {};
}
seconds += value;
}
}
return true;
}
static constexpr bool GetOffset(const char* name, int& offset, int& value) {
bool is_negative{};
if (name[offset] == '-') {
is_negative = true;
offset++;
} else if (name[offset] == '+') {
offset++;
}
if (!GetSeconds(name, offset, value)) {
return {};
}
if (is_negative) {
value = -value;
}
return true;
}
static constexpr bool GetRule(const char* name, int& position, Rule& rule) {
bool is_valid{};
if (name[position] == 'J') {
position++;
rule.rule_type = Rule::Type::JulianDay;
is_valid = GetInteger(name, position, rule.day, 1, days_per_normal_year);
} else if (name[position] == 'M') {
position++;
rule.rule_type = Rule::Type::MonthNthDayOfWeek;
is_valid = GetInteger(name, position, rule.month, 1, months_per_year);
if (!is_valid) {
return {};
}
if (name[position++] != '.') {
return {};
}
is_valid = GetInteger(name, position, rule.week, 1, 5);
if (!is_valid) {
return {};
}
if (name[position++] != '.') {
return {};
}
is_valid = GetInteger(name, position, rule.day, 0, days_per_week - 1);
} else if (isdigit(name[position])) {
rule.rule_type = Rule::Type::DayOfYear;
is_valid = GetInteger(name, position, rule.day, 0, days_per_leap_year - 1);
} else {
return {};
}
if (!is_valid) {
return {};
}
if (name[position] == '/') {
position++;
return GetOffset(name, position, rule.transition_time);
} else {
rule.transition_time = 2 * seconds_per_hour;
}
return true;
}
static constexpr int TransitionTime(int year, Rule rule, int offset) {
int value{};
switch (rule.rule_type) {
case Rule::Type::JulianDay:
value = (rule.day - 1) * seconds_per_day;
if (IsLeapYear(year) && rule.day >= 60) {
value += seconds_per_day;
}
break;
case Rule::Type::DayOfYear:
value = rule.day * seconds_per_day;
break;
case Rule::Type::MonthNthDayOfWeek: {
// Use Zeller's Congruence (https://en.wikipedia.org/wiki/Zeller%27s_congruence) to
// calculate the day of the week for any Julian or Gregorian calendar date.
const int m1{(rule.month + 9) % 12 + 1};
const int yy0{(rule.month <= 2) ? (year - 1) : year};
const int yy1{yy0 / 100};
const int yy2{yy0 % 100};
int day_of_week{((26 * m1 - 2) / 10 + 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7};
if (day_of_week < 0) {
day_of_week += days_per_week;
}
int day{rule.day - day_of_week};
if (day < 0) {
day += days_per_week;
}
for (int i{1}; i < rule.week; i++) {
if (day + days_per_week >= GetMonthLength(IsLeapYear(year), rule.month - 1)) {
break;
}
day += days_per_week;
}
value = day * seconds_per_day;
for (int index{}; index < rule.month - 1; ++index) {
value += GetMonthLength(IsLeapYear(year), index) * seconds_per_day;
}
break;
}
default:
ASSERT(false);
break;
}
return value + rule.transition_time + offset;
}
static bool ParsePosixName(const char* name, TimeZoneRule& rule) {
static constexpr char default_rule[]{",M4.1.0,M10.5.0"};
const char* std_name{name};
int std_len{};
int offset{};
int std_offset{};
if (name[offset] == '<') {
offset++;
std_name = name + offset;
const int std_name_offset{offset};
offset = GetQZName(name, offset, '>');
if (name[offset] != '>') {
return {};
}
std_len = offset - std_name_offset;
offset++;
} else {
offset = GetTZName(name, offset);
std_len = offset;
}
if (std_len == 0) {
return {};
}
if (!GetOffset(name, offset, std_offset)) {
return {};
}
int char_count{std_len + 1};
int dest_len{};
int dest_offset{};
const char* dest_name{name + offset};
if (rule.chars.size() < std::size_t(char_count)) {
return {};
}
if (name[offset] != '\0') {
if (name[offset] == '<') {
dest_name = name + (++offset);
const int dest_name_offset{offset};
offset = GetQZName(name, offset, '>');
if (name[offset] != '>') {
return {};
}
dest_len = offset - dest_name_offset;
offset++;
} else {
dest_name = name + (offset);
offset = GetTZName(name, offset);
dest_len = offset;
}
if (dest_len == 0) {
return {};
}
char_count += dest_len + 1;
if (rule.chars.size() < std::size_t(char_count)) {
return {};
}
if (name[offset] != '\0' && name[offset] != ',' && name[offset] != ';') {
if (!GetOffset(name, offset, dest_offset)) {
return {};
}
} else {
dest_offset = std_offset - seconds_per_hour;
}
if (name[offset] == '\0') {
name = default_rule;
offset = 0;
}
if (name[offset] == ',' || name[offset] == ';') {
offset++;
Rule start{};
if (!GetRule(name, offset, start)) {
return {};
}
if (name[offset++] != ',') {
return {};
}
Rule end{};
if (!GetRule(name, offset, end)) {
return {};
}
if (name[offset] != '\0') {
return {};
}
rule.type_count = 2;
rule.ttis[0].gmt_offset = -dest_offset;
rule.ttis[0].is_dst = true;
rule.ttis[0].abbreviation_list_index = std_len + 1;
rule.ttis[1].gmt_offset = -std_offset;
rule.ttis[1].is_dst = false;
rule.ttis[1].abbreviation_list_index = 0;
rule.default_type = 0;
s64 jan_first{};
int time_count{};
int jan_offset{};
int year_beginning{epoch_year};
do {
const int year_seconds{GetYearLengthInDays(year_beginning - 1) * seconds_per_day};
year_beginning--;
if (!SafeAdd(jan_first, -year_seconds)) {
jan_offset = -year_seconds;
break;
}
} while (epoch_year - years_per_repeat / 2 < year_beginning);
int year_limit{year_beginning + years_per_repeat + 1};
int year{};
for (year = year_beginning; year < year_limit; year++) {
int start_time{TransitionTime(year, start, std_offset)};
int end_time{TransitionTime(year, end, dest_offset)};
const int year_seconds{GetYearLengthInDays(year) * seconds_per_day};
const bool is_reversed{end_time < start_time};
if (is_reversed) {
int swap{start_time};
start_time = end_time;
end_time = swap;
}
if (is_reversed ||
(start_time < end_time &&
(end_time - start_time < (year_seconds + (std_offset - dest_offset))))) {
if (rule.ats.size() - 2 < std::size_t(time_count)) {
break;
}
rule.ats[time_count] = jan_first;
if (SafeAdd(rule.ats[time_count], jan_offset + start_time)) {
rule.types[time_count++] = is_reversed ? 1 : 0;
} else if (jan_offset != 0) {
rule.default_type = is_reversed ? 1 : 0;
}
rule.ats[time_count] = jan_first;
if (SafeAdd(rule.ats[time_count], jan_offset + end_time)) {
rule.types[time_count++] = is_reversed ? 0 : 1;
year_limit = year + years_per_repeat + 1;
} else if (jan_offset != 0) {
rule.default_type = is_reversed ? 0 : 1;
}
}
if (!SafeAdd(jan_first, jan_offset + year_seconds)) {
break;
}
jan_offset = 0;
}
rule.time_count = time_count;
if (time_count == 0) {
rule.type_count = 1;
} else if (years_per_repeat < year - year_beginning) {
rule.go_back = true;
rule.go_ahead = true;
}
} else {
if (name[offset] == '\0') {
return {};
}
s64 their_std_offset{};
for (int index{}; index < rule.time_count; ++index) {
const s8 type{rule.types[index]};
if (rule.ttis[type].is_standard_time_daylight) {
their_std_offset = -rule.ttis[type].gmt_offset;
}
}
s64 their_offset{their_std_offset};
for (int index{}; index < rule.time_count; ++index) {
const s8 type{rule.types[index]};
rule.types[index] = rule.ttis[type].is_dst ? 1 : 0;
if (!rule.ttis[type].is_gmt) {
if (!rule.ttis[type].is_standard_time_daylight) {
rule.ats[index] += dest_offset - their_std_offset;
} else {
rule.ats[index] += std_offset - their_std_offset;
}
}
their_offset = -rule.ttis[type].gmt_offset;
if (!rule.ttis[type].is_dst) {
their_std_offset = their_offset;
}
}
if (rule.time_count > 0) {
UNIMPLEMENTED();
// TODO (lat9nq): Implement eggert/tz/localtime.c:tzparse:1329
// Seems to be unused in yuzu for now: I never hit the UNIMPLEMENTED in testing
}
rule.ttis[0].gmt_offset = -std_offset;
rule.ttis[0].is_dst = false;
rule.ttis[0].abbreviation_list_index = 0;
rule.ttis[1].gmt_offset = -dest_offset;
rule.ttis[1].is_dst = true;
rule.ttis[1].abbreviation_list_index = std_len + 1;
rule.type_count = 2;
rule.default_type = 0;
}
} else {
// Default is standard time
rule.type_count = 1;
rule.time_count = 0;
rule.default_type = 0;
rule.ttis[0].gmt_offset = -std_offset;
rule.ttis[0].is_dst = false;
rule.ttis[0].abbreviation_list_index = 0;
}
rule.char_count = char_count;
for (int index{}; index < std_len; ++index) {
rule.chars[index] = std_name[index];
}
rule.chars[std_len++] = '\0';
if (dest_len != 0) {
for (int index{}; index < dest_len; ++index) {
rule.chars[std_len + index] = dest_name[index];
}
rule.chars[std_len + dest_len] = '\0';
}
return true;
}
static bool ParseTimeZoneBinary(TimeZoneRule& time_zone_rule, FileSys::VirtualFile& vfs_file) {
TzifHeader header{};
if (vfs_file->ReadObject<TzifHeader>(&header) != sizeof(TzifHeader)) {
return {};
}
constexpr s32 time_zone_max_leaps{50};
constexpr s32 time_zone_max_chars{50};
constexpr s32 time_zone_max_times{1000};
if (!(0 <= header.leap_count && header.leap_count < time_zone_max_leaps &&
0 < header.type_count && header.type_count < s32(time_zone_rule.ttis.size()) &&
0 <= header.time_count && header.time_count < s32(time_zone_rule.ats.size()) &&
0 <= header.char_count && header.char_count < time_zone_max_chars &&
(header.ttis_std_count == header.type_count || header.ttis_std_count == 0) &&
(header.ttis_gmt_count == header.type_count || header.ttis_gmt_count == 0))) {
return {};
}
time_zone_rule.time_count = header.time_count;
time_zone_rule.type_count = header.type_count;
time_zone_rule.char_count = header.char_count;
int time_count{};
u64 read_offset = sizeof(TzifHeader);
for (int index{}; index < time_zone_rule.time_count; ++index) {
s64_be at{};
vfs_file->ReadObject<s64_be>(&at, read_offset);
time_zone_rule.types[index] = 1;
if (time_count != 0 && at <= time_zone_rule.ats[time_count - 1]) {
if (at < time_zone_rule.ats[time_count - 1]) {
return {};
}
time_zone_rule.types[index - 1] = 0;
time_count--;
}
time_zone_rule.ats[time_count++] = at;
read_offset += sizeof(s64_be);
}
time_count = 0;
for (int index{}; index < time_zone_rule.time_count; ++index) {
const u8 type{*vfs_file->ReadByte(read_offset)};
read_offset += sizeof(u8);
if (time_zone_rule.time_count <= type) {
return {};
}
if (time_zone_rule.types[index] != 0) {
time_zone_rule.types[time_count++] = type;
}
}
time_zone_rule.time_count = time_count;
for (int index{}; index < time_zone_rule.type_count; ++index) {
TimeTypeInfo& ttis{time_zone_rule.ttis[index]};
u32_be gmt_offset{};
vfs_file->ReadObject<u32_be>(&gmt_offset, read_offset);
read_offset += sizeof(u32_be);
ttis.gmt_offset = gmt_offset;
const u8 dst{*vfs_file->ReadByte(read_offset)};
read_offset += sizeof(u8);
if (dst >= 2) {
return {};
}
ttis.is_dst = dst != 0;
const s32 abbreviation_list_index{*vfs_file->ReadByte(read_offset)};
read_offset += sizeof(u8);
if (abbreviation_list_index >= time_zone_rule.char_count) {
return {};
}
ttis.abbreviation_list_index = abbreviation_list_index;
}
vfs_file->ReadArray(time_zone_rule.chars.data(), time_zone_rule.char_count, read_offset);
time_zone_rule.chars[time_zone_rule.char_count] = '\0';
read_offset += time_zone_rule.char_count;
for (int index{}; index < time_zone_rule.type_count; ++index) {
if (header.ttis_std_count == 0) {
time_zone_rule.ttis[index].is_standard_time_daylight = false;
} else {
const u8 dst{*vfs_file->ReadByte(read_offset)};
read_offset += sizeof(u8);
if (dst >= 2) {
return {};
}
time_zone_rule.ttis[index].is_standard_time_daylight = dst != 0;
}
}
for (int index{}; index < time_zone_rule.type_count; ++index) {
if (header.ttis_std_count == 0) {
time_zone_rule.ttis[index].is_gmt = false;
} else {
const u8 dst{*vfs_file->ReadByte(read_offset)};
read_offset += sizeof(u8);
if (dst >= 2) {
return {};
}
time_zone_rule.ttis[index].is_gmt = dst != 0;
}
}
const u64 position{(read_offset - sizeof(TzifHeader))};
const s64 bytes_read = s64(vfs_file->GetSize() - sizeof(TzifHeader) - position);
if (bytes_read < 0) {
return {};
}
constexpr s32 time_zone_name_max{255};
if (bytes_read > (time_zone_name_max + 1)) {
return {};
}
std::array<char, time_zone_name_max + 1> temp_name{};
vfs_file->ReadArray(temp_name.data(), bytes_read, read_offset);
if (bytes_read > 2 && temp_name[0] == '\n' && temp_name[bytes_read - 1] == '\n' &&
std::size_t(time_zone_rule.type_count) + 2 <= time_zone_rule.ttis.size()) {
temp_name[bytes_read - 1] = '\0';
std::array<char, time_zone_name_max> name{};
std::memcpy(name.data(), temp_name.data() + 1, std::size_t(bytes_read - 1));
// Fill in computed transition times with temp rule
TimeZoneRule temp_rule;
if (ParsePosixName(name.data(), temp_rule)) {
int have_abbreviation = 0;
int char_count = time_zone_rule.char_count;
for (int i = 0; i < temp_rule.type_count; i++) {
char* temp_abbreviation =
temp_rule.chars.data() + temp_rule.ttis[i].abbreviation_list_index;
int j;
for (j = 0; j < char_count; j++) {
if (std::strcmp(time_zone_rule.chars.data() + j, temp_abbreviation) == 0) {
temp_rule.ttis[i].abbreviation_list_index = j;
have_abbreviation++;
break;
}
}
if (j >= char_count) {
int temp_abbreviation_length = static_cast<int>(std::strlen(temp_abbreviation));
if (j + temp_abbreviation_length < time_zone_max_chars) {
std::strcpy(time_zone_rule.chars.data() + j, temp_abbreviation);
char_count = j + temp_abbreviation_length + 1;
temp_rule.ttis[i].abbreviation_list_index = j;
have_abbreviation++;
}
}
}
if (have_abbreviation == temp_rule.type_count) {
time_zone_rule.char_count = char_count;
// Original comment:
/* 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. */
// This is possibly unnecessary for yuzu, since Nintendo doesn't run zic
while (1 < time_zone_rule.time_count &&
(time_zone_rule.types[time_zone_rule.time_count - 1] ==
time_zone_rule.types[time_zone_rule.time_count - 2])) {
time_zone_rule.time_count--;
}
for (int i = 0;
i < temp_rule.time_count && time_zone_rule.time_count < time_zone_max_times;
i++) {
const s64 transition_time = temp_rule.ats[i];
if (0 < time_zone_rule.time_count &&
transition_time <= time_zone_rule.ats[time_zone_rule.time_count - 1]) {
continue;
}
time_zone_rule.ats[time_zone_rule.time_count] = transition_time;
time_zone_rule.types[time_zone_rule.time_count] =
static_cast<s8>(time_zone_rule.type_count + temp_rule.types[i]);
time_zone_rule.time_count++;
}
for (int i = 0; i < temp_rule.type_count; i++) {
time_zone_rule.ttis[time_zone_rule.type_count++] = temp_rule.ttis[i];
}
}
}
}
const auto typesequiv = [](TimeZoneRule& rule, int a, int b) -> bool {
if (a < 0 || a >= rule.type_count || b < 0 || b >= rule.type_count) {
return {};
}
const struct TimeTypeInfo* ap = &rule.ttis[a];
const struct TimeTypeInfo* bp = &rule.ttis[b];
return (ap->gmt_offset == bp->gmt_offset && ap->is_dst == bp->is_dst &&
(std::strcmp(&rule.chars[ap->abbreviation_list_index],
&rule.chars[bp->abbreviation_list_index]) == 0));
};
if (time_zone_rule.type_count == 0) {
return {};
}
if (time_zone_rule.time_count > 1) {
if (time_zone_rule.ats[0] <= std::numeric_limits<s64>::max() - seconds_per_repeat) {
s64 repeatat = time_zone_rule.ats[0] + seconds_per_repeat;
int repeatattype = time_zone_rule.types[0];
for (int i = 1; i < time_zone_rule.time_count; ++i) {
if (time_zone_rule.ats[i] == repeatat &&
typesequiv(time_zone_rule, time_zone_rule.types[i], repeatattype)) {
time_zone_rule.go_back = true;
break;
}
}
}
if (std::numeric_limits<s64>::min() + seconds_per_repeat <=
time_zone_rule.ats[time_zone_rule.time_count - 1]) {
s64 repeatat = time_zone_rule.ats[time_zone_rule.time_count - 1] - seconds_per_repeat;
int repeatattype = time_zone_rule.types[time_zone_rule.time_count - 1];
for (int i = time_zone_rule.time_count; i >= 0; --i) {
if (time_zone_rule.ats[i] == repeatat &&
typesequiv(time_zone_rule, time_zone_rule.types[i], repeatattype)) {
time_zone_rule.go_ahead = true;
break;
}
}
}
}
s32 default_type{};
for (default_type = 0; default_type < time_zone_rule.time_count; default_type++) {
if (time_zone_rule.types[default_type] == 0) {
break;
}
}
default_type = default_type < time_zone_rule.time_count ? -1 : 0;
if (default_type < 0 && time_zone_rule.time_count > 0 &&
time_zone_rule.ttis[time_zone_rule.types[0]].is_dst) {
default_type = time_zone_rule.types[0];
while (--default_type >= 0) {
if (!time_zone_rule.ttis[default_type].is_dst) {
break;
}
}
}
if (default_type < 0) {
default_type = 0;
while (time_zone_rule.ttis[default_type].is_dst) {
if (++default_type >= time_zone_rule.type_count) {
default_type = 0;
break;
}
}
}
time_zone_rule.default_type = default_type;
return true;
}
static Result CreateCalendarTime(s64 time, int gmt_offset, CalendarTimeInternal& calendar_time,
CalendarAdditionalInfo& calendar_additional_info) {
s64 year{epoch_year};
s64 time_days{time / seconds_per_day};
s64 remaining_seconds{time % seconds_per_day};
while (time_days < 0 || time_days >= GetYearLengthInDays(year)) {
s64 delta = time_days / days_per_leap_year;
if (!delta) {
delta = time_days < 0 ? -1 : 1;
}
s64 new_year{year};
if (!SafeAdd(new_year, delta)) {
return ERROR_OUT_OF_RANGE;
}
time_days -= (new_year - year) * days_per_normal_year;
time_days -= GetLeapDaysFromYear(new_year - 1) - GetLeapDaysFromYear(year - 1);
year = new_year;
}
s64 day_of_year{time_days};
remaining_seconds += gmt_offset;
while (remaining_seconds < 0) {
remaining_seconds += seconds_per_day;
day_of_year--;
}
while (remaining_seconds >= seconds_per_day) {
remaining_seconds -= seconds_per_day;
day_of_year++;
}
while (day_of_year < 0) {
if (!SafeAdd(year, -1)) {
return ERROR_OUT_OF_RANGE;
}
day_of_year += GetYearLengthInDays(year);
}
while (day_of_year >= GetYearLengthInDays(year)) {
day_of_year -= GetYearLengthInDays(year);
if (!SafeAdd(year, 1)) {
return ERROR_OUT_OF_RANGE;
}
}
calendar_time.year = year;
calendar_additional_info.day_of_year = static_cast<u32>(day_of_year);
s64 day_of_week{
(epoch_week_day +
((year - epoch_year) % days_per_week) * (days_per_normal_year % days_per_week) +
GetLeapDaysFromYear(year - 1) - GetLeapDaysFromYear(epoch_year - 1) + day_of_year) %
days_per_week};
if (day_of_week < 0) {
day_of_week += days_per_week;
}
calendar_additional_info.day_of_week = static_cast<u32>(day_of_week);
calendar_time.hour = static_cast<s8>((remaining_seconds / seconds_per_hour) % seconds_per_hour);
remaining_seconds %= seconds_per_hour;
calendar_time.minute = static_cast<s8>(remaining_seconds / seconds_per_minute);
calendar_time.second = static_cast<s8>(remaining_seconds % seconds_per_minute);
for (calendar_time.month = 0;
day_of_year >= GetMonthLength(IsLeapYear(year), calendar_time.month);
++calendar_time.month) {
day_of_year -= GetMonthLength(IsLeapYear(year), calendar_time.month);
}
calendar_time.day = static_cast<s8>(day_of_year + 1);
calendar_additional_info.is_dst = false;
calendar_additional_info.gmt_offset = gmt_offset;
return ResultSuccess;
}
static Result ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
CalendarTimeInternal& calendar_time,
CalendarAdditionalInfo& calendar_additional_info) {
if ((rules.go_ahead && time < rules.ats[0]) ||
(rules.go_back && time > rules.ats[rules.time_count - 1])) {
s64 seconds{};
if (time < rules.ats[0]) {
seconds = rules.ats[0] - time;
} else {
seconds = time - rules.ats[rules.time_count - 1];
}
seconds--;
const s64 years{(seconds / seconds_per_repeat + 1) * years_per_repeat};
seconds = years * average_seconds_per_year;
s64 new_time{time};
if (time < rules.ats[0]) {
new_time += seconds;
} else {
new_time -= seconds;
}
if (new_time < rules.ats[0] && new_time > rules.ats[rules.time_count - 1]) {
return ERROR_TIME_NOT_FOUND;
}
if (const Result result{
ToCalendarTimeInternal(rules, new_time, calendar_time, calendar_additional_info)};
result != ResultSuccess) {
return result;
}
if (time < rules.ats[0]) {
calendar_time.year -= years;
} else {
calendar_time.year += years;
}
return ResultSuccess;
}
s32 tti_index{};
if (rules.time_count == 0 || time < rules.ats[0]) {
tti_index = rules.default_type;
} else {
s32 low{1};
s32 high{rules.time_count};
while (low < high) {
s32 mid{(low + high) >> 1};
if (time < rules.ats[mid]) {
high = mid;
} else {
low = mid + 1;
}
}
tti_index = rules.types[low - 1];
}
if (const Result result{CreateCalendarTime(time, rules.ttis[tti_index].gmt_offset,
calendar_time, calendar_additional_info)};
result != ResultSuccess) {
return result;
}
calendar_additional_info.is_dst = rules.ttis[tti_index].is_dst;
const char* time_zone{&rules.chars[rules.ttis[tti_index].abbreviation_list_index]};
for (int index{}; time_zone[index] != '\0'; ++index) {
calendar_additional_info.timezone_name[index] = time_zone[index];
}
return ResultSuccess;
}
static Result ToCalendarTimeImpl(const TimeZoneRule& rules, s64 time, CalendarInfo& calendar) {
CalendarTimeInternal calendar_time{};
const Result result{
ToCalendarTimeInternal(rules, time, calendar_time, calendar.additional_info)};
calendar.time.year = static_cast<s16>(calendar_time.year);
// Internal impl. uses 0-indexed month
calendar.time.month = static_cast<s8>(calendar_time.month + 1);
calendar.time.day = calendar_time.day;
calendar.time.hour = calendar_time.hour;
calendar.time.minute = calendar_time.minute;
calendar.time.second = calendar_time.second;
return result;
}
TimeZoneManager::TimeZoneManager() = default;
TimeZoneManager::~TimeZoneManager() = default;
Result TimeZoneManager::ToCalendarTime(const TimeZoneRule& rules, s64 time,
CalendarInfo& calendar) const {
return ToCalendarTimeImpl(rules, time, calendar);
}
Result TimeZoneManager::SetDeviceLocationNameWithTimeZoneRule(const std::string& location_name,
FileSys::VirtualFile& vfs_file) {
TimeZoneRule rule{};
if (ParseTimeZoneBinary(rule, vfs_file)) {
device_location_name = location_name;
time_zone_rule = rule;
return ResultSuccess;
}
return ERROR_TIME_ZONE_CONVERSION_FAILED;
}
Result TimeZoneManager::SetUpdatedTime(const Clock::SteadyClockTimePoint& value) {
time_zone_update_time_point = value;
return ResultSuccess;
}
Result TimeZoneManager::ToCalendarTimeWithMyRules(s64 time, CalendarInfo& calendar) const {
if (is_initialized) {
return ToCalendarTime(time_zone_rule, time, calendar);
} else {
return ERROR_UNINITIALIZED_CLOCK;
}
}
Result TimeZoneManager::ParseTimeZoneRuleBinary(TimeZoneRule& rules,
FileSys::VirtualFile& vfs_file) const {
if (!ParseTimeZoneBinary(rules, vfs_file)) {
return ERROR_TIME_ZONE_CONVERSION_FAILED;
}
return ResultSuccess;
}
Result TimeZoneManager::ToPosixTime(const TimeZoneRule& rules, const CalendarTime& calendar_time,
s64& posix_time) const {
posix_time = 0;
CalendarTimeInternal internal_time{
.year = calendar_time.year,
// Internal impl. uses 0-indexed month
.month = static_cast<s8>(calendar_time.month - 1),
.day = calendar_time.day,
.hour = calendar_time.hour,
.minute = calendar_time.minute,
.second = calendar_time.second,
};
s32 hour{internal_time.hour};
s32 minute{internal_time.minute};
if (!SafeNormalize(hour, minute, minutes_per_hour)) {
return ERROR_OVERFLOW;
}
internal_time.minute = static_cast<s8>(minute);
s32 day{internal_time.day};
if (!SafeNormalize(day, hour, hours_per_day)) {
return ERROR_OVERFLOW;
}
internal_time.day = static_cast<s8>(day);
internal_time.hour = static_cast<s8>(hour);
s64 year{internal_time.year};
s64 month{internal_time.month};
if (!SafeNormalize(year, month, months_per_year)) {
return ERROR_OVERFLOW;
}
internal_time.month = static_cast<s8>(month);
if (!SafeAdd(year, year_base)) {
return ERROR_OVERFLOW;
}
while (day <= 0) {
if (!SafeAdd(year, -1)) {
return ERROR_OVERFLOW;
}
s64 temp_year{year};
if (1 < internal_time.month) {
++temp_year;
}
day += static_cast<s32>(GetYearLengthInDays(temp_year));
}
while (day > days_per_leap_year) {
s64 temp_year{year};
if (1 < internal_time.month) {
temp_year++;
}
day -= static_cast<s32>(GetYearLengthInDays(temp_year));
if (!SafeAdd(year, 1)) {
return ERROR_OVERFLOW;
}
}
while (true) {
const s32 month_length{GetMonthLength(IsLeapYear(year), internal_time.month)};
if (day <= month_length) {
break;
}
day -= month_length;
internal_time.month++;
if (internal_time.month >= months_per_year) {
internal_time.month = 0;
if (!SafeAdd(year, 1)) {
return ERROR_OVERFLOW;
}
}
}
internal_time.day = static_cast<s8>(day);
if (!SafeAdd(year, -year_base)) {
return ERROR_OVERFLOW;
}
internal_time.year = year;
s32 saved_seconds{};
if (internal_time.second >= 0 && internal_time.second < seconds_per_minute) {
saved_seconds = 0;
} else if (year + year_base < epoch_year) {
s32 second{internal_time.second};
if (!SafeAdd(second, 1 - seconds_per_minute)) {
return ERROR_OVERFLOW;
}
saved_seconds = second;
internal_time.second = 1 - seconds_per_minute;
} else {
saved_seconds = internal_time.second;
internal_time.second = 0;
}
s64 low{LLONG_MIN};
s64 high{LLONG_MAX};
while (true) {
s64 pivot{low / 2 + high / 2};
if (pivot < low) {
pivot = low;
} else if (pivot > high) {
pivot = high;
}
s32 direction{};
CalendarTimeInternal candidate_calendar_time{};
CalendarAdditionalInfo unused{};
if (ToCalendarTimeInternal(rules, pivot, candidate_calendar_time, unused) !=
ResultSuccess) {
if (pivot > 0) {
direction = 1;
} else {
direction = -1;
}
} else {
direction = candidate_calendar_time.Compare(internal_time);
}
if (!direction) {
const s64 time_result{pivot + saved_seconds};
if ((time_result < pivot) != (saved_seconds < 0)) {
return ERROR_OVERFLOW;
}
posix_time = time_result;
break;
} else {
if (pivot == low) {
if (pivot == LLONG_MAX) {
return ERROR_TIME_NOT_FOUND;
}
pivot++;
low++;
} else if (pivot == high) {
if (pivot == LLONG_MIN) {
return ERROR_TIME_NOT_FOUND;
}
pivot--;
high--;
}
if (low > high) {
return ERROR_TIME_NOT_FOUND;
}
if (direction > 0) {
high = pivot;
} else {
low = pivot;
}
}
}
return ResultSuccess;
}
Result TimeZoneManager::ToPosixTimeWithMyRule(const CalendarTime& calendar_time,
s64& posix_time) const {
if (is_initialized) {
return ToPosixTime(time_zone_rule, calendar_time, posix_time);
}
posix_time = 0;
return ERROR_UNINITIALIZED_CLOCK;
}
Result TimeZoneManager::GetDeviceLocationName(LocationName& value) const {
if (!is_initialized) {
return ERROR_UNINITIALIZED_CLOCK;
}
std::memcpy(value.data(), device_location_name.c_str(), device_location_name.size());
return ResultSuccess;
}
Result TimeZoneManager::GetTotalLocationNameCount(s32& count) const {
if (!is_initialized) {
return ERROR_UNINITIALIZED_CLOCK;
}
count = static_cast<u32>(total_location_name_count);
return ResultSuccess;
}
Result TimeZoneManager::GetTimeZoneRuleVersion(u128& version) const {
if (!is_initialized) {
return ERROR_UNINITIALIZED_CLOCK;
}
version = time_zone_rule_version;
return ResultSuccess;
}
Result TimeZoneManager::LoadLocationNameList(std::vector<LocationName>& values) const {
if (!is_initialized) {
return ERROR_UNINITIALIZED_CLOCK;
}
for (const auto& name : total_location_names) {
LocationName entry{};
std::memcpy(entry.data(), name.c_str(), name.size());
values.push_back(entry);
}
return ResultSuccess;
}
} // namespace Service::Time::TimeZone