Mirrors/yuzu
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

core: Fix clang build

Browse source 
Recent changes to the build system that made more warnings be flagged as
errors caused building via clang to break.

Fixes #4795
This commit is contained in:
Lioncash 2020-10-15 14:49:45 -04:00
parent ca416a0fb8
commit be1954e04c
105 changed files with 906 additions and 667 deletions
Download patch file Download diff file Expand all files Collapse all files

118
src/core/hle/service/time/time_zone_manager.cpp
View file

@ -117,7 +117,8 @@ static constexpr int GetMonthLength(bool is_leap_year, int month) {
constexpr std::array<int, 12> month_lengths{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
constexpr std::array<int, 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];
const auto month_index = static_cast<u32>(month);
return is_leap_year ? month_lengths_leap[month_index] : month_lengths[month_index];
}
static constexpr bool IsDigit(char value) {
@ -320,7 +321,7 @@ static bool ParsePosixName(const char* name, TimeZoneRule& rule) {
int dest_len{};
int dest_offset{};
const char* dest_name{name + offset};
if (rule.chars.size() < std::size_t(char_count)) {
if (rule.chars.size() < static_cast<std::size_t>(char_count)) {
return {};
}
@ -343,7 +344,7 @@ static bool ParsePosixName(const char* name, TimeZoneRule& rule) {
return {};
}
char_count += dest_len + 1;
if (rule.chars.size() < std::size_t(char_count)) {
if (rule.chars.size() < static_cast<std::size_t>(char_count)) {
return {};
}
if (name[offset] != '\0' && name[offset] != ',' && name[offset] != ';') {
@ -386,7 +387,7 @@ static bool ParsePosixName(const char* name, TimeZoneRule& rule) {
rule.default_type = 0;
s64 jan_first{};
int time_count{};
u32 time_count{};
int jan_offset{};
int year_beginning{epoch_year};
do {
@ -414,7 +415,7 @@ static bool ParsePosixName(const char* name, TimeZoneRule& rule) {
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)) {
if (rule.ats.size() - 2 < time_count) {
break;
}
@ -438,7 +439,7 @@ static bool ParsePosixName(const char* name, TimeZoneRule& rule) {
}
jan_offset = 0;
}
rule.time_count = time_count;
rule.time_count = static_cast<s32>(time_count);
if (time_count == 0) {
rule.type_count = 1;
} else if (years_per_repeat < year - year_beginning) {
@ -451,26 +452,30 @@ static bool ParsePosixName(const char* name, TimeZoneRule& rule) {
}
s64 their_std_offset{};
for (int index{}; index < rule.time_count; ++index) {
for (u32 index = 0; index < static_cast<u32>(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;
const auto& tti = rule.ttis[static_cast<u8>(type)];
if (tti.is_standard_time_daylight) {
their_std_offset = -tti.gmt_offset;
}
}
s64 their_offset{their_std_offset};
for (int index{}; index < rule.time_count; ++index) {
for (u32 index = 0; index < static_cast<u32>(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) {
const auto& tti = rule.ttis[static_cast<u8>(type)];
rule.types[index] = tti.is_dst ? 1 : 0;
if (!tti.is_gmt) {
if (!tti.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_offset = -tti.gmt_offset;
if (!tti.is_dst) {
their_std_offset = their_offset;
}
}
@ -494,16 +499,16 @@ static bool ParsePosixName(const char* name, TimeZoneRule& rule) {
}
rule.char_count = char_count;
for (int index{}; index < std_len; ++index) {
for (std::size_t index = 0; index < static_cast<std::size_t>(std_len); ++index) {
rule.chars[index] = std_name[index];
}
rule.chars[std_len++] = '\0';
rule.chars[static_cast<size_t>(std_len++)] = '\0';
if (dest_len != 0) {
for (int index{}; index < dest_len; ++index) {
rule.chars[std_len + index] = dest_name[index];
for (int index = 0; index < dest_len; ++index) {
rule.chars[static_cast<std::size_t>(std_len + index)] = dest_name[index];
}
rule.chars[std_len + dest_len] = '\0';
rule.chars[static_cast<std::size_t>(std_len + dest_len)] = '\0';
}
return true;
@ -531,33 +536,33 @@ static bool ParseTimeZoneBinary(TimeZoneRule& time_zone_rule, FileSys::VirtualFi
int time_count{};
u64 read_offset = sizeof(TzifHeader);
for (int index{}; index < time_zone_rule.time_count; ++index) {
for (size_t index = 0; index < static_cast<size_t>(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]) {
if (time_count != 0 && at <= time_zone_rule.ats[static_cast<size_t>(time_count) - 1]) {
if (at < time_zone_rule.ats[static_cast<size_t>(time_count) - 1]) {
return {};
}
time_zone_rule.types[index - 1] = 0;
time_count--;
}
time_zone_rule.ats[time_count++] = at;
time_zone_rule.ats[static_cast<size_t>(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);
for (size_t index = 0; index < static_cast<size_t>(time_zone_rule.time_count); ++index) {
const auto type{static_cast<s8>(*vfs_file->ReadByte(read_offset))};
read_offset += sizeof(s8);
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.types[static_cast<size_t>(time_count++)] = type;
}
}
time_zone_rule.time_count = time_count;
for (int index{}; index < time_zone_rule.type_count; ++index) {
for (size_t index = 0; index < static_cast<size_t>(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);
@ -579,10 +584,11 @@ static bool ParseTimeZoneBinary(TimeZoneRule& time_zone_rule, FileSys::VirtualFi
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) {
vfs_file->ReadArray(time_zone_rule.chars.data(), static_cast<u32>(time_zone_rule.char_count),
read_offset);
time_zone_rule.chars[static_cast<u32>(time_zone_rule.char_count)] = '\0';
read_offset += static_cast<u64>(time_zone_rule.char_count);
for (size_t index = 0; index < static_cast<size_t>(time_zone_rule.type_count); ++index) {
if (header.ttis_std_count == 0) {
time_zone_rule.ttis[index].is_standard_time_daylight = false;
} else {
@ -595,7 +601,7 @@ static bool ParseTimeZoneBinary(TimeZoneRule& time_zone_rule, FileSys::VirtualFi
}
}
for (int index{}; index < time_zone_rule.type_count; ++index) {
for (size_t index = 0; index < static_cast<size_t>(time_zone_rule.type_count); ++index) {
if (header.ttis_std_count == 0) {
time_zone_rule.ttis[index].is_gmt = false;
} else {
@ -619,13 +625,14 @@ static bool ParseTimeZoneBinary(TimeZoneRule& time_zone_rule, FileSys::VirtualFi
}
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';
vfs_file->ReadArray(temp_name.data(), static_cast<size_t>(bytes_read), read_offset);
if (bytes_read > 2 && temp_name[0] == '\n' &&
temp_name[static_cast<u64>(bytes_read - 1)] == '\n' &&
static_cast<std::size_t>(time_zone_rule.type_count) + 2 <= time_zone_rule.ttis.size()) {
temp_name[static_cast<u64>(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));
std::memcpy(name.data(), temp_name.data() + 1, static_cast<std::size_t>(bytes_read - 1));
TimeZoneRule temp_rule;
if (ParsePosixName(name.data(), temp_rule)) {
@ -642,24 +649,24 @@ static bool ParseTimeZoneBinary(TimeZoneRule& time_zone_rule, FileSys::VirtualFi
s32 default_type{};
for (default_type = 0; default_type < time_zone_rule.time_count; default_type++) {
if (time_zone_rule.types[default_type] == 0) {
if (time_zone_rule.types[static_cast<u32>(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) {
time_zone_rule.ttis[static_cast<u8>(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) {
if (!time_zone_rule.ttis[static_cast<u32>(default_type)].is_dst) {
break;
}
}
}
if (default_type < 0) {
default_type = 0;
while (time_zone_rule.ttis[default_type].is_dst) {
while (time_zone_rule.ttis[static_cast<u32>(default_type)].is_dst) {
if (++default_type >= time_zone_rule.type_count) {
default_type = 0;
break;
@ -749,12 +756,12 @@ static ResultCode 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])) {
(rules.go_back && time > rules.ats[static_cast<size_t>(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 = time - rules.ats[static_cast<size_t>(rules.time_count - 1)];
}
seconds--;
@ -767,7 +774,8 @@ static ResultCode ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
} else {
new_time -= seconds;
}
if (new_time < rules.ats[0] && new_time > rules.ats[rules.time_count - 1]) {
if (new_time < rules.ats[0] &&
new_time > rules.ats[static_cast<size_t>(rules.time_count - 1)]) {
return ERROR_TIME_NOT_FOUND;
}
if (const ResultCode result{
@ -791,25 +799,27 @@ static ResultCode ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
s32 low{1};
s32 high{rules.time_count};
while (low < high) {
s32 mid{(low + high) >> 1};
if (time < rules.ats[mid]) {
const s32 mid{(low + high) >> 1};
if (time < rules.ats[static_cast<size_t>(mid)]) {
high = mid;
} else {
low = mid + 1;
}
}
tti_index = rules.types[low - 1];
tti_index = rules.types[static_cast<size_t>(low - 1)];
}
if (const ResultCode result{CreateCalendarTime(time, rules.ttis[tti_index].gmt_offset,
calendar_time, calendar_additional_info)};
if (const ResultCode result{
CreateCalendarTime(time, rules.ttis[static_cast<u32>(tti_index)].gmt_offset,
calendar_time, calendar_additional_info)};
result != RESULT_SUCCESS) {
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) {
const auto& tti = rules.ttis[static_cast<size_t>(tti_index)];
calendar_additional_info.is_dst = tti.is_dst;
const char* time_zone{&rules.chars[static_cast<size_t>(tti.abbreviation_list_index)]};
for (size_t index = 0; time_zone[index] != '\0'; ++index) {
calendar_additional_info.timezone_name[index] = time_zone[index];
}
return RESULT_SUCCESS;

4
src/core/hle/service/time/time_zone_service.cpp
View file

@ -49,12 +49,12 @@ void ITimeZoneService::LoadTimeZoneRule(Kernel::HLERequestContext& ctx) {
const auto raw_location_name{rp.PopRaw<std::array<u8, 0x24>>()};
std::string location_name;
for (const auto& byte : raw_location_name) {
for (const auto byte : raw_location_name) {
// Strip extra bytes
if (byte == '\0') {
break;
}
location_name.push_back(byte);
location_name.push_back(static_cast<char>(byte));
}
LOG_DEBUG(Service_Time, "called, location_name={}", location_name);