Merge pull request #172 from orange-cpp/feaute/methods_calling_improvement

Feaute/methods calling improvement

include/omath/rev_eng/internal_rev_object.hpp

@@ -3,7 +3,6 @@
 //
 
 #pragma once
-#include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
@@ -23,18 +22,23 @@
 namespace omath::rev_eng
 {
     template<std::size_t N>
-    struct FixedString
+    struct FixedString final
     {
         char data[N]{};
-        constexpr FixedString(const char (&str)[N])
+        // ReSharper disable once CppNonExplicitConvertingConstructor
+        constexpr FixedString(const char (&str)[N]) noexcept // NOLINT(*-explicit-constructor)
         {
-            std::copy_n(str, N, data);
+            for (std::size_t i = 0; i < N; ++i)
+                data[i] = str[i];
         }
-        constexpr operator std::string_view() const
+        // ReSharper disable once CppNonExplicitConversionOperator
+        constexpr operator std::string_view() const noexcept // NOLINT(*-explicit-constructor)
         {
             return {data, N - 1};
         }
     };
+    template<std::size_t N>
+    FixedString(const char (&)[N]) -> FixedString<N>;
 
     class InternalReverseEngineeredObject
     {
@@ -72,68 +76,69 @@ namespace omath::rev_eng
             return reinterpret_cast<MethodType>(const_cast<void*>(ptr))(this, arg_list...);
         }
 
-        template<FixedString module_name, FixedString pattern, class ReturnType>
+        template<FixedString ModuleName, FixedString Pattern, class ReturnType>
         ReturnType call_method(auto... arg_list)
         {
-            static const auto address = []() -> const void*
+            static const auto* address = resolve_pattern(ModuleName, Pattern);
-            {
-                const auto* base = get_module_base(module_name);
-                assert(base && "Failed to find module");
-
-#ifdef _WIN32
-                auto result = PePatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#elif defined(__APPLE__)
-                auto result = MachOPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#else
-                auto result = ElfPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#endif
-                assert(result.has_value() && "Pattern scan failed");
-                return reinterpret_cast<const void*>(*result);
-            }();
-
             return call_method<ReturnType>(address, arg_list...);
         }
 
-        template<FixedString module_name, FixedString pattern, class ReturnType>
+        template<FixedString ModuleName, FixedString Pattern, class ReturnType>
         ReturnType call_method(auto... arg_list) const
         {
-            static const auto address = []() -> const void*
+            static const auto* address = resolve_pattern(ModuleName, Pattern);
-            {
-                const auto* base = get_module_base(module_name);
-                assert(base && "Failed to find module");
-
-#ifdef _WIN32
-                auto result = PePatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#elif defined(__APPLE__)
-                auto result = MachOPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#else
-                auto result = ElfPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#endif
-                assert(result.has_value() && "Pattern scan failed");
-                return reinterpret_cast<const void*>(*result);
-            }();
-
             return call_method<ReturnType>(address, arg_list...);
         }
 
-        template<std::size_t id, class ReturnType>
+        template<class ReturnType>
+        ReturnType call_method(const std::string_view& module_name,const std::string_view& pattern, auto... arg_list)
+        {
+            static const auto* address = resolve_pattern(module_name, pattern);
+            return call_method<ReturnType>(address, arg_list...);
+        }
+
+        template<class ReturnType>
+        ReturnType call_method(const std::string_view& module_name,const std::string_view& pattern, auto... arg_list) const
+        {
+            static const auto* address = resolve_pattern(module_name, pattern);
+            return call_method<ReturnType>(address, arg_list...);
+        }
+        template<std::size_t Id, class ReturnType>
         ReturnType call_virtual_method(auto... arg_list)
         {
             const auto vtable = *reinterpret_cast<void***>(this);
-            return call_method<ReturnType>(vtable[id], arg_list...);
+            return call_method<ReturnType>(vtable[Id], arg_list...);
         }
-        template<std::size_t id, class ReturnType>
+        template<std::size_t Id, class ReturnType>
         ReturnType call_virtual_method(auto... arg_list) const
         {
             const auto vtable = *reinterpret_cast<void* const* const*>(this);
-            return call_method<ReturnType>(vtable[id], arg_list...);
+            return call_method<ReturnType>(vtable[Id], arg_list...);
         }
 
     private:
+        [[nodiscard]]
+        static const void* resolve_pattern(const std::string_view module_name, const std::string_view pattern)
+        {
+            const auto* base = get_module_base(module_name);
+            assert(base && "Failed to find module");
+
+#ifdef _WIN32
+            const auto result = PePatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#elif defined(__APPLE__)
+            const auto result = MachOPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#else
+            const auto result = ElfPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#endif
+            assert(result.has_value() && "Pattern scan failed");
+            return reinterpret_cast<const void*>(*result);
+        }
+
+        [[nodiscard]]
         static const void* get_module_base(const std::string_view module_name)
         {
 #ifdef _WIN32
-            return static_cast<const void*>(GetModuleHandleA(module_name.data()));
+            return GetModuleHandleA(module_name.data());
 #elif defined(__APPLE__)
             // On macOS, iterate loaded images to find the module by name
             const auto count = _dyld_image_count();

tests/general/unit_test_reverse_enineering.cpp

@@ -20,6 +20,13 @@ public:
     int m_health{123};
 };
 
+// Extract a raw function pointer from an object's vtable
+inline const void* get_vtable_entry(const void* obj, const std::size_t index)
+{
+    const auto vtable = *static_cast<void* const* const*>(obj);
+    return vtable[index];
+}
+
 class RevPlayer final : omath::rev_eng::InternalReverseEngineeredObject
 {
 public:
@@ -51,6 +58,17 @@ public:
     {
         return call_virtual_method<1, int>();
     }
+
+    // Wrappers exposing call_method for testing — use vtable entries as known-good function pointers
+    int call_foo_via_ptr(const void* fn_ptr) const
+    {
+        return call_method<int>(fn_ptr);
+    }
+
+    int call_bar_via_ptr(const void* fn_ptr) const
+    {
+        return call_method<int>(fn_ptr);
+    }
 };
 
 TEST(unit_test_reverse_enineering, read_test)
@@ -64,4 +82,39 @@ TEST(unit_test_reverse_enineering, read_test)
     EXPECT_EQ(player_original.bar(), player_reversed->rev_bar());
     EXPECT_EQ(player_original.foo(), player_reversed->rev_foo());
     EXPECT_EQ(player_original.bar(), player_reversed->rev_bar_const());
+}
+
+TEST(unit_test_reverse_enineering, call_method_with_vtable_ptr)
+{
+    // Extract raw function pointers from Player's vtable, then call them via call_method
+    Player player;
+    const auto* rev = reinterpret_cast<const RevPlayer*>(&player);
+
+    const auto* foo_ptr = get_vtable_entry(&player, 0);
+    const auto* bar_ptr = get_vtable_entry(&player, 1);
+
+    EXPECT_EQ(player.foo(), rev->call_foo_via_ptr(foo_ptr));
+    EXPECT_EQ(player.bar(), rev->call_bar_via_ptr(bar_ptr));
+    EXPECT_EQ(1, rev->call_foo_via_ptr(foo_ptr));
+    EXPECT_EQ(2, rev->call_bar_via_ptr(bar_ptr));
+}
+
+TEST(unit_test_reverse_enineering, call_method_same_result_as_virtual)
+{
+    // call_virtual_method delegates to call_method — both paths must agree
+    Player player;
+    const auto* rev = reinterpret_cast<const RevPlayer*>(&player);
+
+    EXPECT_EQ(rev->rev_foo(), rev->call_foo_via_ptr(get_vtable_entry(&player, 0)));
+    EXPECT_EQ(rev->rev_bar(), rev->call_bar_via_ptr(get_vtable_entry(&player, 1)));
+}
+
+TEST(unit_test_reverse_enineering, call_virtual_method_delegates_to_call_method)
+{
+    Player player;
+    auto* rev = reinterpret_cast<RevPlayer*>(&player);
+
+    EXPECT_EQ(1, rev->rev_foo());
+    EXPECT_EQ(2, rev->rev_bar());
+    EXPECT_EQ(2, rev->rev_bar_const());
 }