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

Feaute/methods calling improvement

include/omath/rev_eng/internal_rev_object.hpp

@@ -21,6 +21,25 @@
 
 namespace omath::rev_eng
 {
+    template<std::size_t N>
+    struct FixedString final
+    {
+        char data[N]{};
+        // ReSharper disable once CppNonExplicitConvertingConstructor
+        constexpr FixedString(const char (&str)[N]) noexcept // NOLINT(*-explicit-constructor)
+        {
+            for (std::size_t i = 0; i < N; ++i)
+                data[i] = str[i];
+        }
+        // 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
     {
     protected:
@@ -57,54 +76,69 @@ namespace omath::rev_eng
             return reinterpret_cast<MethodType>(const_cast<void*>(ptr))(this, arg_list...);
         }
 
-        template<auto module_name, auto pattern, class ReturnType>
+        template<FixedString ModuleName, FixedString Pattern, class ReturnType>
         ReturnType call_method(auto... arg_list)
         {
-            static const auto* address = resolve_pattern(module_name, pattern);
+            static const auto* address = resolve_pattern(ModuleName, Pattern);
             return call_method<ReturnType>(address, arg_list...);
         }
 
-        template<auto module_name, auto pattern, class ReturnType>
+        template<FixedString ModuleName, FixedString Pattern, class ReturnType>
         ReturnType call_method(auto... arg_list) const
+        {
+            static const auto* address = resolve_pattern(ModuleName, 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)
         {
             static const auto* address = resolve_pattern(module_name, pattern);
             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) 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
-            auto result = PePatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+            const 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);
+            const auto result = MachOPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
 #else
-            auto result = ElfPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+            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,10 +20,12 @@ public:
     int m_health{123};
 };
 
-// Free functions that mimic member function calling convention (this as first arg)
+// Extract a raw function pointer from an object's vtable
-inline int free_add(void* /*this_ptr*/, int a, int b) { return a + b; }
+inline const void* get_vtable_entry(const void* obj, const std::size_t index)
-inline float free_scale(void* /*this_ptr*/, float val, float factor) { return val * factor; }
+{
-inline int free_get_42(const void* /*this_ptr*/) { return 42; }
+    const auto vtable = *static_cast<void* const* const*>(obj);
+    return vtable[index];
+}
 
 class RevPlayer final : omath::rev_eng::InternalReverseEngineeredObject
 {
@@ -57,20 +59,15 @@ public:
         return call_virtual_method<1, int>();
     }
 
-    // Wrappers exposing call_method for testing
+    // Wrappers exposing call_method for testing — use vtable entries as known-good function pointers
-    int call_add(int a, int b)
+    int call_foo_via_ptr(const void* fn_ptr) const
     {
-        return call_method<int>(reinterpret_cast<const void*>(&free_add), a, b);
+        return call_method<int>(fn_ptr);
     }
 
-    float call_scale(float val, float factor)
+    int call_bar_via_ptr(const void* fn_ptr) const
     {
-        return call_method<float>(reinterpret_cast<const void*>(&free_scale), val, factor);
+        return call_method<int>(fn_ptr);
-    }
-
-    int call_get_42() const
-    {
-        return call_method<int>(reinterpret_cast<const void*>(&free_get_42));
     }
 };
 
@@ -87,48 +84,37 @@ TEST(unit_test_reverse_enineering, read_test)
     EXPECT_EQ(player_original.bar(), player_reversed->rev_bar_const());
 }
 
-TEST(unit_test_reverse_enineering, call_method_with_args)
+TEST(unit_test_reverse_enineering, call_method_with_vtable_ptr)
 {
-    Player player_original;
+    // Extract raw function pointers from Player's vtable, then call them via call_method
-    auto* player_reversed = reinterpret_cast<RevPlayer*>(&player_original);
+    Player player;
+    const auto* rev = reinterpret_cast<const RevPlayer*>(&player);
 
-    EXPECT_EQ(free_add(nullptr, 3, 4), player_reversed->call_add(3, 4));
+    const auto* foo_ptr = get_vtable_entry(&player, 0);
-    EXPECT_EQ(7, player_reversed->call_add(3, 4));
+    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_float_args)
+TEST(unit_test_reverse_enineering, call_method_same_result_as_virtual)
 {
-    Player player_original;
+    // call_virtual_method delegates to call_method — both paths must agree
-    auto* player_reversed = reinterpret_cast<RevPlayer*>(&player_original);
+    Player player;
+    const auto* rev = reinterpret_cast<const RevPlayer*>(&player);
 
-    EXPECT_FLOAT_EQ(6.0f, player_reversed->call_scale(2.0f, 3.0f));
+    EXPECT_EQ(rev->rev_foo(), rev->call_foo_via_ptr(get_vtable_entry(&player, 0)));
-    EXPECT_FLOAT_EQ(0.0f, player_reversed->call_scale(0.0f, 100.0f));
+    EXPECT_EQ(rev->rev_bar(), rev->call_bar_via_ptr(get_vtable_entry(&player, 1)));
-    EXPECT_FLOAT_EQ(-5.0f, player_reversed->call_scale(5.0f, -1.0f));
-}
-
-TEST(unit_test_reverse_enineering, call_method_const)
-{
-    Player player_original;
-    const auto* player_reversed = reinterpret_cast<const RevPlayer*>(&player_original);
-
-    EXPECT_EQ(42, player_reversed->call_get_42());
-}
-
-TEST(unit_test_reverse_enineering, call_method_no_extra_args)
-{
-    Player player_original;
-    const auto* player_reversed = reinterpret_cast<const RevPlayer*>(&player_original);
-
-    // call_get_42 takes no arguments beyond this — verifies zero-arg pack works
-    EXPECT_EQ(42, player_reversed->call_get_42());
 }
 
 TEST(unit_test_reverse_enineering, call_virtual_method_delegates_to_call_method)
 {
-    // call_virtual_method now internally uses call_method — verify both vtable slots
+    Player player;
-    Player player_original;
+    auto* rev = reinterpret_cast<RevPlayer*>(&player);
-    auto* player_reversed = reinterpret_cast<RevPlayer*>(&player_original);
 
-    EXPECT_EQ(1, player_reversed->rev_foo());
+    EXPECT_EQ(1, rev->rev_foo());
-    EXPECT_EQ(2, player_reversed->rev_bar());
+    EXPECT_EQ(2, rev->rev_bar());
+    EXPECT_EQ(2, rev->rev_bar_const());
 }