fix: compilation warnings

Author: qubka

include/dynlibutils/memaddr.hpp

@@ -112,7 +112,7 @@ class CMemory
 
 	// Addition and subtraction operators.
 	CMemory operator+(const std::size_t right) const noexcept { return Offset(right); }
-	CMemory operator-(const std::size_t right) const noexcept { return Offset(-right); }
+	CMemory operator-(const std::size_t right) const noexcept { return Offset(-static_cast<std::ptrdiff_t>(right)); }
 	CMemory operator+(const std::ptrdiff_t right) const noexcept { return Offset(right); }
 	CMemory operator-(const std::ptrdiff_t right) const noexcept { return Offset(-right); }
 	CMemory operator+(const CMemory right) const noexcept { return Offset(static_cast<std::ptrdiff_t>(right.m_addr)); }

include/dynlibutils/module.hpp

@@ -83,9 +83,23 @@ concept PatternCallback_t = requires(T func, std::size_t index, CMemory match)
 #	define PatternCallback_t typename
 #endif
 
+#if defined(__clang__)
+#  define DYNLIB_FORCE_INLINE [[gnu::always_inline]] [[gnu::gnu_inline]] extern inline
+#  define DYNLIB_NOINLINE [[gnu::noinline]]
+#elif defined(__GNUC__)
+#  define DYNLIB_FORCE_INLINE [[gnu::always_inline]] inline
+#  define DYNLIB_NOINLINE [[gnu::noinline]]
+#elif defined(_MSC_VER)
+#  pragma warning(error: 4714)
+#  define DYNLIB_FORCE_INLINE [[msvc::forceinline]]
+#  define DYNLIB_NOINLINE __declspec(noinline)
+#else
+#  define DYNLIB_FORCE_INLINE inline
+#  define DYNLIB_NOINLINE
+#endif
+
 template<std::size_t INDEX = 0, std::size_t N, std::size_t SIZE = (N - 1) / 2>
-[[always_inline, nodiscard]]
-inline DYNLIB_COMPILE_TIME_EXPR void ProcessStringPattern(const char (&szInput)[N], std::size_t& n, std::size_t& nIndex, std::array<std::uint8_t, SIZE>& aBytes, std::array<char, SIZE>& aMask)
+DYNLIB_FORCE_INLINE DYNLIB_COMPILE_TIME_EXPR void ProcessStringPattern(const char (&szInput)[N], std::size_t& n, std::size_t& nIndex, std::array<std::uint8_t, SIZE>& aBytes, std::array<char, SIZE>& aMask)
 {
 	static_assert(SIZE > 0, "Process pattern cannot be empty");
 
@@ -172,8 +186,7 @@ inline DYNLIB_COMPILE_TIME_EXPR void ProcessStringPattern(const char (&szInput)[
 // Output : Pattern_t<SIZE> (fixed-size array by N cells with mask and used size)
 //----------------------------------------------------------------------------
 template<std::size_t N, std::size_t SIZE = (N - 1) / 2>
-[[always_inline, nodiscard]]
-inline DYNLIB_COMPILE_TIME_EXPR auto ParseStringPattern(const char (&szInput)[N])
+[[nodiscard]] DYNLIB_FORCE_INLINE DYNLIB_COMPILE_TIME_EXPR auto ParseStringPattern(const char (&szInput)[N])
 {
 	static_assert(SIZE > 0, "Pattern cannot be empty");
 

include/dynlibutils/vthook.hpp

@@ -81,7 +81,7 @@ class VirtualUnprotector final
 		m_nLength = nLength;
 		m_pTarget = pTarget;
 
-		bool bIsUnprotected = VirtualProtect(pTarget, nLength, PAGE_EXECUTE_READWRITE, &m_nOldProtect);
+		[[maybe_unused]] bool bIsUnprotected = VirtualProtect(pTarget, nLength, PAGE_EXECUTE_READWRITE, &m_nOldProtect);
 #else
 		long pageSize = sysconf(_SC_PAGESIZE);
 
@@ -117,9 +117,9 @@ class VirtualUnprotector final
 	{
 #if _WIN32
 		DWORD origProtect;
-		bool bIsUnprotected = VirtualProtect(m_pTarget, m_nLength, m_nOldProtect, &origProtect);
+		[[maybe_unused]] bool bIsUnprotected = VirtualProtect(m_pTarget, m_nLength, m_nOldProtect, &origProtect);
 #else
-		bool bIsUnprotected = !mprotect(m_pTarget, m_nLength, m_nOldProtect);
+		[[maybe_unused]] bool bIsUnprotected = !mprotect(m_pTarget, m_nLength, m_nOldProtect);
 #endif
 
 		assert(bIsUnprotected);
@@ -507,8 +507,8 @@ class CVTHookAutoBase<T, METHOD> : public T<R, C*, Args...>
 	using CBase = T<R, C*, Args...>;
 	using CBase::CBase;
 
-	[[ always_inline ]] // Wend4r (Linux): don't allow typeinfo/rtti to be generated for templated C argument.
-	void Hook(CVirtualTable pVTable, typename CBase::Function_t &&func) noexcept
+	// Wend4r (Linux): don't allow typeinfo/rtti to be generated for templated C argument.
+	DYNLIB_FORCE_INLINE void Hook(CVirtualTable pVTable, typename CBase::Function_t &&func) noexcept
 	{
 		CBase::Hook(pVTable, GetVirtualIndex<METHOD>(), std::move(func));
 	}