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,