Merge pull request #2 from Wend4r/fix-errors-by_standards

Clang: fix errors by standards
qubka · Feb 13, 2024 · b257d6e · b257d6e
2 parents 8c8d2e7 + fda775a
commit b257d6e
Show file tree

Hide file tree

Showing 21 changed files with 74 additions and 33 deletions.
diff --git a/include/dynohook/hook.h b/include/dynohook/hook.h
@@ -2,6 +2,7 @@
 
 #include "mem_accessor.h"
 #include "ihook.h"
+#include "platform.h"
 #include <asmjit/asmjit.h>
 
 namespace dyno {

diff --git a/include/dynohook/log.h b/include/dynohook/log.h
@@ -56,8 +56,8 @@ namespace dyno {
 #define DYNO_LOG_WARN(msg) dyno::Log::log(msg, dyno::ErrorLevel::WARN)
 #define DYNO_LOG_ERR(msg)  dyno::Log::log(msg, dyno::ErrorLevel::ERR)
 #else
-#define DYNO_LOG(lvl, msg)
-#define DYNO_LOG_INFO(lvl, msg)
-#define DYNO_LOG_WARN(lvl, msg)
-#define DYNO_LOG_ERR(lvl, msg)
+#define DYNO_LOG(msg)
+#define DYNO_LOG_INFO(msg)
+#define DYNO_LOG_WARN(msg)
+#define DYNO_LOG_ERR(msg)
 #endif
diff --git a/include/dynohook/mem_protector.h b/include/dynohook/mem_protector.h
@@ -11,7 +11,7 @@ namespace dyno {
 	class MemProtector {
 	public:
 		MemProtector() = delete;
-		MemProtector(uintptr_t address, size_t length, ProtFlag prot, MemAccessor& accessor, bool unsetOnDestroy = true);
+		MemProtector(std::uintptr_t address, std::size_t length, ProtFlag prot, MemAccessor& accessor, bool unsetOnDestroy = true);
 		~MemProtector();
 
 		ProtFlag originalProt() const {
@@ -25,8 +25,8 @@ namespace dyno {
 	private:
 		MemAccessor& m_accessor;
 
-		uintptr_t m_address;
-		size_t m_length;
+		std::uintptr_t m_address;
+		std::size_t m_length;
 		bool m_status;
 		bool m_unsetLater;
 

diff --git a/include/dynohook/nat_hook.h b/include/dynohook/nat_hook.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "platform.h"
+
 #if DYNO_ARCH_X86 == 32
 #include <dynohook/x86_hook.h>
 #elif DYNO_ARCH_X86 == 64

diff --git a/include/dynohook/platform.h b/include/dynohook/platform.h
@@ -223,7 +223,7 @@
 #endif
 
 // optimization
-#if DYNO_PLATFORM_GCC_COMPATIBLE
+#if DYNO_PLATFORM_GCC_COMPATIBLE && !(defined(DYNO_PLATFORM_CLANG) && DYNO_PLATFORM_CLANG)
 #define DYNO_OPTS_OFF _Pragma("GCC push_options") _Pragma("GCC optimize (\"O0\")")
 #define DYNO_OPTS_ON _Pragma("GCC pop_options")
 #elif DYNO_PLATFORM_MSVC

diff --git a/include/dynohook/virtuals/vhook.h b/include/dynohook/virtuals/vhook.h
@@ -1,11 +1,12 @@
 #pragma once
 
 #include <dynohook/nat_hook.h>
+#include <cstdint>
 
 namespace dyno {
 	class VHook final : public NatHook {
 	public:
-		VHook(uintptr_t fnAddress, const ConvFunc& convention);
+		VHook(std::uintptr_t fnAddress, const ConvFunc& convention);
 		~VHook() override;
 
 		bool hook() override;
@@ -15,12 +16,12 @@ namespace dyno {
 			return HookMode::VTableSwap;
 		}
 
-		const uintptr_t& getAddress() const override {
+		const std::uintptr_t& getAddress() const override {
 			return m_fnAddress;
 		}
 
 	private:
 		// address of the original function
-		uintptr_t m_fnAddress;
+		std::uintptr_t m_fnAddress;
 	};
 }
diff --git a/src/convention.cpp b/src/convention.cpp
@@ -1,5 +1,7 @@
 #include <dynohook/convention.h>
 
+#include <cstring>
+
 using namespace dyno;
 
 ICallingConvention::ICallingConvention(std::vector<DataObject> arguments, DataObject returnType, size_t alignment) :

diff --git a/src/core.cpp b/src/core.cpp
@@ -1,6 +1,8 @@
 #include <dynohook/core.h>
 #include <dynohook/os.h>
 
+#include <cstring>
+
 namespace dyno {
 
 uintptr_t findPattern(uintptr_t rangeStart, size_t len, const char* pattern) {
@@ -36,7 +38,7 @@ uintptr_t findPattern(uintptr_t rangeStart, size_t len, const char* pattern) {
 }
 
 size_t getPatternSize(const char* pattern) {
-	const size_t l = strlen(pattern);
+	const size_t l = std::strlen(pattern);
 
 	// c = 2 * b + (b - 1) . 2 chars per byte + b - 1 spaces between
 	return (l + 1) / 3;

diff --git a/src/detours/detour.cpp b/src/detours/detour.cpp
@@ -1,4 +1,5 @@
 #include <dynohook/detours/detour.h>
+#include <dynohook/log.h>
 
 #include <cmath>
 

diff --git a/src/detours/x64_detour.cpp b/src/detours/x64_detour.cpp
@@ -1,8 +1,15 @@
+#include <dynohook/core.h>
+#include <dynohook/log.h>
 #include <dynohook/detours/x64_detour.h>
 
 #include <asmtk/asmtk.h>
 #include <Zydis/Register.h>
 
+#include <algorithm>
+#include <iterator>
+#include <map>
+#include <set>
+
 using namespace std::string_literals;
 
 using namespace dyno;

diff --git a/src/fb_allocator.cpp b/src/fb_allocator.cpp
@@ -1,5 +1,8 @@
+#include <dynohook/core.h>
 #include <dynohook/fb_allocator.h>
 
+#include <cstring>
+
 void* ALLOC_NewBlock(ALLOC_Allocator* self)  {
 	ALLOC_Block* pBlock = NULL;
 
@@ -85,7 +88,7 @@ void* ALLOC_Calloc(ALLOC_HANDLE hAlloc, size_t num, size_t size) {
 	pMem = ALLOC_Alloc(hAlloc, n);
 
 	if (pMem) {
-		memset(pMem, 0, n);
+		std::memset(pMem, 0, n);
 	}
 	return pMem;
 }
@@ -112,13 +115,13 @@ void ALLOC_Free(ALLOC_HANDLE hAlloc, void* pBlock) {
 using namespace dyno; 
 
 FBAllocator::FBAllocator(uintptr_t min, uintptr_t max, uint8_t blockSize, uint8_t blockCount) :
-	m_min{min},
-	m_max{max},
-	m_dataPool{0},
-	m_maxBlocks{blockCount},
+	m_alloc2Supported{boundedAllocSupported()},
 	m_usedBlocks{0},
+	m_maxBlocks{blockCount},
 	m_blockSize{blockSize},
-	m_alloc2Supported{boundedAllocSupported()} {
+	m_min{min},
+	m_max{max},
+	m_dataPool{0} {
 }
 
 FBAllocator::~FBAllocator() {

diff --git a/src/hook.cpp b/src/hook.cpp
@@ -1,4 +1,5 @@
 #include <dynohook/hook.h>
+#include <dynohook/log.h>
 
 using namespace dyno;
 

diff --git a/src/instruction.cpp b/src/instruction.cpp
@@ -1,6 +1,8 @@
 #include <dynohook/instruction.h>
 #include <dynohook/mem_accessor.h>
 
+#include <cstring>
+
 using namespace dyno;
 
 Instruction::Instruction(
@@ -15,26 +17,28 @@ Instruction::Instruction(
 	std::string&& opStr,
 	Mode mode
 ) : m_accessor{accessor},
-	m_address{address},
-	m_displacement{displacement},
-	m_dispOffset{displacementOffset},
-	m_dispSize{0},
-	m_isRelative{isRelative},
+
+	m_register{0},
 	m_isIndirect{isIndirect},
 	m_isCalling{false},
 	m_isBranching{false},
+	m_isRelative{isRelative},
 	m_hasDisplacement{false},
 	m_hasImmediate{false},
+	m_displacement{displacement},
+
+	m_address{address},
 	m_immediate{0},
 	m_immediateSize{0},
-	m_register{0},
+	m_dispOffset{displacementOffset},
+	m_dispSize{0},
+
+	m_mode{mode},
+	m_uid{s_counter++},
 
 	m_bytes{std::move(bytes)},
 	m_mnemonic{std::move(mnemonic)},
-	m_opStr{std::move(opStr)},
-
-	m_uid{s_counter++},
-	m_mode{mode} {
+	m_opStr{std::move(opStr)} {
 }
 
 void Instruction::setDestination(uintptr_t dest) {

diff --git a/src/log.cpp b/src/log.cpp
@@ -1,5 +1,7 @@
 #include <dynohook/log.h>
 
+#include <iostream>
+
 using namespace dyno;
 
 void Log::registerLogger(std::shared_ptr<Logger> logger) {

diff --git a/src/mem_accessor.cpp b/src/mem_accessor.cpp
@@ -1,7 +1,10 @@
+#include <dynohook/core.h>
 #include <dynohook/mem_accessor.h>
 #include <dynohook/mem_protector.h>
 #include <dynohook/os.h>
 
+#include <cstring>
+
 using namespace dyno;
 
 #if DYNO_PLATFORM_WINDOWS

diff --git a/src/mem_protector.cpp b/src/mem_protector.cpp
@@ -4,12 +4,12 @@
 
 using namespace dyno;
 
-MemProtector::MemProtector(uintptr_t address, size_t length, ProtFlag prot, MemAccessor& accessor, bool unsetOnDestroy) :
+MemProtector::MemProtector(std::uintptr_t address, std::size_t length, ProtFlag prot, MemAccessor& accessor, bool unsetOnDestroy) :
+	m_accessor{accessor},
 	m_address{address},
 	m_length{length},
-	m_unsetLater{unsetOnDestroy},
-	m_accessor{accessor},
-	m_status{false} {
+	m_status{false},
+	m_unsetLater{unsetOnDestroy} {
 	m_origProtection = m_accessor.mem_protect(address, length, prot, m_status);
 }
 

diff --git a/src/range_allocator.cpp b/src/range_allocator.cpp
@@ -1,6 +1,8 @@
 #include <dynohook/range_allocator.h>
 #include <dynohook/fb_allocator.h>
 
+#include <algorithm>
+
 using namespace dyno;
 
 RangeAllocator::RangeAllocator(uint8_t blockSize, uint8_t blockCount) : m_maxBlocks{blockCount}, m_blockSize{blockSize} {

diff --git a/src/registers.cpp b/src/registers.cpp
@@ -1,5 +1,9 @@
 #include <dynohook/registers.h>
 
+#include <array>
+#include <algorithm>
+#include <cstring>
+
 using namespace dyno;
 
 Register Registers::s_none(NONE, SIZE_INVALID);

diff --git a/src/virtuals/vhook.cpp b/src/virtuals/vhook.cpp
@@ -1,8 +1,9 @@
+#include <dynohook/log.h>
 #include <dynohook/virtuals/vhook.h>
 
 using namespace dyno;
 
-VHook::VHook(uintptr_t fnAddress, const ConvFunc& convention) : NatHook(convention), m_fnAddress{fnAddress} {
+VHook::VHook(std::uintptr_t fnAddress, const ConvFunc& convention) : NatHook(convention), m_fnAddress{fnAddress} {
 	assert(fnAddress != 0 && "Function address cannot be null");
 }
 

diff --git a/src/virtuals/vtable.cpp b/src/virtuals/vtable.cpp
@@ -1,6 +1,10 @@
 #include <dynohook/virtuals/vtable.h>
+#include <dynohook/core.h>
+#include <dynohook/log.h>
 #include <dynohook/mem_protector.h>
 
+#include <cstring>
+
 using namespace dyno;
 
 VTable::VTable(void* pClass, std::shared_ptr<VHookCache> hookCache) : m_class{(void***)pClass}, m_hookCache{std::move(hookCache)} {

diff --git a/src/x64_hook.cpp b/src/x64_hook.cpp
@@ -1,4 +1,5 @@
 #include <dynohook/x64_hook.h>
+#include <dynohook/log.h>
 
 using namespace dyno;
 using namespace asmjit;