Add Clang-Tidy configuration file + a some fixes.

Source/.clang-tidy

@@ -0,0 +1,37 @@
+Checks:  >
+  -*,
+  bugprone-*,
+  -bugprone-branch-clone,
+  -bugprone-easily-swappable-parameters,
+  -bugprone-misplaced-widening-cast,
+  google-*,
+  -google-readability-braces-around-statements,
+  hicpp-*,
+  -hicpp-avoid-c-arrays,
+  -hicpp-braces-around-statements,
+  -hicpp-uppercase-literal-suffix,
+  -hicpp-use-auto,
+  -hicpp-use-equals-default,
+  misc-*,
+  -misc-const-correctness,
+  -misc-include-cleaner,
+  -misc-no-recursion,
+  -misc-non-private-member-variables-in-classes,
+  -misc-unused-parameters,
+  -misc-use-anonymous-namespace,
+  modernize-*,
+  -modernize-avoid-c-arrays,
+  -modernize-use-auto,
+  -modernize-use-nodiscard,
+  -modernize-use-trailing-return-type,
+  performance-*,
+  -performance-no-int-to-ptr,
+  readability-*,
+  -readability-braces-around-statements,
+  -readability-function-cognitive-complexity,
+  -readability-identifier-length,
+  -readability-implicit-bool-conversion,
+  -readability-magic-numbers,
+  -readability-uppercase-literal-suffix
+
+FormatStyle: file

Source/CMakeLists.txt

@@ -4,6 +4,8 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(GCC_min_version 10)
 project(dolphin-memory-engine)
 
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
 if(WIN32)
     set(DolphinProcessSrc DolphinProcess/Windows/WindowsDolphinProcess.cpp)
     set(ExeIconSrc Resources/exeicon.rc)

Source/CheatEngineParser/CheatEngineParser.cpp

@@ -39,7 +39,6 @@ MemWatchTreeNode* CheatEngineParser::parseCTFile(QIODevice* CTFileIODevice,
 
   if (m_xmlReader->readNextStartElement())
   {
-    std::string test = m_xmlReader->name().toString().toStdString();
     if (m_xmlReader->name() == QString("CheatTable"))
     {
       MemWatchTreeNode* rootNode = new MemWatchTreeNode(nullptr);
@@ -71,7 +70,6 @@ MemWatchTreeNode* CheatEngineParser::parseCheatTable(MemWatchTreeNode* rootNode,
   {
     if (m_xmlReader->readNextStartElement())
     {
-      std::string test = m_xmlReader->name().toString().toStdString();
       if (m_xmlReader->name() == QString("CheatEntries"))
         parseCheatEntries(rootNode, useDolphinPointer);
     }
@@ -95,7 +93,6 @@ MemWatchTreeNode* CheatEngineParser::parseCheatEntries(MemWatchTreeNode* node,
   {
     if (m_xmlReader->readNextStartElement())
     {
-      std::string test = m_xmlReader->name().toString().toStdString();
       if (m_xmlReader->name() == QString("CheatEntry"))
         parseCheatEntry(node, useDolphinPointer);
     }
@@ -362,7 +359,7 @@ void CheatEngineParser::verifyCheatEntryParsingErrors(cheatEntryParsingState sta
   }
 }
 
-QString CheatEngineParser::formatImportedEntryBasicInfo(const MemWatchEntry* entry) const
+QString CheatEngineParser::formatImportedEntryBasicInfo(const MemWatchEntry* const entry)
 {
   QString formatedEntry = "";
   formatedEntry += "Label: " + entry->getLabel() + "\n";

Source/CheatEngineParser/CheatEngineParser.h

@@ -38,7 +38,7 @@ class CheatEngineParser
   void parseCheatEntry(MemWatchTreeNode* node, const bool useDolphinPointer);
   void verifyCheatEntryParsingErrors(cheatEntryParsingState state, MemWatchEntry* entry,
                                      bool isGroup, const bool useDolphinPointer);
-  QString formatImportedEntryBasicInfo(const MemWatchEntry* entry) const;
+  static QString formatImportedEntryBasicInfo(const MemWatchEntry* entry);
 
   u64 m_tableStartAddress = 0;
   QString m_errorMessages = "";

Source/Common/CommonTypes.h

@@ -2,12 +2,12 @@
 
 #include <cstdint>
 
-typedef uint64_t u64;
-typedef uint32_t u32;
-typedef uint16_t u16;
-typedef uint8_t u8;
+using u64 = uint64_t;
+using u32 = uint32_t;
+using u16 = uint16_t;
+using u8 = uint8_t;
 
-typedef int64_t s64;
-typedef int32_t s32;
-typedef int16_t s16;
-typedef int8_t s8;
+using s64 = int64_t;
+using s32 = int32_t;
+using s16 = int16_t;
+using s8 = int8_t;

Source/Common/CommonUtils.h

@@ -21,6 +21,19 @@
 
 namespace Common
 {
+template <typename To, typename From>
+To bit_cast(From from)  // To be replaced with std::bit_cast when available
+{
+  static_assert(sizeof(From) == sizeof(To), "Type sizes do not match");
+  union
+  {
+    From f;
+    To t;
+  } u;
+  u.f = from;
+  return u.t;
+}
+
 #ifdef _WIN32
 inline u16 bSwap16(u16 data)
 {

Source/Common/MemoryCommon.cpp

@@ -125,16 +125,17 @@ int getNbrBytesAlignmentForType(const MemType type)
 }
 
 char* formatStringToMemory(MemOperationReturnCode& returnCode, size_t& actualLength,
-                           const std::string inputString, const MemBase base, const MemType type,
-                           const size_t length)
+                           const std::string_view inputString, const MemBase base,
+                           const MemType type, const size_t length)
 {
-  if (inputString.length() == 0)
+  if (inputString.empty())
   {
     returnCode = MemOperationReturnCode::invalidInput;
     return nullptr;
   }
 
-  std::stringstream ss(inputString);
+  std::stringstream ss;
+  ss << inputString;
   switch (base)
   {
   case MemBase::base_octal:
@@ -158,19 +159,20 @@ char* formatStringToMemory(MemOperationReturnCode& returnCode, size_t& actualLen
     u8 theByte = 0;
     if (base == MemBase::base_binary)
     {
-      unsigned long long input = 0;
+      u8 input{};
       try
       {
-        input = std::bitset<sizeof(u8) * 8>(inputString).to_ullong();
+        input = static_cast<u8>(
+            std::bitset<sizeof(u8) * 8>(inputString.data(), inputString.size()).to_ullong());
       }
-      catch (std::invalid_argument)
+      catch (const std::invalid_argument&)
       {
         delete[] buffer;
         buffer = nullptr;
         returnCode = MemOperationReturnCode::invalidInput;
         return buffer;
       }
-      theByte = static_cast<u8>(input);
+      theByte = input;
     }
     else
     {
@@ -196,19 +198,20 @@ char* formatStringToMemory(MemOperationReturnCode& returnCode, size_t& actualLen
     u16 theHalfword = 0;
     if (base == MemBase::base_binary)
     {
-      unsigned long long input = 0;
+      u16 input{};
       try
       {
-        input = std::bitset<sizeof(u16) * 8>(inputString).to_ullong();
+        input = static_cast<u16>(
+            std::bitset<sizeof(u16) * 8>(inputString.data(), inputString.size()).to_ullong());
       }
-      catch (std::invalid_argument)
+      catch (const std::invalid_argument&)
       {
         delete[] buffer;
         buffer = nullptr;
         returnCode = MemOperationReturnCode::invalidInput;
         return buffer;
       }
-      theHalfword = static_cast<u16>(input);
+      theHalfword = input;
     }
     else
     {
@@ -232,19 +235,20 @@ char* formatStringToMemory(MemOperationReturnCode& returnCode, size_t& actualLen
     u32 theWord = 0;
     if (base == MemBase::base_binary)
     {
-      unsigned long long input = 0;
+      u32 input{};
       try
       {
-        input = std::bitset<sizeof(u32) * 8>(inputString).to_ullong();
+        input = static_cast<u32>(
+            std::bitset<sizeof(u32) * 8>(inputString.data(), inputString.size()).to_ullong());
       }
-      catch (std::invalid_argument)
+      catch (const std::invalid_argument&)
       {
         delete[] buffer;
         buffer = nullptr;
         returnCode = MemOperationReturnCode::invalidInput;
         return buffer;
       }
-      theWord = static_cast<u32>(input);
+      theWord = input;
     }
     else
     {
@@ -270,10 +274,11 @@ char* formatStringToMemory(MemOperationReturnCode& returnCode, size_t& actualLen
       u32 theWord = 0;
       if (base == MemBase::base_binary)
       {
-        unsigned long long input = 0;
+        u32 input{};
         try
         {
-          input = std::bitset<sizeof(u32) * 8>(inputString).to_ullong();
+          input = static_cast<u32>(
+              std::bitset<sizeof(u32) * 8>(inputString.data(), inputString.size()).to_ullong());
         }
         catch (const std::invalid_argument&)
         {
@@ -282,7 +287,7 @@ char* formatStringToMemory(MemOperationReturnCode& returnCode, size_t& actualLen
           returnCode = MemOperationReturnCode::invalidInput;
           return buffer;
         }
-        theWord = static_cast<u32>(input);
+        theWord = input;
       }
       else
       {
@@ -323,10 +328,11 @@ char* formatStringToMemory(MemOperationReturnCode& returnCode, size_t& actualLen
       u64 theDoubleWord = 0;
       if (base == MemBase::base_binary)
       {
-        unsigned long long input = 0;
+        u64 input{};
         try
         {
-          input = std::bitset<sizeof(u64) * 8>(inputString).to_ullong();
+          input = static_cast<u64>(
+              std::bitset<sizeof(u64) * 8>(inputString.data(), inputString.size()).to_ullong());
         }
         catch (const std::invalid_argument&)
         {
@@ -335,7 +341,7 @@ char* formatStringToMemory(MemOperationReturnCode& returnCode, size_t& actualLen
           returnCode = MemOperationReturnCode::invalidInput;
           return buffer;
         }
-        theDoubleWord = static_cast<u64>(input);
+        theDoubleWord = input;
       }
       else
       {
@@ -378,7 +384,7 @@ char* formatStringToMemory(MemOperationReturnCode& returnCode, size_t& actualLen
       returnCode = MemOperationReturnCode::inputTooLong;
       return buffer;
     }
-    std::memcpy(buffer, inputString.c_str(), length);
+    std::memcpy(buffer, inputString.data(), length);
     actualLength = length;
     break;
   }
@@ -419,7 +425,6 @@ char* formatStringToMemory(MemOperationReturnCode& returnCode, size_t& actualLen
     int index = 0;
     for (const auto& i : bytes)
     {
-      std::stringstream byteStream(i);
       ss >> std::hex;
       u8 theByte = 0;
       int theByteInt = 0;

Source/Common/MemoryCommon.h

@@ -2,6 +2,7 @@
 
 #include <cstddef>
 #include <string>
+#include <string_view>
 
 #include "CommonTypes.h"
 
@@ -58,8 +59,7 @@ size_t getSizeForType(const MemType type, const size_t length);
 bool shouldBeBSwappedForType(const MemType type);
 int getNbrBytesAlignmentForType(const MemType type);
 char* formatStringToMemory(MemOperationReturnCode& returnCode, size_t& actualLength,
-                           const std::string inputString, const MemBase base, const MemType type,
-                           const size_t length);
+                           std::string_view inputString, MemBase base, MemType type, size_t length);
 std::string formatMemoryToString(const char* memory, const MemType type, const size_t length,
                                  const MemBase base, const bool isUnsigned,
                                  const bool withBSwap = false);

Source/DolphinProcess/IDolphinProcess.h

@@ -10,7 +10,7 @@ namespace DolphinComm
 class IDolphinProcess
 {
 public:
-  virtual ~IDolphinProcess() {}
+  virtual ~IDolphinProcess() = default;
   virtual bool findPID() = 0;
   virtual bool obtainEmuRAMInformations() = 0;
   virtual bool readFromRAM(const u32 offset, char* buffer, const size_t size,

Source/DolphinProcess/Linux/LinuxDolphinProcess.cpp

@@ -36,7 +36,7 @@ bool LinuxDolphinProcess::obtainEmuRAMInformations()
       continue;
 
     bool foundDevShmDolphin = false;
-    for (auto str : lineData)
+    for (const std::string& str : lineData)
     {
       if (str.substr(0, 19) == "/dev/shm/dolphinmem" || str.substr(0, 20) == "/dev/shm/dolphin-emu")
       {
@@ -163,7 +163,7 @@ bool LinuxDolphinProcess::readFromRAM(const u32 offset, char* buffer, const size
 
   local.iov_base = buffer;
   local.iov_len = size;
-  remote.iov_base = (void*)RAMAddress;
+  remote.iov_base = reinterpret_cast<void*>(RAMAddress);
   remote.iov_len = size;
 
   nread = process_vm_readv(m_PID, &local, 1, &remote, 1, 0);
@@ -232,7 +232,7 @@ bool LinuxDolphinProcess::writeToRAM(const u32 offset, const char* buffer, const
 
   local.iov_base = bufferCopy;
   local.iov_len = size;
-  remote.iov_base = (void*)RAMAddress;
+  remote.iov_base = reinterpret_cast<void*>(RAMAddress);
   remote.iov_len = size;
 
   if (withBSwap)

Source/DolphinProcess/Linux/LinuxDolphinProcess.h

@@ -13,7 +13,7 @@ namespace DolphinComm
 class LinuxDolphinProcess : public IDolphinProcess
 {
 public:
-  LinuxDolphinProcess() {}
+  LinuxDolphinProcess() = default;
   bool findPID() override;
   bool obtainEmuRAMInformations() override;
   bool readFromRAM(const u32 offset, char* buffer, size_t size, const bool withBSwap) override;

Source/DolphinProcess/Mac/MacDolphinProcess.h

@@ -10,7 +10,7 @@ namespace DolphinComm
 class MacDolphinProcess : public IDolphinProcess
 {
 public:
-  MacDolphinProcess() {}
+  MacDolphinProcess() = default;
   bool findPID() override;
   bool obtainEmuRAMInformations() override;
   bool readFromRAM(const u32 offset, char* buffer, size_t size, const bool withBSwap) override;

Source/DolphinProcess/Windows/WindowsDolphinProcess.cpp

@@ -173,7 +173,8 @@ bool WindowsDolphinProcess::readFromRAM(const u32 offset, char* buffer, const si
   }
 
   SIZE_T nread = 0;
-  bool bResult = ReadProcessMemory(m_hDolphin, (void*)RAMAddress, buffer, size, &nread);
+  const bool bResult{static_cast<bool>(
+      ReadProcessMemory(m_hDolphin, reinterpret_cast<void*>(RAMAddress), buffer, size, &nread))};
   if (bResult && nread == size)
   {
     if (withBSwap)
@@ -265,7 +266,8 @@ bool WindowsDolphinProcess::writeToRAM(const u32 offset, const char* buffer, con
     }
   }
 
-  bool bResult = WriteProcessMemory(m_hDolphin, (void*)RAMAddress, bufferCopy, size, &nread);
+  const bool bResult{static_cast<bool>(WriteProcessMemory(
+      m_hDolphin, reinterpret_cast<void*>(RAMAddress), bufferCopy, size, &nread))};
   delete[] bufferCopy;
   return (bResult && nread == size);
 }

Source/DolphinProcess/Windows/WindowsDolphinProcess.h

@@ -11,7 +11,7 @@ namespace DolphinComm
 class WindowsDolphinProcess : public IDolphinProcess
 {
 public:
-  WindowsDolphinProcess() {}
+  WindowsDolphinProcess() = default;
   bool findPID() override;
   bool obtainEmuRAMInformations() override;
   bool readFromRAM(const u32 offset, char* buffer, const size_t size,