yuzu-emu
/
yuzu-mainline
Archived
1
0
Fork 0

Merge pull request #4786 from lioncash/flags

core/CMakeLists: Make some warnings errors
This commit is contained in:
Rodrigo Locatti 2020-10-13 16:20:44 -03:00 committed by GitHub
commit c5b3c8d06b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
32 changed files with 3243 additions and 1539 deletions

View File

@ -90,6 +90,9 @@ if (ENABLE_WEB_SERVICE)
target_include_directories(httplib INTERFACE ./httplib) target_include_directories(httplib INTERFACE ./httplib)
target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT) target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES}) target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
if (WIN32)
target_link_libraries(httplib INTERFACE crypt32 cryptui ws2_32)
endif()
endif() endif()
# Opus # Opus

File diff suppressed because it is too large Load Diff

View File

@ -16,14 +16,14 @@ namespace Common {
[[nodiscard]] constexpr u8 ToHexNibble(char c) { [[nodiscard]] constexpr u8 ToHexNibble(char c) {
if (c >= 65 && c <= 70) { if (c >= 65 && c <= 70) {
return c - 55; return static_cast<u8>(c - 55);
} }
if (c >= 97 && c <= 102) { if (c >= 97 && c <= 102) {
return c - 87; return static_cast<u8>(c - 87);
} }
return c - 48; return static_cast<u8>(c - 48);
} }
[[nodiscard]] std::vector<u8> HexStringToVector(std::string_view str, bool little_endian); [[nodiscard]] std::vector<u8> HexStringToVector(std::string_view str, bool little_endian);
@ -33,11 +33,11 @@ template <std::size_t Size, bool le = false>
std::array<u8, Size> out{}; std::array<u8, Size> out{};
if constexpr (le) { if constexpr (le) {
for (std::size_t i = 2 * Size - 2; i <= 2 * Size; i -= 2) { for (std::size_t i = 2 * Size - 2; i <= 2 * Size; i -= 2) {
out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]); out[i / 2] = static_cast<u8>((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
} }
} else { } else {
for (std::size_t i = 0; i < 2 * Size; i += 2) { for (std::size_t i = 0; i < 2 * Size; i += 2) {
out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]); out[i / 2] = static_cast<u8>((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
} }
} }
return out; return out;

View File

@ -623,6 +623,17 @@ if (MSVC)
# 'context' : truncation from 'type1' to 'type2' # 'context' : truncation from 'type1' to 'type2'
/we4305 /we4305
) )
else()
target_compile_options(core PRIVATE
-Werror=conversion
-Werror=ignored-qualifiers
-Werror=implicit-fallthrough
-Werror=reorder
-Werror=sign-compare
-Werror=unused-but-set-parameter
-Werror=unused-but-set-variable
-Werror=unused-variable
)
endif() endif()
create_target_directory_groups(core) create_target_directory_groups(core)

View File

@ -411,7 +411,7 @@ Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, KeyManager& ke
// Combine sources and seed // Combine sources and seed
for (auto& source : sd_key_sources) { for (auto& source : sd_key_sources) {
for (std::size_t i = 0; i < source.size(); ++i) { for (std::size_t i = 0; i < source.size(); ++i) {
source[i] ^= sd_seed[i & 0xF]; source[i] = static_cast<u8>(source[i] ^ sd_seed[i & 0xF]);
} }
} }

View File

@ -266,8 +266,9 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
cur_file->offset = file_partition_size; cur_file->offset = file_partition_size;
file_partition_size += cur_file->size; file_partition_size += cur_file->size;
cur_file->entry_offset = entry_offset; cur_file->entry_offset = entry_offset;
entry_offset += sizeof(RomFSFileEntry) + entry_offset +=
Common::AlignUp(cur_file->path_len - cur_file->cur_path_ofs, 4); static_cast<u32>(sizeof(RomFSFileEntry) +
Common::AlignUp(cur_file->path_len - cur_file->cur_path_ofs, 4));
prev_file = cur_file; prev_file = cur_file;
} }
// Assign deferred parent/sibling ownership. // Assign deferred parent/sibling ownership.
@ -284,8 +285,9 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
for (const auto& it : directories) { for (const auto& it : directories) {
cur_dir = it.second; cur_dir = it.second;
cur_dir->entry_offset = entry_offset; cur_dir->entry_offset = entry_offset;
entry_offset += sizeof(RomFSDirectoryEntry) + entry_offset +=
Common::AlignUp(cur_dir->path_len - cur_dir->cur_path_ofs, 4); static_cast<u32>(sizeof(RomFSDirectoryEntry) +
Common::AlignUp(cur_dir->path_len - cur_dir->cur_path_ofs, 4));
} }
// Assign deferred parent/sibling ownership. // Assign deferred parent/sibling ownership.
for (auto it = directories.rbegin(); it->second != root; ++it) { for (auto it = directories.rbegin(); it->second != root; ++it) {

View File

@ -299,7 +299,7 @@ void IPSwitchCompiler::Parse() {
patch_text->GetName(), offset, Common::HexToString(replace)); patch_text->GetName(), offset, Common::HexToString(replace));
} }
patch.records.insert_or_assign(offset, std::move(replace)); patch.records.insert_or_assign(static_cast<u32>(offset), std::move(replace));
} }
patches.push_back(std::move(patch)); patches.push_back(std::move(patch));

View File

@ -108,7 +108,7 @@ std::vector<u8> CNMT::Serialize() const {
memcpy(out.data() + sizeof(CNMTHeader), &opt_header, sizeof(OptionalHeader)); memcpy(out.data() + sizeof(CNMTHeader), &opt_header, sizeof(OptionalHeader));
} }
auto offset = header.table_offset; u64_le offset = header.table_offset;
for (const auto& rec : content_records) { for (const auto& rec : content_records) {
memcpy(out.data() + offset + sizeof(CNMTHeader), &rec, sizeof(ContentRecord)); memcpy(out.data() + offset + sizeof(CNMTHeader), &rec, sizeof(ContentRecord));

View File

@ -29,7 +29,7 @@
namespace FileSys { namespace FileSys {
namespace { namespace {
constexpr u64 SINGLE_BYTE_MODULUS = 0x100; constexpr u32 SINGLE_BYTE_MODULUS = 0x100;
constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000; constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
constexpr std::array<const char*, 14> EXEFS_FILE_NAMES{ constexpr std::array<const char*, 14> EXEFS_FILE_NAMES{

View File

@ -84,10 +84,12 @@ void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) {
return; return;
std::lock_guard guard{touch_state->mutex}; std::lock_guard guard{touch_state->mutex};
touch_state->touch_x = static_cast<float>(framebuffer_x - framebuffer_layout.screen.left) / touch_state->touch_x =
(framebuffer_layout.screen.right - framebuffer_layout.screen.left); static_cast<float>(framebuffer_x - framebuffer_layout.screen.left) /
touch_state->touch_y = static_cast<float>(framebuffer_y - framebuffer_layout.screen.top) / static_cast<float>(framebuffer_layout.screen.right - framebuffer_layout.screen.left);
(framebuffer_layout.screen.bottom - framebuffer_layout.screen.top); touch_state->touch_y =
static_cast<float>(framebuffer_y - framebuffer_layout.screen.top) /
static_cast<float>(framebuffer_layout.screen.bottom - framebuffer_layout.screen.top);
touch_state->touch_pressed = true; touch_state->touch_pressed = true;
} }

View File

@ -14,8 +14,8 @@ namespace Layout {
template <class T> template <class T>
static Common::Rectangle<T> MaxRectangle(Common::Rectangle<T> window_area, static Common::Rectangle<T> MaxRectangle(Common::Rectangle<T> window_area,
float screen_aspect_ratio) { float screen_aspect_ratio) {
float scale = std::min(static_cast<float>(window_area.GetWidth()), const float scale = std::min(static_cast<float>(window_area.GetWidth()),
window_area.GetHeight() / screen_aspect_ratio); static_cast<float>(window_area.GetHeight()) / screen_aspect_ratio);
return Common::Rectangle<T>{0, 0, static_cast<T>(std::round(scale)), return Common::Rectangle<T>{0, 0, static_cast<T>(std::round(scale)),
static_cast<T>(std::round(scale * screen_aspect_ratio))}; static_cast<T>(std::round(scale * screen_aspect_ratio))};
} }
@ -27,7 +27,7 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
// so just calculate them both even if the other isn't showing. // so just calculate them both even if the other isn't showing.
FramebufferLayout res{width, height, false, {}}; FramebufferLayout res{width, height, false, {}};
const float window_aspect_ratio = static_cast<float>(height) / width; const float window_aspect_ratio = static_cast<float>(height) / static_cast<float>(width);
const float emulation_aspect_ratio = EmulationAspectRatio( const float emulation_aspect_ratio = EmulationAspectRatio(
static_cast<AspectRatio>(Settings::values.aspect_ratio.GetValue()), window_aspect_ratio); static_cast<AspectRatio>(Settings::values.aspect_ratio.GetValue()), window_aspect_ratio);

View File

@ -291,11 +291,11 @@ static void FpuWrite(std::size_t id, u128 val, Kernel::Thread* thread = nullptr)
*/ */
static u8 HexCharToValue(u8 hex) { static u8 HexCharToValue(u8 hex) {
if (hex >= '0' && hex <= '9') { if (hex >= '0' && hex <= '9') {
return hex - '0'; return static_cast<u8>(hex - '0');
} else if (hex >= 'a' && hex <= 'f') { } else if (hex >= 'a' && hex <= 'f') {
return hex - 'a' + 0xA; return static_cast<u8>(hex - 'a' + 0xA);
} else if (hex >= 'A' && hex <= 'F') { } else if (hex >= 'A' && hex <= 'F') {
return hex - 'A' + 0xA; return static_cast<u8>(hex - 'A' + 0xA);
} }
LOG_ERROR(Debug_GDBStub, "Invalid nibble: {} ({:02X})", hex, hex); LOG_ERROR(Debug_GDBStub, "Invalid nibble: {} ({:02X})", hex, hex);
@ -310,9 +310,9 @@ static u8 HexCharToValue(u8 hex) {
static u8 NibbleToHex(u8 n) { static u8 NibbleToHex(u8 n) {
n &= 0xF; n &= 0xF;
if (n < 0xA) { if (n < 0xA) {
return '0' + n; return static_cast<u8>('0' + n);
} else { } else {
return 'a' + n - 0xA; return static_cast<u8>('a' + n - 0xA);
} }
} }
@ -355,8 +355,8 @@ static u64 HexToLong(const u8* src, std::size_t len) {
*/ */
static void MemToGdbHex(u8* dest, const u8* src, std::size_t len) { static void MemToGdbHex(u8* dest, const u8* src, std::size_t len) {
while (len-- > 0) { while (len-- > 0) {
u8 tmp = *src++; const u8 tmp = *src++;
*dest++ = NibbleToHex(tmp >> 4); *dest++ = NibbleToHex(static_cast<u8>(tmp >> 4));
*dest++ = NibbleToHex(tmp); *dest++ = NibbleToHex(tmp);
} }
} }
@ -370,7 +370,7 @@ static void MemToGdbHex(u8* dest, const u8* src, std::size_t len) {
*/ */
static void GdbHexToMem(u8* dest, const u8* src, std::size_t len) { static void GdbHexToMem(u8* dest, const u8* src, std::size_t len) {
while (len-- > 0) { while (len-- > 0) {
*dest++ = (HexCharToValue(src[0]) << 4) | HexCharToValue(src[1]); *dest++ = static_cast<u8>((HexCharToValue(src[0]) << 4) | HexCharToValue(src[1]));
src += 2; src += 2;
} }
} }
@ -602,22 +602,22 @@ static void SendReply(const char* reply) {
memcpy(command_buffer + 1, reply, command_length); memcpy(command_buffer + 1, reply, command_length);
u8 checksum = CalculateChecksum(command_buffer, command_length + 1); const u8 checksum = CalculateChecksum(command_buffer, command_length + 1);
command_buffer[0] = GDB_STUB_START; command_buffer[0] = GDB_STUB_START;
command_buffer[command_length + 1] = GDB_STUB_END; command_buffer[command_length + 1] = GDB_STUB_END;
command_buffer[command_length + 2] = NibbleToHex(checksum >> 4); command_buffer[command_length + 2] = NibbleToHex(static_cast<u8>(checksum >> 4));
command_buffer[command_length + 3] = NibbleToHex(checksum); command_buffer[command_length + 3] = NibbleToHex(checksum);
u8* ptr = command_buffer; u8* ptr = command_buffer;
u32 left = command_length + 4; u32 left = command_length + 4;
while (left > 0) { while (left > 0) {
int sent_size = send(gdbserver_socket, reinterpret_cast<char*>(ptr), left, 0); const auto sent_size = send(gdbserver_socket, reinterpret_cast<char*>(ptr), left, 0);
if (sent_size < 0) { if (sent_size < 0) {
LOG_ERROR(Debug_GDBStub, "gdb: send failed"); LOG_ERROR(Debug_GDBStub, "gdb: send failed");
return Shutdown(); return Shutdown();
} }
left -= sent_size; left -= static_cast<u32>(sent_size);
ptr += sent_size; ptr += sent_size;
} }
} }
@ -777,10 +777,10 @@ static void ReadCommand() {
command_buffer[command_length++] = c; command_buffer[command_length++] = c;
} }
u8 checksum_received = HexCharToValue(ReadByte()) << 4; auto checksum_received = static_cast<u32>(HexCharToValue(ReadByte()) << 4);
checksum_received |= HexCharToValue(ReadByte()); checksum_received |= static_cast<u32>(HexCharToValue(ReadByte()));
u8 checksum_calculated = CalculateChecksum(command_buffer, command_length); const u32 checksum_calculated = CalculateChecksum(command_buffer, command_length);
if (checksum_received != checksum_calculated) { if (checksum_received != checksum_calculated) {
LOG_ERROR(Debug_GDBStub, LOG_ERROR(Debug_GDBStub,

View File

@ -38,10 +38,11 @@ public:
explicit RequestHelperBase(Kernel::HLERequestContext& context) explicit RequestHelperBase(Kernel::HLERequestContext& context)
: context(&context), cmdbuf(context.CommandBuffer()) {} : context(&context), cmdbuf(context.CommandBuffer()) {}
void Skip(unsigned size_in_words, bool set_to_null) { void Skip(u32 size_in_words, bool set_to_null) {
if (set_to_null) if (set_to_null) {
memset(cmdbuf + index, 0, size_in_words * sizeof(u32)); memset(cmdbuf + index, 0, size_in_words * sizeof(u32));
index += size_in_words; }
index += static_cast<ptrdiff_t>(size_in_words);
} }
/** /**
@ -49,15 +50,15 @@ public:
*/ */
void AlignWithPadding() { void AlignWithPadding() {
if (index & 3) { if (index & 3) {
Skip(4 - (index & 3), true); Skip(static_cast<u32>(4 - (index & 3)), true);
} }
} }
unsigned GetCurrentOffset() const { u32 GetCurrentOffset() const {
return static_cast<unsigned>(index); return static_cast<u32>(index);
} }
void SetCurrentOffset(unsigned offset) { void SetCurrentOffset(u32 offset) {
index = static_cast<ptrdiff_t>(offset); index = static_cast<ptrdiff_t>(offset);
} }
}; };
@ -89,7 +90,7 @@ public:
// The entire size of the raw data section in u32 units, including the 16 bytes of mandatory // The entire size of the raw data section in u32 units, including the 16 bytes of mandatory
// padding. // padding.
u32 raw_data_size = sizeof(IPC::DataPayloadHeader) / 4 + 4 + normal_params_size; u64 raw_data_size = sizeof(IPC::DataPayloadHeader) / 4 + 4 + normal_params_size;
u32 num_handles_to_move{}; u32 num_handles_to_move{};
u32 num_domain_objects{}; u32 num_domain_objects{};
@ -105,7 +106,7 @@ public:
raw_data_size += sizeof(DomainMessageHeader) / 4 + num_domain_objects; raw_data_size += sizeof(DomainMessageHeader) / 4 + num_domain_objects;
} }
header.data_size.Assign(raw_data_size); header.data_size.Assign(static_cast<u32>(raw_data_size));
if (num_handles_to_copy || num_handles_to_move) { if (num_handles_to_copy || num_handles_to_move) {
header.enable_handle_descriptor.Assign(1); header.enable_handle_descriptor.Assign(1);
} }

View File

@ -118,7 +118,7 @@ std::shared_ptr<Object> HandleTable::GetGeneric(Handle handle) const {
void HandleTable::Clear() { void HandleTable::Clear() {
for (u16 i = 0; i < table_size; ++i) { for (u16 i = 0; i < table_size; ++i) {
generations[i] = i + 1; generations[i] = static_cast<u16>(i + 1);
objects[i] = nullptr; objects[i] = nullptr;
} }
next_free_slot = 0; next_free_slot = 0;

View File

@ -72,7 +72,7 @@ u32 GlobalScheduler::SelectThreads() {
if (top_thread != nullptr) { if (top_thread != nullptr) {
// TODO(Blinkhawk): Implement Thread Pinning // TODO(Blinkhawk): Implement Thread Pinning
} else { } else {
idle_cores |= (1ul << core); idle_cores |= (1U << core);
} }
top_threads[core] = top_thread; top_threads[core] = top_thread;
} }
@ -126,7 +126,7 @@ u32 GlobalScheduler::SelectThreads() {
top_threads[core_id] = suggested; top_threads[core_id] = suggested;
} }
idle_cores &= ~(1ul << core_id); idle_cores &= ~(1U << core_id);
} }
u32 cores_needing_context_switch{}; u32 cores_needing_context_switch{};
for (u32 core = 0; core < Core::Hardware::NUM_CPU_CORES; core++) { for (u32 core = 0; core < Core::Hardware::NUM_CPU_CORES; core++) {
@ -134,7 +134,7 @@ u32 GlobalScheduler::SelectThreads() {
ASSERT(top_threads[core] == nullptr || ASSERT(top_threads[core] == nullptr ||
static_cast<u32>(top_threads[core]->GetProcessorID()) == core); static_cast<u32>(top_threads[core]->GetProcessorID()) == core);
if (update_thread(top_threads[core], sched)) { if (update_thread(top_threads[core], sched)) {
cores_needing_context_switch |= (1ul << core); cores_needing_context_switch |= (1U << core);
} }
} }
return cores_needing_context_switch; return cores_needing_context_switch;
@ -364,7 +364,7 @@ void GlobalScheduler::EnableInterruptAndSchedule(u32 cores_pending_reschedule,
} else { } else {
must_context_switch = true; must_context_switch = true;
} }
cores_pending_reschedule &= ~(1ul << core); cores_pending_reschedule &= ~(1U << core);
} }
if (must_context_switch) { if (must_context_switch) {
auto& core_scheduler = kernel.CurrentScheduler(); auto& core_scheduler = kernel.CurrentScheduler();
@ -767,7 +767,7 @@ void Scheduler::SwitchToCurrent() {
current_thread->context_guard.unlock(); current_thread->context_guard.unlock();
break; break;
} }
if (current_thread->GetProcessorID() != core_id) { if (static_cast<u32>(current_thread->GetProcessorID()) != core_id) {
current_thread->context_guard.unlock(); current_thread->context_guard.unlock();
break; break;
} }

View File

@ -196,7 +196,9 @@ private:
const std::string& content_type_name) { const std::string& content_type_name) {
if (client == nullptr) { if (client == nullptr) {
client = std::make_unique<httplib::SSLClient>(BOXCAT_HOSTNAME, PORT); client = std::make_unique<httplib::SSLClient>(BOXCAT_HOSTNAME, PORT);
client->set_timeout_sec(timeout_seconds); client->set_connection_timeout(timeout_seconds);
client->set_read_timeout(timeout_seconds);
client->set_write_timeout(timeout_seconds);
} }
httplib::Headers headers{ httplib::Headers headers{
@ -255,7 +257,7 @@ private:
return out; return out;
} }
std::unique_ptr<httplib::Client> client; std::unique_ptr<httplib::SSLClient> client;
std::string path; std::string path;
u64 title_id; u64 title_id;
u64 build_id; u64 build_id;
@ -443,7 +445,9 @@ std::optional<std::vector<u8>> Boxcat::GetLaunchParameter(TitleIDVersion title)
Boxcat::StatusResult Boxcat::GetStatus(std::optional<std::string>& global, Boxcat::StatusResult Boxcat::GetStatus(std::optional<std::string>& global,
std::map<std::string, EventStatus>& games) { std::map<std::string, EventStatus>& games) {
httplib::SSLClient client{BOXCAT_HOSTNAME, static_cast<int>(PORT)}; httplib::SSLClient client{BOXCAT_HOSTNAME, static_cast<int>(PORT)};
client.set_timeout_sec(static_cast<int>(TIMEOUT_SECONDS)); client.set_connection_timeout(static_cast<int>(TIMEOUT_SECONDS));
client.set_read_timeout(static_cast<int>(TIMEOUT_SECONDS));
client.set_write_timeout(static_cast<int>(TIMEOUT_SECONDS));
httplib::Headers headers{ httplib::Headers headers{
{std::string("Game-Assets-API-Version"), std::string(BOXCAT_API_VERSION)}, {std::string("Game-Assets-API-Version"), std::string(BOXCAT_API_VERSION)},

View File

@ -42,8 +42,8 @@ void Controller_Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing,
cur_entry.modifier = 0; cur_entry.modifier = 0;
if (Settings::values.keyboard_enabled) { if (Settings::values.keyboard_enabled) {
for (std::size_t i = 0; i < keyboard_keys.size(); ++i) { for (std::size_t i = 0; i < keyboard_keys.size(); ++i) {
cur_entry.key[i / KEYS_PER_BYTE] |= auto& entry = cur_entry.key[i / KEYS_PER_BYTE];
(keyboard_keys[i]->GetStatus() << (i % KEYS_PER_BYTE)); entry = static_cast<u8>(entry | (keyboard_keys[i]->GetStatus() << (i % KEYS_PER_BYTE)));
} }
for (std::size_t i = 0; i < keyboard_mods.size(); ++i) { for (std::size_t i = 0; i < keyboard_mods.size(); ++i) {

View File

@ -269,7 +269,6 @@ void Controller_NPad::RequestPadStateUpdate(u32 npad_id) {
auto& rstick_entry = npad_pad_states[controller_idx].r_stick; auto& rstick_entry = npad_pad_states[controller_idx].r_stick;
const auto& button_state = buttons[controller_idx]; const auto& button_state = buttons[controller_idx];
const auto& analog_state = sticks[controller_idx]; const auto& analog_state = sticks[controller_idx];
const auto& motion_state = motions[controller_idx];
const auto [stick_l_x_f, stick_l_y_f] = const auto [stick_l_x_f, stick_l_y_f] =
analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetStatus(); analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetStatus();
const auto [stick_r_x_f, stick_r_y_f] = const auto [stick_r_x_f, stick_r_y_f] =
@ -391,18 +390,6 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
libnx_entry.connection_status.raw = 0; libnx_entry.connection_status.raw = 0;
libnx_entry.connection_status.IsConnected.Assign(1); libnx_entry.connection_status.IsConnected.Assign(1);
auto& full_sixaxis_entry =
npad.sixaxis_full.sixaxis[npad.sixaxis_full.common.last_entry_index];
auto& handheld_sixaxis_entry =
npad.sixaxis_handheld.sixaxis[npad.sixaxis_handheld.common.last_entry_index];
auto& dual_left_sixaxis_entry =
npad.sixaxis_dual_left.sixaxis[npad.sixaxis_dual_left.common.last_entry_index];
auto& dual_right_sixaxis_entry =
npad.sixaxis_dual_right.sixaxis[npad.sixaxis_dual_right.common.last_entry_index];
auto& left_sixaxis_entry =
npad.sixaxis_left.sixaxis[npad.sixaxis_left.common.last_entry_index];
auto& right_sixaxis_entry =
npad.sixaxis_right.sixaxis[npad.sixaxis_right.common.last_entry_index];
switch (controller_type) { switch (controller_type) {
case NPadControllerType::None: case NPadControllerType::None:
@ -541,18 +528,6 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
} }
} }
auto& main_controller =
npad.main_controller_states.npad[npad.main_controller_states.common.last_entry_index];
auto& handheld_entry =
npad.handheld_states.npad[npad.handheld_states.common.last_entry_index];
auto& dual_entry = npad.dual_states.npad[npad.dual_states.common.last_entry_index];
auto& left_entry = npad.left_joy_states.npad[npad.left_joy_states.common.last_entry_index];
auto& right_entry =
npad.right_joy_states.npad[npad.right_joy_states.common.last_entry_index];
auto& pokeball_entry =
npad.pokeball_states.npad[npad.pokeball_states.common.last_entry_index];
auto& libnx_entry = npad.libnx.npad[npad.libnx.common.last_entry_index];
auto& full_sixaxis_entry = auto& full_sixaxis_entry =
npad.sixaxis_full.sixaxis[npad.sixaxis_full.common.last_entry_index]; npad.sixaxis_full.sixaxis[npad.sixaxis_full.common.last_entry_index];
auto& handheld_sixaxis_entry = auto& handheld_sixaxis_entry =

View File

@ -475,7 +475,7 @@ void Hid::StopSixAxisSensor(Kernel::HLERequestContext& ctx) {
void Hid::EnableSixAxisSensorFusion(Kernel::HLERequestContext& ctx) { void Hid::EnableSixAxisSensorFusion(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx}; IPC::RequestParser rp{ctx};
const auto enable{rp.Pop<bool>()}; [[maybe_unused]] const auto enable{rp.Pop<bool>()};
const auto handle{rp.Pop<u32>()}; const auto handle{rp.Pop<u32>()};
const auto applet_resource_user_id{rp.Pop<u64>()}; const auto applet_resource_user_id{rp.Pop<u64>()};

View File

@ -428,7 +428,7 @@ bool MiiManager::IsFullDatabase() const {
} }
u32 MiiManager::GetCount(SourceFlag source_flag) const { u32 MiiManager::GetCount(SourceFlag source_flag) const {
u32 count{}; std::size_t count{};
if ((source_flag & SourceFlag::Database) != SourceFlag::None) { if ((source_flag & SourceFlag::Database) != SourceFlag::None) {
// TODO(bunnei): We don't implement the Mii database, but when we do, update this // TODO(bunnei): We don't implement the Mii database, but when we do, update this
count += 0; count += 0;
@ -436,7 +436,7 @@ u32 MiiManager::GetCount(SourceFlag source_flag) const {
if ((source_flag & SourceFlag::Default) != SourceFlag::None) { if ((source_flag & SourceFlag::Default) != SourceFlag::None) {
count += DefaultMiiCount; count += DefaultMiiCount;
} }
return count; return static_cast<u32>(count);
} }
ResultVal<MiiInfo> MiiManager::UpdateLatest([[maybe_unused]] const MiiInfo& info, ResultVal<MiiInfo> MiiManager::UpdateLatest([[maybe_unused]] const MiiInfo& info,

View File

@ -89,9 +89,9 @@ Network::Protocol Translate(Type type, Protocol protocol) {
} }
} }
u16 TranslatePollEventsToHost(u16 flags) { u16 TranslatePollEventsToHost(u32 flags) {
u16 result = 0; u32 result = 0;
const auto translate = [&result, &flags](u16 from, u16 to) { const auto translate = [&result, &flags](u32 from, u32 to) {
if ((flags & from) != 0) { if ((flags & from) != 0) {
flags &= ~from; flags &= ~from;
result |= to; result |= to;
@ -105,12 +105,12 @@ u16 TranslatePollEventsToHost(u16 flags) {
translate(POLL_NVAL, Network::POLL_NVAL); translate(POLL_NVAL, Network::POLL_NVAL);
UNIMPLEMENTED_IF_MSG(flags != 0, "Unimplemented flags={}", flags); UNIMPLEMENTED_IF_MSG(flags != 0, "Unimplemented flags={}", flags);
return result; return static_cast<u16>(result);
} }
u16 TranslatePollEventsToGuest(u16 flags) { u16 TranslatePollEventsToGuest(u32 flags) {
u16 result = 0; u32 result = 0;
const auto translate = [&result, &flags](u16 from, u16 to) { const auto translate = [&result, &flags](u32 from, u32 to) {
if ((flags & from) != 0) { if ((flags & from) != 0) {
flags &= ~from; flags &= ~from;
result |= to; result |= to;
@ -125,7 +125,7 @@ u16 TranslatePollEventsToGuest(u16 flags) {
translate(Network::POLL_NVAL, POLL_NVAL); translate(Network::POLL_NVAL, POLL_NVAL);
UNIMPLEMENTED_IF_MSG(flags != 0, "Unimplemented flags={}", flags); UNIMPLEMENTED_IF_MSG(flags != 0, "Unimplemented flags={}", flags);
return result; return static_cast<u16>(result);
} }
Network::SockAddrIn Translate(SockAddrIn value) { Network::SockAddrIn Translate(SockAddrIn value) {

View File

@ -31,10 +31,10 @@ Network::Type Translate(Type type);
Network::Protocol Translate(Type type, Protocol protocol); Network::Protocol Translate(Type type, Protocol protocol);
/// Translate abstract poll event flags to guest poll event flags /// Translate abstract poll event flags to guest poll event flags
u16 TranslatePollEventsToHost(u16 flags); u16 TranslatePollEventsToHost(u32 flags);
/// Translate guest poll event flags to abstract poll event flags /// Translate guest poll event flags to abstract poll event flags
u16 TranslatePollEventsToGuest(u16 flags); u16 TranslatePollEventsToGuest(u32 flags);
/// Translate guest socket address structure to abstract socket address structure /// Translate guest socket address structure to abstract socket address structure
Network::SockAddrIn Translate(SockAddrIn value); Network::SockAddrIn Translate(SockAddrIn value);

View File

@ -820,7 +820,10 @@ static ResultCode ToCalendarTimeImpl(const TimeZoneRule& rules, s64 time, Calend
const ResultCode result{ const ResultCode result{
ToCalendarTimeInternal(rules, time, calendar_time, calendar.additiona_info)}; ToCalendarTimeInternal(rules, time, calendar_time, calendar.additiona_info)};
calendar.time.year = static_cast<s16>(calendar_time.year); calendar.time.year = static_cast<s16>(calendar_time.year);
calendar.time.month = calendar_time.month + 1; // Internal impl. uses 0-indexed month
// Internal impl. uses 0-indexed month
calendar.time.month = static_cast<s8>(calendar_time.month + 1);
calendar.time.day = calendar_time.day; calendar.time.day = calendar_time.day;
calendar.time.hour = calendar_time.hour; calendar.time.hour = calendar_time.hour;
calendar.time.minute = calendar_time.minute; calendar.time.minute = calendar_time.minute;
@ -872,13 +875,15 @@ ResultCode TimeZoneManager::ToPosixTime(const TimeZoneRule& rules,
const CalendarTime& calendar_time, s64& posix_time) const { const CalendarTime& calendar_time, s64& posix_time) const {
posix_time = 0; posix_time = 0;
CalendarTimeInternal internal_time{}; CalendarTimeInternal internal_time{
internal_time.year = calendar_time.year; .year = calendar_time.year,
internal_time.month = calendar_time.month - 1; // Internal impl. uses 0-indexed month // Internal impl. uses 0-indexed month
internal_time.day = calendar_time.day; .month = static_cast<s8>(calendar_time.month - 1),
internal_time.hour = calendar_time.hour; .day = calendar_time.day,
internal_time.minute = calendar_time.minute; .hour = calendar_time.hour,
internal_time.second = calendar_time.second; .minute = calendar_time.minute,
.second = calendar_time.second,
};
s32 hour{internal_time.hour}; s32 hour{internal_time.hour};
s32 minute{internal_time.minute}; s32 minute{internal_time.minute};

View File

@ -159,7 +159,7 @@ public:
header.data_size = static_cast<u32_le>(write_index - sizeof(Header)); header.data_size = static_cast<u32_le>(write_index - sizeof(Header));
header.data_offset = sizeof(Header); header.data_offset = sizeof(Header);
header.objects_size = 4; header.objects_size = 4;
header.objects_offset = sizeof(Header) + header.data_size; header.objects_offset = static_cast<u32>(sizeof(Header) + header.data_size);
std::memcpy(buffer.data(), &header, sizeof(Header)); std::memcpy(buffer.data(), &header, sizeof(Header));
return buffer; return buffer;

View File

@ -16,7 +16,7 @@ namespace Loader {
namespace { namespace {
constexpr u32 PageAlignSize(u32 size) { constexpr u32 PageAlignSize(u32 size) {
return (size + Core::Memory::PAGE_MASK) & ~Core::Memory::PAGE_MASK; return static_cast<u32>((size + Core::Memory::PAGE_MASK) & ~Core::Memory::PAGE_MASK);
} }
} // Anonymous namespace } // Anonymous namespace

View File

@ -127,7 +127,7 @@ FileType AppLoader_NRO::IdentifyType(const FileSys::VirtualFile& file) {
} }
static constexpr u32 PageAlignSize(u32 size) { static constexpr u32 PageAlignSize(u32 size) {
return (size + Core::Memory::PAGE_MASK) & ~Core::Memory::PAGE_MASK; return static_cast<u32>((size + Core::Memory::PAGE_MASK) & ~Core::Memory::PAGE_MASK);
} }
static bool LoadNroImpl(Kernel::Process& process, const std::vector<u8>& data, static bool LoadNroImpl(Kernel::Process& process, const std::vector<u8>& data,

View File

@ -47,7 +47,7 @@ std::vector<u8> DecompressSegment(const std::vector<u8>& compressed_data,
} }
constexpr u32 PageAlignSize(u32 size) { constexpr u32 PageAlignSize(u32 size) {
return (size + Core::Memory::PAGE_MASK) & ~Core::Memory::PAGE_MASK; return static_cast<u32>((size + Core::Memory::PAGE_MASK) & ~Core::Memory::PAGE_MASK);
} }
} // Anonymous namespace } // Anonymous namespace

View File

@ -59,7 +59,7 @@ struct NSOHeader {
static_assert(sizeof(NSOHeader) == 0x100, "NSOHeader has incorrect size."); static_assert(sizeof(NSOHeader) == 0x100, "NSOHeader has incorrect size.");
static_assert(std::is_trivially_copyable_v<NSOHeader>, "NSOHeader must be trivially copyable."); static_assert(std::is_trivially_copyable_v<NSOHeader>, "NSOHeader must be trivially copyable.");
constexpr u64 NSO_ARGUMENT_DATA_ALLOCATION_SIZE = 0x9000; constexpr u32 NSO_ARGUMENT_DATA_ALLOCATION_SIZE = 0x9000;
struct NSOArgumentHeader { struct NSOArgumentHeader {
u32_le allocated_size; u32_le allocated_size;

View File

@ -120,9 +120,9 @@ struct Memory::Impl {
if ((addr & 1) == 0) { if ((addr & 1) == 0) {
return Read<u16_le>(addr); return Read<u16_le>(addr);
} else { } else {
const u8 a{Read<u8>(addr)}; const u32 a{Read<u8>(addr)};
const u8 b{Read<u8>(addr + sizeof(u8))}; const u32 b{Read<u8>(addr + sizeof(u8))};
return (static_cast<u16>(b) << 8) | a; return static_cast<u16>((b << 8) | a);
} }
} }
@ -130,9 +130,9 @@ struct Memory::Impl {
if ((addr & 3) == 0) { if ((addr & 3) == 0) {
return Read<u32_le>(addr); return Read<u32_le>(addr);
} else { } else {
const u16 a{Read16(addr)}; const u32 a{Read16(addr)};
const u16 b{Read16(addr + sizeof(u16))}; const u32 b{Read16(addr + sizeof(u16))};
return (static_cast<u32>(b) << 16) | a; return (b << 16) | a;
} }
} }

View File

@ -153,8 +153,9 @@ std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
return {}; return {};
} }
const auto value = static_cast<u32>(std::stoul(hex, nullptr, 0x10));
out[*current_entry].definition.opcodes[out[*current_entry].definition.num_opcodes++] = out[*current_entry].definition.opcodes[out[*current_entry].definition.num_opcodes++] =
std::stoul(hex, nullptr, 0x10); value;
i += 8; i += 8;
} else { } else {

View File

@ -238,14 +238,14 @@ SockAddrIn TranslateToSockAddrIn(sockaddr input_) {
return result; return result;
} }
u16 TranslatePollEvents(u16 events) { u16 TranslatePollEvents(u32 events) {
u16 result = 0; u32 result = 0;
if (events & POLL_IN) { if ((events & POLL_IN) != 0) {
events &= ~POLL_IN; events &= ~POLL_IN;
result |= POLLIN; result |= POLLIN;
} }
if (events & POLL_PRI) { if ((events & POLL_PRI) != 0) {
events &= ~POLL_PRI; events &= ~POLL_PRI;
#ifdef _WIN32 #ifdef _WIN32
LOG_WARNING(Service, "Winsock doesn't support POLLPRI"); LOG_WARNING(Service, "Winsock doesn't support POLLPRI");
@ -253,20 +253,20 @@ u16 TranslatePollEvents(u16 events) {
result |= POLL_PRI; result |= POLL_PRI;
#endif #endif
} }
if (events & POLL_OUT) { if ((events & POLL_OUT) != 0) {
events &= ~POLL_OUT; events &= ~POLL_OUT;
result |= POLLOUT; result |= POLLOUT;
} }
UNIMPLEMENTED_IF_MSG(events != 0, "Unhandled guest events=0x{:x}", events); UNIMPLEMENTED_IF_MSG(events != 0, "Unhandled guest events=0x{:x}", events);
return result; return static_cast<u16>(result);
} }
u16 TranslatePollRevents(u16 revents) { u16 TranslatePollRevents(u32 revents) {
u16 result = 0; u32 result = 0;
const auto translate = [&result, &revents](int host, unsigned guest) { const auto translate = [&result, &revents](u32 host, u32 guest) {
if (revents & host) { if ((revents & host) != 0) {
revents &= ~host; revents &= ~host;
result |= guest; result |= guest;
} }
@ -280,7 +280,7 @@ u16 TranslatePollRevents(u16 revents) {
UNIMPLEMENTED_IF_MSG(revents != 0, "Unhandled host revents=0x{:x}", revents); UNIMPLEMENTED_IF_MSG(revents != 0, "Unhandled host revents=0x{:x}", revents);
return result; return static_cast<u16>(result);
} }
template <typename T> template <typename T>
@ -350,7 +350,7 @@ std::pair<s32, Errno> Poll(std::vector<PollFD>& pollfds, s32 timeout) {
} }
for (size_t i = 0; i < num; ++i) { for (size_t i = 0; i < num; ++i) {
pollfds[i].revents = TranslatePollRevents(host_pollfds[i].revents); pollfds[i].revents = TranslatePollRevents(static_cast<u32>(host_pollfds[i].revents));
} }
if (result > 0) { if (result > 0) {
@ -408,7 +408,7 @@ std::pair<Socket::AcceptResult, Errno> Socket::Accept() {
Errno Socket::Connect(SockAddrIn addr_in) { Errno Socket::Connect(SockAddrIn addr_in) {
const sockaddr host_addr_in = TranslateFromSockAddrIn(addr_in); const sockaddr host_addr_in = TranslateFromSockAddrIn(addr_in);
if (connect(fd, &host_addr_in, sizeof(host_addr_in)) != INVALID_SOCKET) { if (connect(fd, &host_addr_in, sizeof(host_addr_in)) != SOCKET_ERROR) {
return Errno::SUCCESS; return Errno::SUCCESS;
} }
@ -503,10 +503,10 @@ std::pair<s32, Errno> Socket::Recv(int flags, std::vector<u8>& message) {
ASSERT(flags == 0); ASSERT(flags == 0);
ASSERT(message.size() < static_cast<size_t>(std::numeric_limits<int>::max())); ASSERT(message.size() < static_cast<size_t>(std::numeric_limits<int>::max()));
const int result = const auto result =
recv(fd, reinterpret_cast<char*>(message.data()), static_cast<int>(message.size()), 0); recv(fd, reinterpret_cast<char*>(message.data()), static_cast<int>(message.size()), 0);
if (result != SOCKET_ERROR) { if (result != SOCKET_ERROR) {
return {result, Errno::SUCCESS}; return {static_cast<s32>(result), Errno::SUCCESS};
} }
switch (const int ec = LastError()) { switch (const int ec = LastError()) {
@ -531,14 +531,14 @@ std::pair<s32, Errno> Socket::RecvFrom(int flags, std::vector<u8>& message, Sock
socklen_t* const p_addrlen = addr ? &addrlen : nullptr; socklen_t* const p_addrlen = addr ? &addrlen : nullptr;
sockaddr* const p_addr_in = addr ? &addr_in : nullptr; sockaddr* const p_addr_in = addr ? &addr_in : nullptr;
const int result = recvfrom(fd, reinterpret_cast<char*>(message.data()), const auto result = recvfrom(fd, reinterpret_cast<char*>(message.data()),
static_cast<int>(message.size()), 0, p_addr_in, p_addrlen); static_cast<int>(message.size()), 0, p_addr_in, p_addrlen);
if (result != SOCKET_ERROR) { if (result != SOCKET_ERROR) {
if (addr) { if (addr) {
ASSERT(addrlen == sizeof(addr_in)); ASSERT(addrlen == sizeof(addr_in));
*addr = TranslateToSockAddrIn(addr_in); *addr = TranslateToSockAddrIn(addr_in);
} }
return {result, Errno::SUCCESS}; return {static_cast<s32>(result), Errno::SUCCESS};
} }
switch (const int ec = LastError()) { switch (const int ec = LastError()) {
@ -558,10 +558,10 @@ std::pair<s32, Errno> Socket::Send(const std::vector<u8>& message, int flags) {
ASSERT(message.size() < static_cast<size_t>(std::numeric_limits<int>::max())); ASSERT(message.size() < static_cast<size_t>(std::numeric_limits<int>::max()));
ASSERT(flags == 0); ASSERT(flags == 0);
const int result = send(fd, reinterpret_cast<const char*>(message.data()), const auto result = send(fd, reinterpret_cast<const char*>(message.data()),
static_cast<int>(message.size()), 0); static_cast<int>(message.size()), 0);
if (result != SOCKET_ERROR) { if (result != SOCKET_ERROR) {
return {result, Errno::SUCCESS}; return {static_cast<s32>(result), Errno::SUCCESS};
} }
const int ec = LastError(); const int ec = LastError();
@ -591,10 +591,10 @@ std::pair<s32, Errno> Socket::SendTo(u32 flags, const std::vector<u8>& message,
to = &host_addr_in; to = &host_addr_in;
} }
const int result = sendto(fd, reinterpret_cast<const char*>(message.data()), const auto result = sendto(fd, reinterpret_cast<const char*>(message.data()),
static_cast<int>(message.size()), 0, to, tolen); static_cast<int>(message.size()), 0, to, tolen);
if (result != SOCKET_ERROR) { if (result != SOCKET_ERROR) {
return {result, Errno::SUCCESS}; return {static_cast<s32>(result), Errno::SUCCESS};
} }
const int ec = LastError(); const int ec = LastError();

View File

@ -67,28 +67,25 @@ struct Client::Impl {
const std::string& jwt = "", const std::string& username = "", const std::string& jwt = "", const std::string& username = "",
const std::string& token = "") { const std::string& token = "") {
if (cli == nullptr) { if (cli == nullptr) {
auto parsedUrl = LUrlParser::clParseURL::ParseURL(host); const auto parsedUrl = LUrlParser::clParseURL::ParseURL(host);
int port; int port{};
if (parsedUrl.m_Scheme == "http") { if (parsedUrl.m_Scheme == "http") {
if (!parsedUrl.GetPort(&port)) { if (!parsedUrl.GetPort(&port)) {
port = HTTP_PORT; port = HTTP_PORT;
} }
cli = std::make_unique<httplib::Client>(parsedUrl.m_Host.c_str(), port);
} else if (parsedUrl.m_Scheme == "https") { } else if (parsedUrl.m_Scheme == "https") {
if (!parsedUrl.GetPort(&port)) { if (!parsedUrl.GetPort(&port)) {
port = HTTPS_PORT; port = HTTPS_PORT;
} }
cli = std::make_unique<httplib::SSLClient>(parsedUrl.m_Host.c_str(), port);
} else { } else {
LOG_ERROR(WebService, "Bad URL scheme {}", parsedUrl.m_Scheme); LOG_ERROR(WebService, "Bad URL scheme {}", parsedUrl.m_Scheme);
return WebResult{WebResult::Code::InvalidURL, "Bad URL scheme", ""}; return WebResult{WebResult::Code::InvalidURL, "Bad URL scheme", ""};
} }
cli = std::make_unique<httplib::Client>(parsedUrl.m_Host.c_str(), port);
} }
if (cli == nullptr) { cli->set_connection_timeout(TIMEOUT_SECONDS);
LOG_ERROR(WebService, "Invalid URL {}", host + path); cli->set_read_timeout(TIMEOUT_SECONDS);
return WebResult{WebResult::Code::InvalidURL, "Invalid URL", ""}; cli->set_write_timeout(TIMEOUT_SECONDS);
}
cli->set_timeout_sec(TIMEOUT_SECONDS);
httplib::Headers params; httplib::Headers params;
if (!jwt.empty()) { if (!jwt.empty()) {