diff --git a/sourcehook/generate/sourcehook.h b/sourcehook/generate/sourcehook.h index 1b43b3e..8b929ce 100644 --- a/sourcehook/generate/sourcehook.h +++ b/sourcehook/generate/sourcehook.h @@ -374,7 +374,7 @@ namespace SourceHook #define META_RESULT_PREVIOUS SH_GLOB_SHPTR->GetPrevRes() #define META_RESULT_ORIG_RET(type) *reinterpret_cast(SH_GLOB_SHPTR->GetOrigRet()) #define META_RESULT_OVERRIDE_RET(type) *reinterpret_cast(SH_GLOB_SHPTR->GetOverrideRet()) -#define META_IFACEPTR SH_GLOB_SHPTR->GetIfacePtr() +#define META_IFACEPTR(type) reinterpret_cast(SH_GLOB_SHPTR->GetIfacePtr()) /** diff --git a/sourcehook/generate/sourcehook.hxx b/sourcehook/generate/sourcehook.hxx index 326277b..1a8e89f 100755 --- a/sourcehook/generate/sourcehook.hxx +++ b/sourcehook/generate/sourcehook.hxx @@ -374,7 +374,7 @@ namespace SourceHook #define META_RESULT_PREVIOUS SH_GLOB_SHPTR->GetPrevRes() #define META_RESULT_ORIG_RET(type) *reinterpret_cast(SH_GLOB_SHPTR->GetOrigRet()) #define META_RESULT_OVERRIDE_RET(type) *reinterpret_cast(SH_GLOB_SHPTR->GetOverrideRet()) -#define META_IFACEPTR SH_GLOB_SHPTR->GetIfacePtr() +#define META_IFACEPTR(type) reinterpret_cast(SH_GLOB_SHPTR->GetIfacePtr()) /** diff --git a/sourcehook/sh_stack.h b/sourcehook/sh_stack.h index fb097dc..c265edd 100644 --- a/sourcehook/sh_stack.h +++ b/sourcehook/sh_stack.h @@ -13,8 +13,6 @@ #define SH_STACK_DEFAULT_SIZE 4 -#include - namespace SourceHook { // Vector @@ -101,20 +99,18 @@ namespace SourceHook m_AllocatedSize(SH_STACK_DEFAULT_SIZE), m_UsedSize(0) { - assert(m_Elements); } CStack(size_t size) : m_Elements(new T[size]), m_AllocatedSize(size), m_UsedSize(0) { - assert(m_Elements); } CStack(const CStack &other) : m_Elements(NULL), m_AllocatedSize(0), m_UsedSize(0) { - assert(reserve(other.m_AllocatedSize) && m_Elements); + reserve(other.m_AllocatedSize); m_UsedSize = other.m_UsedSize; for (size_t i = 0; i < m_UsedSize; ++i) m_Elements[i] = other.m_Elements[i]; @@ -133,7 +129,6 @@ namespace SourceHook if (m_Elements) delete [] m_Elements; m_Elements = new T[other.m_AllocatedSize]; - assert(m_Elements); m_AllocatedSize = other.m_AllocatedSize; } m_UsedSize = other.m_UsedSize; diff --git a/sourcehook/sourcehook.h b/sourcehook/sourcehook.h index 1b43b3e..8b929ce 100644 --- a/sourcehook/sourcehook.h +++ b/sourcehook/sourcehook.h @@ -374,7 +374,7 @@ namespace SourceHook #define META_RESULT_PREVIOUS SH_GLOB_SHPTR->GetPrevRes() #define META_RESULT_ORIG_RET(type) *reinterpret_cast(SH_GLOB_SHPTR->GetOrigRet()) #define META_RESULT_OVERRIDE_RET(type) *reinterpret_cast(SH_GLOB_SHPTR->GetOverrideRet()) -#define META_IFACEPTR SH_GLOB_SHPTR->GetIfacePtr() +#define META_IFACEPTR(type) reinterpret_cast(SH_GLOB_SHPTR->GetIfacePtr()) /** diff --git a/sourcehook/test/main.cpp b/sourcehook/test/main.cpp index 2e5385f..ec652ef 100644 --- a/sourcehook/test/main.cpp +++ b/sourcehook/test/main.cpp @@ -71,6 +71,7 @@ DO_TEST(VafmtAndOverload); DO_TEST(ThisPtrOffs); DO_TEST(PlugSys); DO_TEST(Bail); +DO_TEST(Reentr); int main(int argc, char *argv[]) { diff --git a/sourcehook/test/test.vcproj b/sourcehook/test/test.vcproj index 4bde6b9..6e7d7b9 100644 --- a/sourcehook/test/test.vcproj +++ b/sourcehook/test/test.vcproj @@ -268,6 +268,9 @@ + + (META_IFACEPTR))); + ADD_STATE(State_Func1H_Called(META_IFACEPTR(void))); } void Handler_Func2() { - ADD_STATE(State_Func2H_Called(reinterpret_cast(META_IFACEPTR))); + ADD_STATE(State_Func2H_Called(META_IFACEPTR(void))); } void Handler_Func3() { - ADD_STATE(State_Func3H_Called(reinterpret_cast(META_IFACEPTR))); + ADD_STATE(State_Func3H_Called(META_IFACEPTR(void))); } } diff --git a/sourcehook/test/testbail.cpp b/sourcehook/test/testbail.cpp index c82093c..d42f38d 100644 --- a/sourcehook/test/testbail.cpp +++ b/sourcehook/test/testbail.cpp @@ -17,7 +17,7 @@ namespace SH_DECL_HOOK0_void(zomg_lolz, zomg, SH_NOATTRIB, 0); void Handler() { - SH_REMOVE_HOOK_STATICFUNC(zomg_lolz, zomg, reinterpret_cast(META_IFACEPTR), + SH_REMOVE_HOOK_STATICFUNC(zomg_lolz, zomg, META_IFACEPTR(zomg_lolz), Handler, false); } void Handler2() diff --git a/sourcehook/test/testreentr.cpp b/sourcehook/test/testreentr.cpp new file mode 100644 index 0000000..94b6bb3 --- /dev/null +++ b/sourcehook/test/testreentr.cpp @@ -0,0 +1,351 @@ +// Reentrancy test +// = calling hooks from hook handlers, etc + +#include +#include "sourcehook_impl.h" +#include "testevents.h" + +namespace +{ + StateList g_States; + SourceHook::ISourceHook *g_SHPtr; + SourceHook::Plugin g_PLID; + + struct C1; + struct C2; + struct C3; + struct C4; + struct C5; + struct C6; + struct C7; + struct C8; + + C1 *g_pC1; + C2 *g_pC2; + C3 *g_pC3; + C4 *g_pC4; + C5 *g_pC5; + C6 *g_pC6; + C7 *g_pC7; + C8 *g_pC8; + + // param1: This pointer + MAKE_STATE_1(State_C1_F, C1*); + MAKE_STATE_1(State_C2_F, C2*); + MAKE_STATE_1(State_C3_F, C3*); + MAKE_STATE_1(State_C4_F, C4*); + MAKE_STATE_1(State_C5_F, C5*); + MAKE_STATE_1(State_C6_F, C6*); + MAKE_STATE_1(State_C7_F, C7*); + MAKE_STATE_1(State_C8_F, C8*); + + MAKE_STATE_1(State_C1_G, C1*); + MAKE_STATE_1(State_C2_G, C2*); + MAKE_STATE_1(State_C3_G, C3*); + MAKE_STATE_1(State_C4_G, C4*); + MAKE_STATE_1(State_C5_G, C5*); + MAKE_STATE_1(State_C6_G, C6*); + MAKE_STATE_1(State_C7_G, C7*); + MAKE_STATE_1(State_C8_G, C8*); + + MAKE_STATE_1(State_H_C1_F, C1*); + MAKE_STATE_1(State_H_C2_F, C2*); + MAKE_STATE_1(State_H_C3_F, C3*); + MAKE_STATE_1(State_H_C4_F, C4*); + MAKE_STATE_1(State_H_C5_F, C5*); + MAKE_STATE_1(State_H_C6_F, C6*); + MAKE_STATE_1(State_H_C7_F, C7*); + MAKE_STATE_1(State_H_C8_F, C8*); + + MAKE_STATE_1(State_H_C1_G, C1*); + MAKE_STATE_1(State_H_C2_G, C2*); + MAKE_STATE_1(State_H_C3_G, C3*); + MAKE_STATE_1(State_H_C4_G, C4*); + MAKE_STATE_1(State_H_C5_G, C5*); + MAKE_STATE_1(State_H_C6_G, C6*); + MAKE_STATE_1(State_H_C7_G, C7*); + MAKE_STATE_1(State_H_C8_G, C8*); + + struct C1 + { + virtual void F() + { + ADD_STATE(State_C1_F(this)); + } + virtual int G() + { + ADD_STATE(State_C1_G(this)); + return 1; + } + }; + struct C2 + { + virtual void F() + { + ADD_STATE(State_C2_F(this)); + } + virtual int G() + { + ADD_STATE(State_C2_G(this)); + return 2; + } + }; + struct C3 + { + virtual void F() + { + ADD_STATE(State_C3_F(this)); + } + virtual int G() + { + ADD_STATE(State_C3_G(this)); + return 3; + } + }; + struct C4 + { + virtual void F() + { + ADD_STATE(State_C4_F(this)); + } + virtual int G() + { + ADD_STATE(State_C4_G(this)); + return 4; + } + }; + struct C5 + { + virtual void F() + { + ADD_STATE(State_C5_F(this)); + } + virtual int G() + { + ADD_STATE(State_C5_G(this)); + return 5; + } + }; + struct C6 + { + virtual void F() + { + ADD_STATE(State_C6_F(this)); + } + virtual int G() + { + ADD_STATE(State_C6_G(this)); + return 6; + } + }; + struct C7 + { + virtual void F() + { + ADD_STATE(State_C7_F(this)); + } + virtual int G() + { + ADD_STATE(State_C7_G(this)); + return 7; + } + }; + struct C8 + { + virtual void F() + { + ADD_STATE(State_C8_F(this)); + } + virtual int G() + { + ADD_STATE(State_C8_G(this)); + return 8; + } + }; + + void Handler_C1_F() + { + ADD_STATE(State_H_C1_F(META_IFACEPTR(C1))); + g_pC1->G(); + } + int Handler_C1_G() + { + ADD_STATE(State_H_C1_G(META_IFACEPTR(C1))); + g_pC2->F(); + return 1; + } + void Handler_C2_F() + { + ADD_STATE(State_H_C2_F(META_IFACEPTR(C2))); + g_pC2->G(); + } + int Handler_C2_G() + { + ADD_STATE(State_H_C2_G(META_IFACEPTR(C2))); + g_pC3->F(); + return 2; + } + void Handler_C3_F() + { + ADD_STATE(State_H_C3_F(META_IFACEPTR(C3))); + g_pC3->G(); + } + int Handler_C3_G() + { + ADD_STATE(State_H_C3_G(META_IFACEPTR(C3))); + g_pC4->F(); + return 3; + } + void Handler_C4_F() + { + ADD_STATE(State_H_C4_F(META_IFACEPTR(C4))); + g_pC4->G(); + } + int Handler_C4_G() + { + ADD_STATE(State_H_C4_G(META_IFACEPTR(C4))); + g_pC5->F(); + return 4; + } + void Handler_C5_F() + { + ADD_STATE(State_H_C5_F(META_IFACEPTR(C5))); + g_pC5->G(); + } + int Handler_C5_G() + { + ADD_STATE(State_H_C5_G(META_IFACEPTR(C5))); + g_pC6->F(); + return 5; + } + void Handler_C6_F() + { + ADD_STATE(State_H_C6_F(META_IFACEPTR(C6))); + g_pC6->G(); + } + int Handler_C6_G() + { + ADD_STATE(State_H_C6_G(META_IFACEPTR(C6))); + g_pC7->F(); + return 6; + } + void Handler_C7_F() + { + ADD_STATE(State_H_C7_F(META_IFACEPTR(C7))); + g_pC7->G(); + } + int Handler_C7_G() + { + ADD_STATE(State_H_C7_G(META_IFACEPTR(C7))); + g_pC8->F(); + return 7; + } + void Handler_C8_F() + { + ADD_STATE(State_H_C8_F(META_IFACEPTR(C8))); + g_pC8->G(); + } + int Handler_C8_G() + { + ADD_STATE(State_H_C8_G(META_IFACEPTR(C8))); + return 8; + } + + C1 g_C1; + C2 g_C2; + C3 g_C3; + C4 g_C4; + C5 g_C5; + C6 g_C6; + C7 g_C7; + C8 g_C8; + + SH_DECL_HOOK0_void(C1, F, SH_NOATTRIB, 0); + SH_DECL_HOOK0(C1, G, SH_NOATTRIB, 0, int); + SH_DECL_HOOK0_void(C2, F, SH_NOATTRIB, 0); + SH_DECL_HOOK0(C2, G, SH_NOATTRIB, 0, int); + SH_DECL_HOOK0_void(C3, F, SH_NOATTRIB, 0); + SH_DECL_HOOK0(C3, G, SH_NOATTRIB, 0, int); + SH_DECL_HOOK0_void(C4, F, SH_NOATTRIB, 0); + SH_DECL_HOOK0(C4, G, SH_NOATTRIB, 0, int); + SH_DECL_HOOK0_void(C5, F, SH_NOATTRIB, 0); + SH_DECL_HOOK0(C5, G, SH_NOATTRIB, 0, int); + SH_DECL_HOOK0_void(C6, F, SH_NOATTRIB, 0); + SH_DECL_HOOK0(C6, G, SH_NOATTRIB, 0, int); + SH_DECL_HOOK0_void(C7, F, SH_NOATTRIB, 0); + SH_DECL_HOOK0(C7, G, SH_NOATTRIB, 0, int); + SH_DECL_HOOK0_void(C8, F, SH_NOATTRIB, 0); + SH_DECL_HOOK0(C8, G, SH_NOATTRIB, 0, int); +} + +bool TestReentr(std::string &error) +{ + SourceHook::CSourceHookImpl g_SHImpl; + g_SHPtr = &g_SHImpl; + g_PLID = 1337; + + g_pC1 = &g_C1; + g_pC2 = &g_C2; + g_pC3 = &g_C3; + g_pC4 = &g_C4; + g_pC5 = &g_C5; + g_pC6 = &g_C6; + g_pC7 = &g_C7; + g_pC8 = &g_C8; + + SH_ADD_HOOK_STATICFUNC(C1, F, g_pC1, Handler_C1_F, false); + SH_ADD_HOOK_STATICFUNC(C1, G, g_pC1, Handler_C1_G, false); + SH_ADD_HOOK_STATICFUNC(C2, F, g_pC2, Handler_C2_F, false); + SH_ADD_HOOK_STATICFUNC(C2, G, g_pC2, Handler_C2_G, false); + SH_ADD_HOOK_STATICFUNC(C3, F, g_pC3, Handler_C3_F, false); + SH_ADD_HOOK_STATICFUNC(C3, G, g_pC3, Handler_C3_G, false); + SH_ADD_HOOK_STATICFUNC(C4, F, g_pC4, Handler_C4_F, false); + SH_ADD_HOOK_STATICFUNC(C4, G, g_pC4, Handler_C4_G, false); + SH_ADD_HOOK_STATICFUNC(C5, F, g_pC5, Handler_C5_F, false); + SH_ADD_HOOK_STATICFUNC(C5, G, g_pC5, Handler_C5_G, false); + SH_ADD_HOOK_STATICFUNC(C6, F, g_pC6, Handler_C6_F, false); + SH_ADD_HOOK_STATICFUNC(C6, G, g_pC6, Handler_C6_G, false); + SH_ADD_HOOK_STATICFUNC(C7, F, g_pC7, Handler_C7_F, false); + SH_ADD_HOOK_STATICFUNC(C7, G, g_pC7, Handler_C7_G, false); + SH_ADD_HOOK_STATICFUNC(C8, F, g_pC8, Handler_C8_F, false); + SH_ADD_HOOK_STATICFUNC(C8, G, g_pC8, Handler_C8_G, false); + + g_pC1->F(); + + CHECK_STATES((&g_States, + new State_H_C1_F(g_pC1), + new State_H_C1_G(g_pC1), + new State_H_C2_F(g_pC2), + new State_H_C2_G(g_pC2), + new State_H_C3_F(g_pC3), + new State_H_C3_G(g_pC3), + new State_H_C4_F(g_pC4), + new State_H_C4_G(g_pC4), + new State_H_C5_F(g_pC5), + new State_H_C5_G(g_pC5), + new State_H_C6_F(g_pC6), + new State_H_C6_G(g_pC6), + new State_H_C7_F(g_pC7), + new State_H_C7_G(g_pC7), + new State_H_C8_F(g_pC8), + new State_H_C8_G(g_pC8), + new State_C8_G(g_pC8), + new State_C8_F(g_pC8), + new State_C7_G(g_pC7), + new State_C7_F(g_pC7), + new State_C6_G(g_pC6), + new State_C6_F(g_pC6), + new State_C5_G(g_pC5), + new State_C5_F(g_pC5), + new State_C4_G(g_pC4), + new State_C4_F(g_pC4), + new State_C3_G(g_pC3), + new State_C3_F(g_pC3), + new State_C2_G(g_pC2), + new State_C2_F(g_pC2), + new State_C1_G(g_pC1), + new State_C1_F(g_pC1), + NULL), "1"); + + return true; +} \ No newline at end of file