Merge pull request #11687 from Minty-Meeo/warnings

leoetlino · web-flow · commit ae18aa0639bd · 2023-04-14T01:29:46.000+01:00
Resolve GCC/Clang Warnings
diff --git a/Source/Core/Common/Crypto/bn.cpp b/Source/Core/Common/Crypto/bn.cpp
@@ -3,42 +3,45 @@
 
 #include "Common/Crypto/bn.h"
 
+#include <cstddef>
 #include <cstdio>
 #include <cstring>
 
 #include "Common/CommonTypes.h"
 
-static void bn_zero(u8* d, int n)
+static void bn_zero(u8* d, const size_t n)
 {
   std::memset(d, 0, n);
 }
 
-static void bn_copy(u8* d, const u8* a, int n)
+static void bn_copy(u8* d, const u8* a, const size_t n)
 {
   std::memcpy(d, a, n);
 }
 
-int bn_compare(const u8* a, const u8* b, int n)
+int bn_compare(const u8* a, const u8* b, const size_t n)
 {
   return std::memcmp(a, b, n);
 }
 
-void bn_sub_modulus(u8* a, const u8* N, int n)
+void bn_sub_modulus(u8* a, const u8* N, const size_t n)
 {
   u8 c = 0;
-  for (int i = n - 1; i >= 0; --i)
+  for (size_t i = n; i > 0;)
   {
+    --i;
     u32 dig = N[i] + c;
     c = (a[i] < dig);
     a[i] -= dig;
   }
 }
 
-void bn_add(u8* d, const u8* a, const u8* b, const u8* N, int n)
+void bn_add(u8* d, const u8* a, const u8* b, const u8* N, const size_t n)
 {
   u8 c = 0;
-  for (int i = n - 1; i >= 0; --i)
+  for (size_t i = n; i > 0;)
   {
+    --i;
     u32 dig = a[i] + b[i] + c;
     c = (dig >= 0x100);
     d[i] = dig;
@@ -51,11 +54,11 @@ void bn_add(u8* d, const u8* a, const u8* b, const u8* N, int n)
     bn_sub_modulus(d, N, n);
 }
 
-void bn_mul(u8* d, const u8* a, const u8* b, const u8* N, int n)
+void bn_mul(u8* d, const u8* a, const u8* b, const u8* N, const size_t n)
 {
   bn_zero(d, n);
 
-  for (int i = 0; i < n; i++)
+  for (size_t i = 0; i < n; i++)
   {
     for (u8 mask = 0x80; mask != 0; mask >>= 1)
     {
@@ -66,13 +69,13 @@ void bn_mul(u8* d, const u8* a, const u8* b, const u8* N, int n)
   }
 }
 
-void bn_exp(u8* d, const u8* a, const u8* N, int n, const u8* e, int en)
+void bn_exp(u8* d, const u8* a, const u8* N, const size_t n, const u8* e, const size_t en)
 {
   u8 t[512];
 
   bn_zero(d, n);
   d[n - 1] = 1;
-  for (int i = 0; i < en; i++)
+  for (size_t i = 0; i < en; i++)
   {
     for (u8 mask = 0x80; mask != 0; mask >>= 1)
     {
@@ -86,7 +89,7 @@ void bn_exp(u8* d, const u8* a, const u8* N, int n, const u8* e, int en)
 }
 
 // only for prime N -- stupid but lazy, see if I care
-void bn_inv(u8* d, const u8* a, const u8* N, int n)
+void bn_inv(u8* d, const u8* a, const u8* N, const size_t n)
 {
   u8 t[512], s[512];
 
diff --git a/Source/Core/Common/Crypto/bn.h b/Source/Core/Common/Crypto/bn.h
@@ -3,13 +3,15 @@
 
 #pragma once
 
+#include <cstddef>
+
 #include "Common/CommonTypes.h"
 
 // bignum arithmetic
 
-int bn_compare(const u8* a, const u8* b, int n);
-void bn_sub_modulus(u8* a, const u8* N, int n);
-void bn_add(u8* d, const u8* a, const u8* b, const u8* N, int n);
-void bn_mul(u8* d, const u8* a, const u8* b, const u8* N, int n);
-void bn_inv(u8* d, const u8* a, const u8* N, int n);  // only for prime N
-void bn_exp(u8* d, const u8* a, const u8* N, int n, const u8* e, int en);
+int bn_compare(const u8* a, const u8* b, size_t n);
+void bn_sub_modulus(u8* a, const u8* N, size_t n);
+void bn_add(u8* d, const u8* a, const u8* b, const u8* N, size_t n);
+void bn_mul(u8* d, const u8* a, const u8* b, const u8* N, size_t n);
+void bn_inv(u8* d, const u8* a, const u8* N, size_t n);  // only for prime N
+void bn_exp(u8* d, const u8* a, const u8* N, size_t n, const u8* e, size_t en);
diff --git a/Source/Core/Common/FileUtil.cpp b/Source/Core/Common/FileUtil.cpp
@@ -486,7 +486,7 @@ FSTEntry ScanDirectoryTree(std::string directory, bool recursive)
       }
       else if (cur_depth < prev_depth)
       {
-        while (dir_fsts.size() - 1 != cur_depth)
+        while (dir_fsts.size() != static_cast<size_t>(cur_depth) + 1u)
         {
           calc_dir_size(dir_fsts.top());
           dir_fsts.pop();
diff --git a/Source/Core/Common/HttpRequest.cpp b/Source/Core/Common/HttpRequest.cpp
@@ -33,8 +33,8 @@ class HttpRequest::Impl final
   Response Fetch(const std::string& url, Method method, const Headers& headers, const u8* payload,
                  size_t size, AllowedReturnCodes codes = AllowedReturnCodes::Ok_Only);
 
-  static int CurlProgressCallback(Impl* impl, double dlnow, double dltotal, double ulnow,
-                                  double ultotal);
+  static int CurlProgressCallback(Impl* impl, curl_off_t dltotal, curl_off_t dlnow,
+                                  curl_off_t ultotal, curl_off_t ulnow);
   std::string EscapeComponent(const std::string& string);
 
 private:
@@ -95,11 +95,12 @@ HttpRequest::Response HttpRequest::Post(const std::string& url, const std::strin
                        reinterpret_cast<const u8*>(payload.data()), payload.size(), codes);
 }
 
-int HttpRequest::Impl::CurlProgressCallback(Impl* impl, double dlnow, double dltotal, double ulnow,
-                                            double ultotal)
+int HttpRequest::Impl::CurlProgressCallback(Impl* impl, curl_off_t dltotal, curl_off_t dlnow,
+                                            curl_off_t ultotal, curl_off_t ulnow)
 {
   // Abort if callback isn't true
-  return !impl->m_callback(dlnow, dltotal, ulnow, ultotal);
+  return !impl->m_callback(static_cast<s64>(dltotal), static_cast<s64>(dlnow),
+                           static_cast<s64>(ultotal), static_cast<s64>(ulnow));
 }
 
 HttpRequest::Impl::Impl(std::chrono::milliseconds timeout_ms, ProgressCallback callback)
@@ -116,7 +117,7 @@ HttpRequest::Impl::Impl(std::chrono::milliseconds timeout_ms, ProgressCallback c
   if (m_callback)
   {
     curl_easy_setopt(m_curl.get(), CURLOPT_PROGRESSDATA, this);
-    curl_easy_setopt(m_curl.get(), CURLOPT_PROGRESSFUNCTION, CurlProgressCallback);
+    curl_easy_setopt(m_curl.get(), CURLOPT_XFERINFOFUNCTION, CurlProgressCallback);
   }
 
   // Set up error buffer
diff --git a/Source/Core/Common/HttpRequest.h b/Source/Core/Common/HttpRequest.h
@@ -25,8 +25,7 @@ class HttpRequest final
   };
 
   // Return false to abort the request
-  using ProgressCallback =
-      std::function<bool(double dlnow, double dltotal, double ulnow, double ultotal)>;
+  using ProgressCallback = std::function<bool(s64 dltotal, s64 dlnow, s64 ultotal, s64 ulnow)>;
 
   explicit HttpRequest(std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{3000},
                        ProgressCallback callback = nullptr);
diff --git a/Source/Core/Common/SettingsHandler.cpp b/Source/Core/Common/SettingsHandler.cpp
@@ -70,12 +70,10 @@ std::string SettingsHandler::GetValue(std::string_view key) const
 
 void SettingsHandler::Decrypt()
 {
-  const u8* str = m_buffer.data();
   while (m_position < m_buffer.size())
   {
     decoded.push_back((u8)(m_buffer[m_position] ^ m_key));
     m_position++;
-    str++;
     m_key = (m_key >> 31) | (m_key << 1);
   }
 
diff --git a/Source/Core/Core/FifoPlayer/FifoPlayer.cpp b/Source/Core/Core/FifoPlayer/FifoPlayer.cpp
@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <cstring>
 #include <mutex>
+#include <type_traits>
 
 #include "Common/Assert.h"
 #include "Common/CommonTypes.h"
@@ -101,14 +102,9 @@ void FifoPlaybackAnalyzer::AnalyzeFrames(FifoDataFile* file,
         part_start = offset;
         // Copy cpmem now, because end_of_primitives isn't triggered until the first opcode after
         // primitive data, and the first opcode might update cpmem
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wclass-memaccess"
-#endif
-        std::memcpy(&cpmem, &analyzer.m_cpmem, sizeof(CPState));
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
+        static_assert(std::is_trivially_copyable_v<CPState>);
+        std::memcpy(static_cast<void*>(&cpmem), static_cast<const void*>(&analyzer.m_cpmem),
+                    sizeof(CPState));
       }
       if (analyzer.m_end_of_primitives)
       {
diff --git a/Source/Core/Core/FifoPlayer/FifoRecorder.cpp b/Source/Core/Core/FifoPlayer/FifoRecorder.cpp
@@ -268,9 +268,7 @@ void FifoRecorder::StartRecording(s32 numFrames, CallbackFunc finishedCb)
           RecordInitialVideoMemory();
         }
 
-        auto& system = Core::System::GetInstance();
-        auto& command_processor = system.GetCommandProcessor();
-        const auto& fifo = command_processor.GetFifo();
+        const auto& fifo = Core::System::GetInstance().GetCommandProcessor().GetFifo();
         EndFrame(fifo.CPBase.load(std::memory_order_relaxed),
                  fifo.CPEnd.load(std::memory_order_relaxed));
       },
diff --git a/Source/Core/Core/HW/DSPHLE/UCodes/AESnd.cpp b/Source/Core/Core/HW/DSPHLE/UCodes/AESnd.cpp
@@ -44,21 +44,21 @@ constexpr u32 VOICE_16_BIT_FLAG = 2;
 
 // These are used in the pre-2020 versions version
 constexpr u32 VOICE_PAUSE_OLD = 0x00000004;
-constexpr u32 VOICE_LOOP_OLD = 0x00000008;    // not used by the DSP
-constexpr u32 VOICE_ONCE_OLD = 0x00000010;    // not used by the DSP
-constexpr u32 VOICE_STREAM_OLD = 0x00000020;  // not used by the DSP
+constexpr u32 VOICE_LOOP_OLD [[maybe_unused]] = 0x00000008;    // not used by the DSP
+constexpr u32 VOICE_ONCE_OLD [[maybe_unused]] = 0x00000010;    // not used by the DSP
+constexpr u32 VOICE_STREAM_OLD [[maybe_unused]] = 0x00000020;  // not used by the DSP
 
 // These were changed in the 2020 version to account for the different flags
 constexpr u32 VOICE_PAUSE_NEW = 0x00000008;
-constexpr u32 VOICE_LOOP_NEW = 0x00000010;    // not used by the DSP
-constexpr u32 VOICE_ONCE_NEW = 0x00000020;    // not used by the DSP
-constexpr u32 VOICE_STREAM_NEW = 0x00000040;  // not used by the DSP
+constexpr u32 VOICE_LOOP_NEW [[maybe_unused]] = 0x00000010;    // not used by the DSP
+constexpr u32 VOICE_ONCE_NEW [[maybe_unused]] = 0x00000020;    // not used by the DSP
+constexpr u32 VOICE_STREAM_NEW [[maybe_unused]] = 0x00000040;  // not used by the DSP
 
 // These did not change between versions
 constexpr u32 VOICE_FINISHED = 0x00100000;
-constexpr u32 VOICE_STOPPED = 0x00200000;  // not used by the DSP
+constexpr u32 VOICE_STOPPED [[maybe_unused]] = 0x00200000;  // not used by the DSP
 constexpr u32 VOICE_RUNNING = 0x40000000;
-constexpr u32 VOICE_USED = 0x80000000;  // not used by the DSP
+constexpr u32 VOICE_USED [[maybe_unused]] = 0x80000000;  // not used by the DSP
 
 // 1<<4 = scale gain by 1/1,    2<<2 = PCM decoding from ARAM, 1<<0 = 8-bit reads
 constexpr u32 ACCELERATOR_FORMAT_8_BIT = 0x0019;
diff --git a/Source/Core/Core/HW/EXI/BBA/BuiltIn.cpp b/Source/Core/Core/HW/EXI/BBA/BuiltIn.cpp
@@ -384,7 +384,8 @@ void CEXIETHERNET::BuiltInBBAInterface::HandleTCPFrame(const Common::TCPPacket&
     if (size > 0)
     {
       // only if contain data
-      if (static_cast<int>(this_seq - ref->ack_num) >= 0 && data.size() >= size)
+      if (static_cast<int>(this_seq - ref->ack_num) >= 0 &&
+          data.size() >= static_cast<size_t>(size))
       {
         ref->tcp_socket.send(data.data(), size);
         ref->ack_num += size;
diff --git a/Source/Core/Core/HW/MemoryInterface.cpp b/Source/Core/Core/HW/MemoryInterface.cpp
@@ -61,14 +61,7 @@ MemoryInterfaceManager::~MemoryInterfaceManager() = default;
 void MemoryInterfaceManager::Init()
 {
   static_assert(std::is_trivially_copyable_v<MIMemStruct>);
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wclass-memaccess"
-#endif
-  std::memset(&m_mi_mem, 0, sizeof(MIMemStruct));
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
+  std::memset(static_cast<void*>(&m_mi_mem), 0, sizeof(MIMemStruct));
 }
 
 void MemoryInterfaceManager::Shutdown()
diff --git a/Source/Core/Core/HW/ProcessorInterface.cpp b/Source/Core/Core/HW/ProcessorInterface.cpp
@@ -24,8 +24,8 @@
 
 namespace ProcessorInterface
 {
-constexpr u32 FLIPPER_REV_A = 0x046500B0;
-constexpr u32 FLIPPER_REV_B = 0x146500B1;
+constexpr u32 FLIPPER_REV_A [[maybe_unused]] = 0x046500B0;
+constexpr u32 FLIPPER_REV_B [[maybe_unused]] = 0x146500B1;
 constexpr u32 FLIPPER_REV_C = 0x246500B1;
 
 ProcessorInterfaceManager::ProcessorInterfaceManager(Core::System& system) : m_system(system)
diff --git a/Source/Core/Core/HW/WiimoteEmu/DesiredWiimoteState.cpp b/Source/Core/Core/HW/WiimoteEmu/DesiredWiimoteState.cpp
@@ -136,14 +136,8 @@ static bool DeserializeExtensionState(DesiredWiimoteState* state,
     return false;
   auto& e = state->extension.data.emplace<T>();
   static_assert(std::is_trivially_copyable_v<T>);
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wclass-memaccess"
-#endif
-  std::memcpy(&e, &serialized.data[offset], sizeof(T));
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
+  std::memcpy(static_cast<void*>(&e), static_cast<const void*>(&serialized.data[offset]),
+              sizeof(T));
   return true;
 }
 
diff --git a/Source/Core/Core/NetPlayClient.cpp b/Source/Core/Core/NetPlayClient.cpp
@@ -254,7 +254,8 @@ bool NetPlayClient::Connect()
   // TODO: make this not hang
   ENetEvent netEvent;
   int net;
-  while ((net = enet_host_service(m_client, &netEvent, 5000)) > 0 && netEvent.type == 42)
+  while ((net = enet_host_service(m_client, &netEvent, 5000)) > 0 &&
+         netEvent.type == ENetEventType(42))  // See PR #11381 and ENetUtil::InterceptCallback
   {
     // ignore packets from traversal server
   }
diff --git a/Source/Core/DolphinQt/Debugger/MemoryViewWidget.cpp b/Source/Core/DolphinQt/Debugger/MemoryViewWidget.cpp
@@ -891,7 +891,7 @@ void MemoryViewWidget::OnContextMenu(const QPoint& pos)
   auto* copy_hex = menu->addAction(tr("Copy Hex"), this, [this, addr] { OnCopyHex(addr); });
   copy_hex->setEnabled(item_has_value);
 
-  auto* copy_value = menu->addAction(tr("Copy Value"), this, [this, item_selected] {
+  auto* copy_value = menu->addAction(tr("Copy Value"), this, [item_selected] {
     QApplication::clipboard()->setText(item_selected->text());
   });
   copy_value->setEnabled(item_has_value);
diff --git a/Source/Core/DolphinQt/Main.cpp b/Source/Core/DolphinQt/Main.cpp
@@ -143,7 +143,7 @@ int main(int argc, char* argv[])
   // code, which makes mouse inputs work again.
   // For more information: https://bugs.dolphin-emu.org/issues/12913
 #if (QT_VERSION >= QT_VERSION_CHECK(6, 3, 0))
-  putenv("QT_XCB_NO_XI2=1");
+  setenv("QT_XCB_NO_XI2", "1", true);
 #endif
 #endif
 
diff --git a/Source/Core/InputCommon/ControllerInterface/Xlib/XInput2.cpp b/Source/Core/InputCommon/ControllerInterface/Xlib/XInput2.cpp
@@ -3,10 +3,8 @@
 
 #include "InputCommon/ControllerInterface/Xlib/XInput2.h"
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wregister"
 #include <X11/XKBlib.h>
-#pragma GCC diagnostic pop
+
 #include <cmath>
 #include <cstdlib>
 #include <cstring>
diff --git a/Source/Core/UpdaterCommon/UpdaterCommon.cpp b/Source/Core/UpdaterCommon/UpdaterCommon.cpp
@@ -58,7 +58,7 @@ void LogToFile(const char* fmt, ...)
   va_end(args);
 }
 
-bool ProgressCallback(double total, double now, double, double)
+bool ProgressCallback(s64 total, s64 now, s64, s64)
 {
   UI::SetCurrentProgress(static_cast<int>(now), static_cast<int>(total));
   return true;
diff --git a/Source/Core/VideoCommon/CPMemory.cpp b/Source/Core/VideoCommon/CPMemory.cpp
@@ -4,6 +4,7 @@
 #include "VideoCommon/CPMemory.h"
 
 #include <cstring>
+#include <type_traits>
 
 #include "Common/ChunkFile.h"
 #include "Common/Logging/Log.h"
@@ -17,14 +18,9 @@ CPState g_preprocess_cp_state;
 
 void CopyPreprocessCPStateFromMain()
 {
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wclass-memaccess"
-#endif
-  std::memcpy(&g_preprocess_cp_state, &g_main_cp_state, sizeof(CPState));
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
+  static_assert(std::is_trivially_copyable_v<CPState>);
+  std::memcpy(static_cast<void*>(&g_preprocess_cp_state),
+              static_cast<const void*>(&g_main_cp_state), sizeof(CPState));
 }
 
 std::pair<std::string, std::string> GetCPRegInfo(u8 cmd, u32 value)
diff --git a/Source/Core/VideoCommon/ShaderCache.cpp b/Source/Core/VideoCommon/ShaderCache.cpp
diff --git a/Source/Core/VideoCommon/TextureCacheBase.cpp b/Source/Core/VideoCommon/TextureCacheBase.cpp
diff --git a/Source/Core/VideoCommon/VertexLoaderManager.cpp b/Source/Core/VideoCommon/VertexLoaderManager.cpp

Original file line number	Diff line number	Diff line change
`@@ -3,42 +3,45 @@`
`3`	`3`
`4`	`4`	`#include "Common/Crypto/bn.h"`
`5`	`5`
	`6`	`+#include <cstddef>`
`6`	`7`	`#include <cstdio>`
`7`	`8`	`#include <cstring>`
`8`	`9`
`9`	`10`	`#include "Common/CommonTypes.h"`
`10`	`11`
`11`		`-static void bn_zero(u8* d, int n)`
	`12`	`+static void bn_zero(u8* d, const size_t n)`
`12`	`13`	`{`
`13`	`14`	`std::memset(d, 0, n);`
`14`	`15`	`}`
`15`	`16`
`16`		`-static void bn_copy(u8* d, const u8* a, int n)`
	`17`	`+static void bn_copy(u8* d, const u8* a, const size_t n)`
`17`	`18`	`{`
`18`	`19`	`std::memcpy(d, a, n);`
`19`	`20`	`}`
`20`	`21`
`21`		`-int bn_compare(const u8* a, const u8* b, int n)`
	`22`	`+int bn_compare(const u8* a, const u8* b, const size_t n)`
`22`	`23`	`{`
`23`	`24`	`return std::memcmp(a, b, n);`
`24`	`25`	`}`
`25`	`26`
`26`		`-void bn_sub_modulus(u8* a, const u8* N, int n)`
	`27`	`+void bn_sub_modulus(u8* a, const u8* N, const size_t n)`
`27`	`28`	`{`
`28`	`29`	`u8 c = 0;`
`29`		`- for (int i = n - 1; i >= 0; --i)`
	`30`	`+ for (size_t i = n; i > 0;)`
`30`	`31`	`{`
	`32`	`+ --i;`
`31`	`33`	`u32 dig = N[i] + c;`
`32`	`34`	`c = (a[i] < dig);`
`33`	`35`	`a[i] -= dig;`
`34`	`36`	`}`
`35`	`37`	`}`
`36`	`38`
`37`		`-void bn_add(u8* d, const u8* a, const u8* b, const u8* N, int n)`
	`39`	`+void bn_add(u8* d, const u8* a, const u8* b, const u8* N, const size_t n)`
`38`	`40`	`{`
`39`	`41`	`u8 c = 0;`
`40`		`- for (int i = n - 1; i >= 0; --i)`
	`42`	`+ for (size_t i = n; i > 0;)`
`41`	`43`	`{`
	`44`	`+ --i;`
`42`	`45`	`u32 dig = a[i] + b[i] + c;`
`43`	`46`	`c = (dig >= 0x100);`
`44`	`47`	`d[i] = dig;`
`@@ -51,11 +54,11 @@ void bn_add(u8* d, const u8* a, const u8* b, const u8* N, int n)`
`51`	`54`	`bn_sub_modulus(d, N, n);`
`52`	`55`	`}`
`53`	`56`
`54`		`-void bn_mul(u8* d, const u8* a, const u8* b, const u8* N, int n)`
	`57`	`+void bn_mul(u8* d, const u8* a, const u8* b, const u8* N, const size_t n)`
`55`	`58`	`{`
`56`	`59`	`bn_zero(d, n);`
`57`	`60`
`58`		`- for (int i = 0; i < n; i++)`
	`61`	`+ for (size_t i = 0; i < n; i++)`
`59`	`62`	`{`
`60`	`63`	`for (u8 mask = 0x80; mask != 0; mask >>= 1)`
`61`	`64`	`{`
`@@ -66,13 +69,13 @@ void bn_mul(u8* d, const u8* a, const u8* b, const u8* N, int n)`
`66`	`69`	`}`
`67`	`70`	`}`
`68`	`71`
`69`		`-void bn_exp(u8* d, const u8* a, const u8* N, int n, const u8* e, int en)`
	`72`	`+void bn_exp(u8* d, const u8* a, const u8* N, const size_t n, const u8* e, const size_t en)`
`70`	`73`	`{`
`71`	`74`	`u8 t[512];`
`72`	`75`
`73`	`76`	`bn_zero(d, n);`
`74`	`77`	`d[n - 1] = 1;`
`75`		`- for (int i = 0; i < en; i++)`
	`78`	`+ for (size_t i = 0; i < en; i++)`
`76`	`79`	`{`
`77`	`80`	`for (u8 mask = 0x80; mask != 0; mask >>= 1)`
`78`	`81`	`{`
`@@ -86,7 +89,7 @@ void bn_exp(u8* d, const u8* a, const u8* N, int n, const u8* e, int en)`
`86`	`89`	`}`
`87`	`90`
`88`	`91`	`// only for prime N -- stupid but lazy, see if I care`
`89`		`-void bn_inv(u8* d, const u8* a, const u8* N, int n)`
	`92`	`+void bn_inv(u8* d, const u8* a, const u8* N, const size_t n)`
`90`	`93`	`{`
`91`	`94`	`u8 t[512], s[512];`
`92`	`95`
Original file line number	Diff line number	Diff line change
`@@ -486,7 +486,7 @@ FSTEntry ScanDirectoryTree(std::string directory, bool recursive)`
`486`	`486`	`}`
`487`	`487`	`else if (cur_depth < prev_depth)`
`488`	`488`	`{`
`489`		`- while (dir_fsts.size() - 1 != cur_depth)`
	`489`	`+ while (dir_fsts.size() != static_cast<size_t>(cur_depth) + 1u)`
`490`	`490`	`{`
`491`	`491`	`calc_dir_size(dir_fsts.top());`
`492`	`492`	`dir_fsts.pop();`
Original file line number	Diff line number	Diff line change
`@@ -33,8 +33,8 @@ class HttpRequest::Impl final`
`33`	`33`	`Response Fetch(const std::string& url, Method method, const Headers& headers, const u8* payload,`
`34`	`34`	`size_t size, AllowedReturnCodes codes = AllowedReturnCodes::Ok_Only);`
`35`	`35`
`36`		`- static int CurlProgressCallback(Impl* impl, double dlnow, double dltotal, double ulnow,`
`37`		`- double ultotal);`
	`36`	`+ static int CurlProgressCallback(Impl* impl, curl_off_t dltotal, curl_off_t dlnow,`
	`37`	`+ curl_off_t ultotal, curl_off_t ulnow);`
`38`	`38`	`std::string EscapeComponent(const std::string& string);`
`39`	`39`
`40`	`40`	`private:`
`@@ -95,11 +95,12 @@ HttpRequest::Response HttpRequest::Post(const std::string& url, const std::strin`
`95`	`95`	`reinterpret_cast<const u8*>(payload.data()), payload.size(), codes);`
`96`	`96`	`}`
`97`	`97`
`98`		`-int HttpRequest::Impl::CurlProgressCallback(Impl* impl, double dlnow, double dltotal, double ulnow,`
`99`		`- double ultotal)`
	`98`	`+int HttpRequest::Impl::CurlProgressCallback(Impl* impl, curl_off_t dltotal, curl_off_t dlnow,`
	`99`	`+ curl_off_t ultotal, curl_off_t ulnow)`
`100`	`100`	`{`
`101`	`101`	`// Abort if callback isn't true`
`102`		`- return !impl->m_callback(dlnow, dltotal, ulnow, ultotal);`
	`102`	`+ return !impl->m_callback(static_cast<s64>(dltotal), static_cast<s64>(dlnow),`
	`103`	`+ static_cast<s64>(ultotal), static_cast<s64>(ulnow));`
`103`	`104`	`}`
`104`	`105`
`105`	`106`	`HttpRequest::Impl::Impl(std::chrono::milliseconds timeout_ms, ProgressCallback callback)`
`@@ -116,7 +117,7 @@ HttpRequest::Impl::Impl(std::chrono::milliseconds timeout_ms, ProgressCallback c`
`116`	`117`	`if (m_callback)`
`117`	`118`	`{`
`118`	`119`	`curl_easy_setopt(m_curl.get(), CURLOPT_PROGRESSDATA, this);`
`119`		`- curl_easy_setopt(m_curl.get(), CURLOPT_PROGRESSFUNCTION, CurlProgressCallback);`
	`120`	`+ curl_easy_setopt(m_curl.get(), CURLOPT_XFERINFOFUNCTION, CurlProgressCallback);`
`120`	`121`	`}`
`121`	`122`
`122`	`123`	`// Set up error buffer`
Original file line number	Diff line number	Diff line change
`@@ -70,12 +70,10 @@ std::string SettingsHandler::GetValue(std::string_view key) const`
`70`	`70`
`71`	`71`	`void SettingsHandler::Decrypt()`
`72`	`72`	`{`
`73`		`- const u8* str = m_buffer.data();`
`74`	`73`	`while (m_position < m_buffer.size())`
`75`	`74`	`{`
`76`	`75`	`decoded.push_back((u8)(m_buffer[m_position] ^ m_key));`
`77`	`76`	`m_position++;`
`78`		`- str++;`
`79`	`77`	`m_key = (m_key >> 31) \| (m_key << 1);`
`80`	`78`	`}`
`81`	`79`
Original file line number	Diff line number	Diff line change
`@@ -384,7 +384,8 @@ void CEXIETHERNET::BuiltInBBAInterface::HandleTCPFrame(const Common::TCPPacket&`
`384`	`384`	`if (size > 0)`
`385`	`385`	`{`
`386`	`386`	`// only if contain data`
`387`		`- if (static_cast<int>(this_seq - ref->ack_num) >= 0 && data.size() >= size)`
	`387`	`+ if (static_cast<int>(this_seq - ref->ack_num) >= 0 &&`
	`388`	`+ data.size() >= static_cast<size_t>(size))`
`388`	`389`	`{`
`389`	`390`	`ref->tcp_socket.send(data.data(), size);`
`390`	`391`	`ref->ack_num += size;`