Revert to C++17

Author: MiranDMC

hooking/Hooking.Patterns.cpp

@@ -12,7 +12,6 @@
 #include "Hooking.Patterns.h"
 
 #define WIN32_LEAN_AND_MEAN
-#define NOMINMAX
 #include <windows.h>
 #include <algorithm>
 

injector/assembly.hpp

@@ -1,13 +1,88 @@
-#pragma once
 /*
-// Original assembly.hpp functions moved to SafetyHook
-*/
+ *  Injectors - Useful Assembly Stuff
+ *
+ *  Copyright (C) 2012-2014 LINK/2012 <[email protected]>
+ *
+ *  This software is provided 'as-is', without any express or implied
+ *  warranty. In no event will the authors be held liable for any damages
+ *  arising from the use of this software.
+ * 
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ * 
+ *     1. The origin of this software must not be misrepresented; you must not
+ *     claim that you wrote the original software. If you use this software
+ *     in a product, an acknowledgment in the product documentation would be
+ *     appreciated but is not required.
+ * 
+ *     2. Altered source versions must be plainly marked as such, and must not be
+ *     misrepresented as being the original software.
+ * 
+ *     3. This notice may not be removed or altered from any source
+ *     distribution.
+ *
+ */
+#pragma once
+
+// This header is very restrict about compiler and architecture
+#ifndef _MSC_VER
+#warning  This header is tested only with MSVC
+#endif
+#if ! (defined (_M_IX86) || defined (_X86_))
+#error  Supported only in x86
+#endif
+
+//
+#include <utility>
+#include <memory>
 #include "injector.hpp"
-#include "..\safetyhook\safetyhook.hpp"
 
 namespace injector
 {
-    using reg_pack = SafetyHookContext;
+    struct reg_pack
+    {
+        // The ordering is very important, don't change
+        // The first field is the last to be pushed and first to be poped
+
+        // PUSHFD / POPFD
+        uint32_t ef;
+
+        // PUSHAD/POPAD -- must be the lastest fields (because of esp)
+        union
+        {
+            uint32_t arr[8];
+            struct { uint32_t edi, esi, ebp, esp, ebx, edx, ecx, eax; };
+        };
+        
+        enum reg_name {
+            reg_edi, reg_esi, reg_ebp, reg_esp, reg_ebx, reg_edx, reg_ecx, reg_eax 
+        };
+        
+        enum ef_flag {
+            carry_flag = 0, parity_flag = 2, adjust_flag = 4, zero_flag = 6, sign_flag = 7,
+            direction_flag = 10, overflow_flag = 11
+        };
+
+        uint32_t& operator[](size_t i)
+        { return this->arr[i]; }
+        const uint32_t& operator[](size_t i) const
+        { return this->arr[i]; }
+
+        template<uint32_t bit>   // bit starts from 0, use ef_flag enum
+        bool flag()
+        {
+            return (this->ef & (1 << bit)) != 0;
+        }
+
+        bool jnb()
+        {
+            return flag<carry_flag>() == false;
+        }
+    };
+
+    // Lowest level stuff (actual assembly) goes on the following namespace
+    // PRIVATE! Skip this, not interesting for you.
     namespace injector_asm
     {
         // Wrapper functor, so the assembly can use some templating
@@ -22,28 +97,68 @@ namespace injector
 
         // Constructs a reg_pack and calls the wrapper functor
         template<class W>   // where W is of type wrapper
-        inline void make_reg_pack_and_call(memory_pointer_tr at)
+        inline void __declspec(naked) make_reg_pack_and_call()
         {
-            static std::vector<SafetyHookMid> pack;
-            auto m = safetyhook::create_mid(at.get<void>(), [](reg_pack& ctx)
+            #ifdef _MSC_VER    // MSVC is much more flexible when we're talking about inline assembly
+            _asm
             {
-                W::call(&ctx);
-            });
-            pack.emplace_back(std::move(m));
+                // Construct the reg_pack structure on the stack
+                pushad              // Pushes general purposes registers to reg_pack
+                add [esp+12], 4     // Add 4 to reg_pack::esp 'cuz of our return pointer, let it be as before this func is called
+                pushfd              // Pushes EFLAGS to reg_pack
+
+                // Call wrapper sending reg_pack as parameter
+                push esp
+                call W::call
+                add esp, 4
+
+                // Destructs the reg_pack from the stack
+                sub [esp+12+4], 4   // Fix reg_pack::esp before popping it (doesn't make a difference though) (+4 because eflags)
+                popfd               // Warning: Do not use any instruction that changes EFLAGS after this (-> sub affects EF!! <-)
+                popad
+
+                // Back to normal flow
+                ret
+            }
+            #else // MINGW needs -masm=intel
+            asm
+            (
+                // Construct the reg_pack structure on the stack
+                "pushad\n"              // Pushes general purposes registers to reg_pack
+                "add DWORD PTR [esp+12], 4\n"     // Add 4 to reg_pack::esp 'cuz of our return pointer, let it be as before this func is called
+                "pushfd\n"              // Pushes EFLAGS to reg_pack
+
+                // Call wrapper sending reg_pack as parameter
+                "push esp\n"
+            );
+            // https://stackoverflow.com/questions/3467180/direct-c-function-call-using-gccs-inline-assembly
+            asm("call %P0" : : "i"(W::call));  // FIXME: missing clobbers
+            asm (
+                "add esp, 4\n"
+
+                // Destructs the reg_pack from the stack
+                "sub DWORD PTR [esp+12+4], 4\n"   // Fix reg_pack::esp before popping it (doesn't make a difference though) (+4 because eflags)
+                "popfd\n"               // Warning: Do not use any instruction that changes EFLAGS after this (-> sub affects EF!! <-)
+                "popad\n"
+
+                // Back to normal flow
+                "ret\n"
+            );
+            #endif
         }
     };
 
+
     /*
      *  MakeInline
      *      Makes inline assembly (but not assembly, an actual functor of type FuncT) at address
      */
     template<class FuncT>
     void MakeInline(memory_pointer_tr at)
     {
-        MakeNOP(at, 5);
         typedef injector_asm::wrapper<FuncT> functor;
         if(false) functor::call(nullptr);   // To instantiate the template, if not done _asm will fail
-        injector_asm::make_reg_pack_and_call<functor>(at);
+        MakeCALL(at, injector_asm::make_reg_pack_and_call<functor>);
     }
 
     /*
@@ -102,8 +217,6 @@ namespace injector
     template<uintptr_t at, class FuncT>
     void MakeInline(FuncT func)
     {
-        MakeNOP(at, 5);
         return MakeInline<at, at+5, FuncT>(func);
     }
 };
-

plugin_sa/game_sa/CGame.cpp

@@ -228,6 +228,8 @@ void DoRwStuffEndOfFrame() {
     plugin::Call<0x53D840>();
 }
 
+#ifndef RW
 RsEventStatus RsEventHandler(RsEvent event, void* param) {
     return plugin::CallAndReturnDyn<RsEventStatus>(0x619B60, event, param);
 }
+#endif