From 3de86ccca848bb0e9b9c284deea8ac770072f387 Mon Sep 17 00:00:00 2001 From: Pavol Marko Date: Sun, 18 Nov 2007 11:58:07 +0000 Subject: [PATCH] Hookmangen support for vafmt on gcc Added vafmt_void test to testhookmangen Recalls should work now with vafmt --HG-- branch : hookman_autogen extra : convert_revision : svn%3Ac2935e3e-5518-0410-8daf-afa5dab7d4e3/branches/hookman_autogen%40564 --- sourcehook/generate/sourcehook.h | 204 ++++ sourcehook/generate/sourcehook.hxx | 12 + sourcehook/sourcehook.h | 204 ++++ sourcehook/sourcehook_hookmangen.cpp | 102 +- sourcehook/sourcehook_hookmangen.h | 4 +- sourcehook/sourcehook_hookmangen_x86.h | 22 + sourcehook/sourcehook_pibuilder.h | 2 +- sourcehook/test/testhookmangen.cpp | 60 + sourcehook/test/testhookmangen.h | 1414 +++++++++++++++++++++++- sourcehook/test/testhookmangen.hxx | 210 +++- 10 files changed, 2198 insertions(+), 36 deletions(-) diff --git a/sourcehook/generate/sourcehook.h b/sourcehook/generate/sourcehook.h index ee287dc..df5a477 100644 --- a/sourcehook/generate/sourcehook.h +++ b/sourcehook/generate/sourcehook.h @@ -5635,204 +5635,408 @@ namespace SourceHook return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)()) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + } #endif diff --git a/sourcehook/generate/sourcehook.hxx b/sourcehook/generate/sourcehook.hxx index bde13ab..04069b7 100755 --- a/sourcehook/generate/sourcehook.hxx +++ b/sourcehook/generate/sourcehook.hxx @@ -1353,11 +1353,23 @@ namespace SourceHook return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(@[$2,1,$1:Param$2, @]...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(@[$2,1,$1|, :Param$2@])) { return reinterpret_cast(shptr->GetIfacePtr()); } + + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(@[$2,1,$1:Param$2, @]...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } @] } diff --git a/sourcehook/sourcehook.h b/sourcehook/sourcehook.h index ee287dc..df5a477 100644 --- a/sourcehook/sourcehook.h +++ b/sourcehook/sourcehook.h @@ -5635,204 +5635,408 @@ namespace SourceHook return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)()) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + template OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16)) { return OverrideFunctor(); } + template + OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...)) + { + return OverrideFunctor(); + } + template Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16)) { return reinterpret_cast(shptr->GetIfacePtr()); } + template + Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...)) + { + return reinterpret_cast(shptr->GetIfacePtr()); + } + } #endif diff --git a/sourcehook/sourcehook_hookmangen.cpp b/sourcehook/sourcehook_hookmangen.cpp index 9bcb671..bc985c7 100644 --- a/sourcehook/sourcehook_hookmangen.cpp +++ b/sourcehook/sourcehook_hookmangen.cpp @@ -848,7 +848,7 @@ namespace SourceHook } void GenContext::GenerateCallHooks(int v_status, int v_prev_res, int v_cur_res, int v_iter, - int v_pContext, int base_param_offset, int v_plugin_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base) + int v_pContext, int base_param_offset, int v_plugin_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base, jit_int32_t v_va_buf) { jitoffs_t counter, tmppos; jitoffs_t counter2, tmppos2; @@ -894,8 +894,17 @@ namespace SourceHook // eax = [eax+2*SIZE_PTR] // call eax // gcc: clean up + + jit_int32_t gcc_clean_bytes = 0; + // vafmt: push va_buf + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt) + { + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf); + IA32_Push_Reg(&m_HookFunc, REG_ECX); + gcc_clean_bytes += SIZE_PTR; + } - jit_int32_t gcc_clean_bytes = PushParams(base_param_offset, v_plugin_ret, v_place_for_memret, v_place_fbrr_base); + gcc_clean_bytes += PushParams(base_param_offset, v_plugin_ret, v_place_for_memret, v_place_fbrr_base); IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG); GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); @@ -953,7 +962,7 @@ namespace SourceHook } void GenContext::GenerateCallOrig(int v_status, int v_pContext, int param_base_offs, int v_this, - int v_vfnptr_origentry, int v_orig_ret, int v_override_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base) + int v_vfnptr_origentry, int v_orig_ret, int v_override_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base, jit_int32_t v_va_buf) { jitoffs_t counter, tmppos; jitoffs_t counter2, tmppos2; @@ -1005,8 +1014,19 @@ namespace SourceHook tmppos2 = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0); m_HookFunc.start_count(counter2); + jit_int32_t gcc_clean_bytes = 0; + + // vafmt: push va_buf, then "%s" + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt) + { + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf); + IA32_Push_Reg(&m_HookFunc, REG_ECX); + IA32_Push_Imm32(&m_HookFunc, DownCastPtr("%s")); + gcc_clean_bytes += 2*SIZE_PTR; + } + // push params - jit_int32_t gcc_clean_bytes = PushParams(param_base_offs, v_orig_ret, v_place_for_memret, v_place_fbrr_base); + gcc_clean_bytes += PushParams(param_base_offs, v_orig_ret, v_place_for_memret, v_place_fbrr_base); // thisptr IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this); @@ -1248,21 +1268,22 @@ namespace SourceHook // IHookContext *pContext ebp - 24 -4 // == 3 ptrs + 3 enums = 24 bytes // - // varargs: - // va_list argptr ebp - 28 -4 - // // non-void: add: - // my_rettype *ret_ptr ebp - 28 (va: -4) -4 - // my_rettype orig_ret ebp - 28 (va: -4) - sizeof(my_rettype) -4 - // my_rettype override_ret ebp - 28 (va: -4) - sizeof(my_rettype)*2 -4 - // my_rettype plugin_ret ebp - 28 (va: -4) - sizeof(my_rettype)*3 -4 + // my_rettype *ret_ptr ebp - 28 -4 + // my_rettype orig_ret ebp - 28 - sizeof(my_rettype) -4 + // my_rettype override_ret ebp - 28 - sizeof(my_rettype)*2 -4 + // my_rettype plugin_ret ebp - 28 - sizeof(my_rettype)*3 -4 // == + 3 * sizeof(my_rettype) bytes // if required: - // my_rettype place_for_memret ebp - 28 (va: -4) - sizeof(my_rettype)*4 -4 + // my_rettype place_for_memret ebp - 28 - sizeof(my_rettype)*4 -4 // gcc only: if required: - // place forced byref params ebp - 28 (va: -4) - sizeof(my_rettype)*{4 or 5} + // place forced byref params ebp - 28 - sizeof(my_rettype)*{4 or 5} + // + // varargs: + // va_list argptr + // char va_buf[something]; const jit_int8_t v_vfnptr_origentry = AddVarToFrame(SIZE_PTR); @@ -1271,10 +1292,6 @@ namespace SourceHook const jit_int8_t v_cur_res = AddVarToFrame(sizeof(META_RES)); const jit_int8_t v_iter = AddVarToFrame(SIZE_PTR); const jit_int8_t v_pContext = AddVarToFrame(SIZE_PTR); - // Only exists for varargs functions - const jit_int8_t v_va_argptr = (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs) ? - AddVarToFrame(sizeof(va_list)) : - 0; #if SH_COMP == SH_COMP_GCC jit_int32_t param_base_offs = 16; @@ -1319,25 +1336,60 @@ namespace SourceHook } jit_int32_t v_place_fbrr_base = 0; - if (GetForcedByRefParamsSize()) + if (SH_COMP == SH_COMP_GCC && GetForcedByRefParamsSize()) { v_place_fbrr_base = AddVarToFrame(GetForcedByRefParamsSize()); } + // Only exists for varargs functions + jit_int32_t v_va_argptr = 0; + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs) + { + v_va_argptr = AddVarToFrame(SIZE_PTR); + } + + jit_int32_t v_va_buf = 0; + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt) + { + v_va_buf = AddVarToFrame(SourceHook::STRBUF_LEN); + } + IA32_Sub_Rm_Imm32(&m_HookFunc, REG_ESP, ComputeVarsSize(), MOD_REG); // init status localvar IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_status); - // VarArgs: init argptr + // VarArgs: init argptr & format if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs) { // argptr = first vararg param - // lea eax, [esp + param_base_offs + paramssize] + // lea eax, [ebp + param_base_offs + paramssize] // mov argptr, eax - IA32_Lea_Reg_DispRegMultImm32(&m_HookFunc, REG_EAX, REG_NOIDX, REG_ESP, NOSCALE, param_base_offs + GetParamsStackSize()); - IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, v_va_argptr, REG_EAX); + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, param_base_offs + GetParamsStackSize() + SIZE_PTR); // +SIZE_PTR: last const char * is not in protoinfo + IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_va_argptr); + } + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt) + { + // vsnprintf + + // push valist, fmt param, maxsize, buffer + IA32_Push_Reg(&m_HookFunc, REG_EAX); + IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, param_base_offs + GetParamsStackSize()); // last given param (+4-4, see above) + IA32_Push_Imm32(&m_HookFunc, SourceHook::STRBUF_LEN - 1); + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf); + IA32_Push_Reg(&m_HookFunc, REG_ECX); + + // call + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(&vsnprintf)); + IA32_Call_Reg(&m_HookFunc, REG_EAX); + + // Clean up (cdecl) + IA32_Add_Rm_Imm32(&m_HookFunc, REG_ESP, 0x10, MOD_REG); + + // Set trailing zero + IA32_Xor_Reg_Rm(&m_HookFunc, REG_EDX, REG_EDX, MOD_REG); + IA32_Mov_Rm8_Reg8_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_va_buf + SourceHook::STRBUF_LEN - 1); } // Call constructors for ret vars if required @@ -1374,15 +1426,15 @@ namespace SourceHook // ********************** call pre hooks ********************** GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs, - v_plugin_ret, v_place_for_memret, v_place_fbrr_base); + v_plugin_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf); // ********************** call orig func ********************** GenerateCallOrig(v_status, v_pContext, param_base_offs, v_this, v_vfnptr_origentry, v_orig_ret, - v_override_ret, v_place_for_memret, v_place_fbrr_base); + v_override_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf); // ********************** call post hooks ********************** GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs, - v_plugin_ret, v_place_for_memret, v_place_fbrr_base); + v_plugin_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf); // ********************** end context and return ********************** diff --git a/sourcehook/sourcehook_hookmangen.h b/sourcehook/sourcehook_hookmangen.h index 8014694..71bbf54 100644 --- a/sourcehook/sourcehook_hookmangen.h +++ b/sourcehook/sourcehook_hookmangen.h @@ -221,11 +221,11 @@ namespace SourceHook // Call hooks void GenerateCallHooks(int v_status, int v_prev_res, int v_cur_res, int v_iter, - int v_pContext, int base_param_offset, int v_plugin_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base); + int v_pContext, int base_param_offset, int v_plugin_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base, jit_int32_t v_va_buf); // Call orig void GenerateCallOrig(int v_status, int v_pContext, int param_base_offs, int v_this, - int v_vfnptr_origentry, int v_orig_ret, int v_override_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base); + int v_vfnptr_origentry, int v_orig_ret, int v_override_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base, jit_int32_t v_va_buf); // Hook loop void CallSetupHookLoop(int v_orig_ret, int v_override_ret, diff --git a/sourcehook/sourcehook_hookmangen_x86.h b/sourcehook/sourcehook_hookmangen_x86.h index 81b40cd..4590ff0 100644 --- a/sourcehook/sourcehook_hookmangen_x86.h +++ b/sourcehook/sourcehook_hookmangen_x86.h @@ -943,6 +943,28 @@ namespace SourceHook jit->write_ubyte(ia32_modrm(mode, src, dest)); } + inline void IA32_Mov_Rm8_Reg8_Disp8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int8_t disp) + { + jit->write_ubyte(IA32_MOV_RM8_REG8); + jit->write_ubyte(ia32_modrm(MOD_DISP8, src, dest)); + jit->write_byte(disp); + } + + inline void IA32_Mov_Rm8_Reg8_Disp32(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp) + { + jit->write_ubyte(IA32_MOV_RM8_REG8); + jit->write_ubyte(ia32_modrm(MOD_DISP32, src, dest)); + jit->write_int32(disp); + } + + inline void IA32_Mov_Rm8_Reg8_DispAuto(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp) + { + if (disp >= SCHAR_MIN && disp <= SCHAR_MAX) + IA32_Mov_Rm8_Reg8_Disp8(jit, dest, src, static_cast(disp)); + else + IA32_Mov_Rm8_Reg8_Disp32(jit, dest, src, disp); + } + inline void IA32_Mov_RmESP_Reg(JitWriter *jit, jit_uint8_t src) { jit->write_ubyte(IA32_MOV_RM_REG); diff --git a/sourcehook/sourcehook_pibuilder.h b/sourcehook/sourcehook_pibuilder.h index 7c91738..6c2f592 100644 --- a/sourcehook/sourcehook_pibuilder.h +++ b/sourcehook/sourcehook_pibuilder.h @@ -23,7 +23,7 @@ namespace SourceHook CVector m_Params; CVector m_Params2; public: - CProtoInfoBuilder(ProtoInfo::CallConvention cc) + CProtoInfoBuilder(int cc) { memset(reinterpret_cast(&m_PI), 0, sizeof(ProtoInfo)); m_PI.convention = cc; diff --git a/sourcehook/test/testhookmangen.cpp b/sourcehook/test/testhookmangen.cpp index ccb3cdd..a391482 100644 --- a/sourcehook/test/testhookmangen.cpp +++ b/sourcehook/test/testhookmangen.cpp @@ -219,6 +219,15 @@ namespace } }; + template<> + struct Increment + { + static void Incr(std::string &what) + { + what += "!"; + } + }; + #include "testhookmangen.h" template @@ -412,6 +421,38 @@ namespace SourceHook::PassInfo::PassFlag_ByRef | SourceHook::PassInfo::PassFlag_OCtor | SourceHook::PassInfo::PassFlag_ODtor | SourceHook::PassInfo::PassFlag_CCtor | SourceHook::PassInfo::PassFlag_AssignOp); + + // vafmt tests + THGM_MAKE_TEST0_vafmt_void(200); + THGM_SETUP_PI0(200); + + THGM_MAKE_TEST1_vafmt_void(201, char); + THGM_SETUP_PI1(201, char, SourceHook::PassInfo::PassType_Basic, SourceHook::PassInfo::PassFlag_ByVal); + + THGM_MAKE_TEST1_vafmt_void(203, int); + THGM_SETUP_PI1(203, int, SourceHook::PassInfo::PassType_Basic, SourceHook::PassInfo::PassFlag_ByVal); + + THGM_MAKE_TEST5_vafmt_void(206, char, short, int, float, double); + THGM_SETUP_PI5(206, + char, SourceHook::PassInfo::PassType_Basic, SourceHook::PassInfo::PassFlag_ByVal, + short, SourceHook::PassInfo::PassType_Basic, SourceHook::PassInfo::PassFlag_ByVal, + int, SourceHook::PassInfo::PassType_Basic, SourceHook::PassInfo::PassFlag_ByVal, + float, SourceHook::PassInfo::PassType_Float, SourceHook::PassInfo::PassFlag_ByVal, + double, SourceHook::PassInfo::PassType_Float, SourceHook::PassInfo::PassFlag_ByVal + ); + + THGM_MAKE_TEST2_vafmt_void(207, char&, double&); + THGM_SETUP_PI2(207, + char&, SourceHook::PassInfo::PassType_Basic, SourceHook::PassInfo::PassFlag_ByRef, + double&, SourceHook::PassInfo::PassType_Float, SourceHook::PassInfo::PassFlag_ByRef + ); + + THGM_MAKE_TEST1_vafmt_void(208, POD<7>); + THGM_SETUP_PI1(208, POD<7>, SourceHook::PassInfo::PassType_Object, SourceHook::PassInfo::PassFlag_ByVal); + + THGM_MAKE_TEST1_vafmt_void(210, POD<600> &); + THGM_SETUP_PI1(210, POD<600> &, SourceHook::PassInfo::PassType_Object, SourceHook::PassInfo::PassFlag_ByRef) + MAKE_STATE(State_Hello_Func4_Called); MAKE_STATE(State_Hello_Func79_Called); @@ -915,6 +956,25 @@ bool TestHookManGen(std::string &error) // RefRet THGM_DO_TEST(111, ()); + // Vafmt + + THGM_DO_TEST_void(200, ("Hello %s%d%s", "BA", 1, "L!")); + + THGM_DO_TEST_void(201, (100, "Hello %s%d%s", "BA", 1, "L!")); + + THGM_DO_TEST_void(203, (0x1F000000, "Hello %s%d%s", "BA", 1, "L!")); + + THGM_DO_TEST_void(206, (100, 0x1f00, 0x1f000000, 0.5f, 5.5, "Hello %s%d%s", "BA", 1, "L!")); + + a = 5; + b = 233.33; + THGM_DO_TEST_void(207, (a, b, "Hello %s%d%s", "BA", 1, "L!")); + + pod7 = MakeRet< POD<7> >::Do(78); + THGM_DO_TEST_void(208, (pod7, "Hello %s%d%s", "BA", 1, "L!")); + + THGM_DO_TEST_void(210, (pod600, "Hello %s%d%s", "BA", 1, "L!")); + // Test for lange vtable indices Hello *pHello = new Hello; SourceHook::CProtoInfoBuilder helloPi(SourceHook::ProtoInfo::CallConv_ThisCall); diff --git a/sourcehook/test/testhookmangen.h b/sourcehook/test/testhookmangen.h index 1450eba..32c12d5 100644 --- a/sourcehook/test/testhookmangen.h +++ b/sourcehook/test/testhookmangen.h @@ -132,6 +132,20 @@ struct MakeRet< POD > }; // Stores parameter status +template +bool EqualToMyFmtString(T sth) +{ + return false; +} + +bool EqualToMyFmtString(std::string &sth) +{ + if (sth == "Hello %s%d%s") + sth = "Hello BA1L!"; + return true; +} + + template @@ -145,8 +159,9 @@ struct ParamState0 ; } - ParamState0() + ParamState0(...) { + } ParamState0 & operator() (int incrsteps) @@ -178,8 +193,11 @@ struct ParamState1 && m_1 == other.m_1 ; } - ParamState1(p1 a1) : m_1(a1) + ParamState1(p1 a1, ...) : m_1(a1) { + + EqualToMyFmtString(m_1); + } ParamState1 & operator() (int incrsteps) @@ -214,8 +232,13 @@ struct ParamState2 && m_2 == other.m_2 && m_2 == other.m_2 ; } - ParamState2(p1 a1, p2 a2) : m_1(a1), m_2(a2) + ParamState2(p1 a1, p2 a2, ...) : m_1(a1), m_2(a2) { + + EqualToMyFmtString(m_1); + + EqualToMyFmtString(m_2); + } ParamState2 & operator() (int incrsteps) @@ -253,8 +276,15 @@ struct ParamState3 && m_3 == other.m_3 && m_3 == other.m_3 && m_3 == other.m_3 ; } - ParamState3(p1 a1, p2 a2, p3 a3) : m_1(a1), m_2(a2), m_3(a3) + ParamState3(p1 a1, p2 a2, p3 a3, ...) : m_1(a1), m_2(a2), m_3(a3) { + + EqualToMyFmtString(m_1); + + EqualToMyFmtString(m_2); + + EqualToMyFmtString(m_3); + } ParamState3 & operator() (int incrsteps) @@ -295,8 +325,17 @@ struct ParamState4 && m_4 == other.m_4 && m_4 == other.m_4 && m_4 == other.m_4 && m_4 == other.m_4 ; } - ParamState4(p1 a1, p2 a2, p3 a3, p4 a4) : m_1(a1), m_2(a2), m_3(a3), m_4(a4) + ParamState4(p1 a1, p2 a2, p3 a3, p4 a4, ...) : m_1(a1), m_2(a2), m_3(a3), m_4(a4) { + + EqualToMyFmtString(m_1); + + EqualToMyFmtString(m_2); + + EqualToMyFmtString(m_3); + + EqualToMyFmtString(m_4); + } ParamState4 & operator() (int incrsteps) @@ -340,8 +379,19 @@ struct ParamState5 && m_5 == other.m_5 && m_5 == other.m_5 && m_5 == other.m_5 && m_5 == other.m_5 && m_5 == other.m_5 ; } - ParamState5(p1 a1, p2 a2, p3 a3, p4 a4, p5 a5) : m_1(a1), m_2(a2), m_3(a3), m_4(a4), m_5(a5) + ParamState5(p1 a1, p2 a2, p3 a3, p4 a4, p5 a5, ...) : m_1(a1), m_2(a2), m_3(a3), m_4(a4), m_5(a5) { + + EqualToMyFmtString(m_1); + + EqualToMyFmtString(m_2); + + EqualToMyFmtString(m_3); + + EqualToMyFmtString(m_4); + + EqualToMyFmtString(m_5); + } ParamState5 & operator() (int incrsteps) @@ -388,8 +438,21 @@ struct ParamState6 && m_6 == other.m_6 && m_6 == other.m_6 && m_6 == other.m_6 && m_6 == other.m_6 && m_6 == other.m_6 && m_6 == other.m_6 ; } - ParamState6(p1 a1, p2 a2, p3 a3, p4 a4, p5 a5, p6 a6) : m_1(a1), m_2(a2), m_3(a3), m_4(a4), m_5(a5), m_6(a6) + ParamState6(p1 a1, p2 a2, p3 a3, p4 a4, p5 a5, p6 a6, ...) : m_1(a1), m_2(a2), m_3(a3), m_4(a4), m_5(a5), m_6(a6) { + + EqualToMyFmtString(m_1); + + EqualToMyFmtString(m_2); + + EqualToMyFmtString(m_3); + + EqualToMyFmtString(m_4); + + EqualToMyFmtString(m_5); + + EqualToMyFmtString(m_6); + } ParamState6 & operator() (int incrsteps) @@ -622,6 +685,197 @@ std::ostream& operator <<(std::ostream &os,const ParamState6<0, p1, p2, p3, p4, bool TestClass##id::ms_DoRecall = false; \ SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall); +#define THGM_MAKE_TEST0_vafmt_void(id) \ + struct TestClass##id; \ + typedef ParamState1<0, std::string > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual void Func(const char *fmt, ...) \ + { \ + g_Inside_LeafFunc = true; \ + \ + char buf[9999]; \ + va_list ap; \ + va_start(ap, fmt); \ + vsnprintf(buf, 9998, fmt, ap); \ + buf[9998] = 0; \ + va_end(ap); \ + \ + ADD_STATE(State_Func##id(this, ParamState_m##id(std::string(buf)))); \ + g_Inside_LeafFunc = false; \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual void Call(const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, ("%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual void Call(const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, ("%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual void Call(const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, ("%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual void Call(const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, ("%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall | SourceHook::ProtoInfo::CallConv_HasVafmt); + + +#define THGM_MAKE_TEST0_vafmt(id, ret_type) \ + struct TestClass##id; \ + typedef ret_type RetType##id; \ + typedef ParamState0<0 > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual ret_type Func() \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Func##id(this, ParamState_m##id())); \ + g_Inside_LeafFunc = false; \ + \ + return MakeRet< ret_type >::Do(0); \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual ret_type Call() \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id())); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(1), &TestClass##id::Func, ()); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(1)); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual ret_type Call() \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id())); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2), &TestClass##id::Func, ()); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2)); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual ret_type Call() \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id())); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(3), &TestClass##id::Func, ()); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(3)); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual ret_type Call() \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id())); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4), &TestClass##id::Func, ()); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4)); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall) + + #define THGM_SETUP_PI0(id) \ void setuppi_##id() \ { \ @@ -812,6 +1066,197 @@ std::ostream& operator <<(std::ostream &os,const ParamState6<0, p1, p2, p3, p4, bool TestClass##id::ms_DoRecall = false; \ SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall); +#define THGM_MAKE_TEST1_vafmt_void(id, param1) \ + struct TestClass##id; \ + typedef ParamState2<0, param1, std::string > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual void Func(param1 p1, const char *fmt, ...) \ + { \ + g_Inside_LeafFunc = true; \ + \ + char buf[9999]; \ + va_list ap; \ + va_start(ap, fmt); \ + vsnprintf(buf, 9998, fmt, ap); \ + buf[9998] = 0; \ + va_end(ap); \ + \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1, std::string(buf)))); \ + g_Inside_LeafFunc = false; \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual void Call(param1 p1, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual void Call(param1 p1, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual void Call(param1 p1, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual void Call(param1 p1, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall | SourceHook::ProtoInfo::CallConv_HasVafmt); + + +#define THGM_MAKE_TEST1_vafmt(id, ret_type, param1) \ + struct TestClass##id; \ + typedef ret_type RetType##id; \ + typedef ParamState1<0, param1 > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual ret_type Func(param1 p1) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1))); \ + g_Inside_LeafFunc = false; \ + \ + return MakeRet< ret_type >::Do(0); \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(1), &TestClass##id::Func, (p1)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(1)); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2), &TestClass##id::Func, (p1)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2)); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(3), &TestClass##id::Func, (p1)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(3)); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4), &TestClass##id::Func, (p1)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4)); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall) + + #define THGM_SETUP_PI1(id, p1_type, p1_passtype, p1_flags) \ void setuppi_##id() \ { \ @@ -1009,6 +1454,197 @@ std::ostream& operator <<(std::ostream &os,const ParamState6<0, p1, p2, p3, p4, bool TestClass##id::ms_DoRecall = false; \ SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall); +#define THGM_MAKE_TEST2_vafmt_void(id, param1, param2) \ + struct TestClass##id; \ + typedef ParamState3<0, param1, param2, std::string > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual void Func(param1 p1, param2 p2, const char *fmt, ...) \ + { \ + g_Inside_LeafFunc = true; \ + \ + char buf[9999]; \ + va_list ap; \ + va_start(ap, fmt); \ + vsnprintf(buf, 9998, fmt, ap); \ + buf[9998] = 0; \ + va_end(ap); \ + \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1, p2, std::string(buf)))); \ + g_Inside_LeafFunc = false; \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall | SourceHook::ProtoInfo::CallConv_HasVafmt); + + +#define THGM_MAKE_TEST2_vafmt(id, ret_type, param1, param2) \ + struct TestClass##id; \ + typedef ret_type RetType##id; \ + typedef ParamState2<0, param1, param2 > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual ret_type Func(param1 p1, param2 p2) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1, p2))); \ + g_Inside_LeafFunc = false; \ + \ + return MakeRet< ret_type >::Do(0); \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(1), &TestClass##id::Func, (p1, p2)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(1)); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2), &TestClass##id::Func, (p1, p2)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2)); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(3), &TestClass##id::Func, (p1, p2)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(3)); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4), &TestClass##id::Func, (p1, p2)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4)); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall) + + #define THGM_SETUP_PI2(id, p1_type, p1_passtype, p1_flags, p2_type, p2_passtype, p2_flags) \ void setuppi_##id() \ { \ @@ -1213,6 +1849,197 @@ std::ostream& operator <<(std::ostream &os,const ParamState6<0, p1, p2, p3, p4, bool TestClass##id::ms_DoRecall = false; \ SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall); +#define THGM_MAKE_TEST3_vafmt_void(id, param1, param2, param3) \ + struct TestClass##id; \ + typedef ParamState4<0, param1, param2, param3, std::string > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual void Func(param1 p1, param2 p2, param3 p3, const char *fmt, ...) \ + { \ + g_Inside_LeafFunc = true; \ + \ + char buf[9999]; \ + va_list ap; \ + va_start(ap, fmt); \ + vsnprintf(buf, 9998, fmt, ap); \ + buf[9998] = 0; \ + va_end(ap); \ + \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1, p2, p3, std::string(buf)))); \ + g_Inside_LeafFunc = false; \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall | SourceHook::ProtoInfo::CallConv_HasVafmt); + + +#define THGM_MAKE_TEST3_vafmt(id, ret_type, param1, param2, param3) \ + struct TestClass##id; \ + typedef ret_type RetType##id; \ + typedef ParamState3<0, param1, param2, param3 > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual ret_type Func(param1 p1, param2 p2, param3 p3) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1, p2, p3))); \ + g_Inside_LeafFunc = false; \ + \ + return MakeRet< ret_type >::Do(0); \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(1), &TestClass##id::Func, (p1, p2, p3)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(1)); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2), &TestClass##id::Func, (p1, p2, p3)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2)); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(3), &TestClass##id::Func, (p1, p2, p3)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(3)); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4), &TestClass##id::Func, (p1, p2, p3)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4)); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall) + + #define THGM_SETUP_PI3(id, p1_type, p1_passtype, p1_flags, p2_type, p2_passtype, p2_flags, p3_type, p3_passtype, p3_flags) \ void setuppi_##id() \ { \ @@ -1424,6 +2251,197 @@ std::ostream& operator <<(std::ostream &os,const ParamState6<0, p1, p2, p3, p4, bool TestClass##id::ms_DoRecall = false; \ SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall); +#define THGM_MAKE_TEST4_vafmt_void(id, param1, param2, param3, param4) \ + struct TestClass##id; \ + typedef ParamState5<0, param1, param2, param3, param4, std::string > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, const char *fmt, ...) \ + { \ + g_Inside_LeafFunc = true; \ + \ + char buf[9999]; \ + va_list ap; \ + va_start(ap, fmt); \ + vsnprintf(buf, 9998, fmt, ap); \ + buf[9998] = 0; \ + va_end(ap); \ + \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1, p2, p3, p4, std::string(buf)))); \ + g_Inside_LeafFunc = false; \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall | SourceHook::ProtoInfo::CallConv_HasVafmt); + + +#define THGM_MAKE_TEST4_vafmt(id, ret_type, param1, param2, param3, param4) \ + struct TestClass##id; \ + typedef ret_type RetType##id; \ + typedef ParamState4<0, param1, param2, param3, param4 > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual ret_type Func(param1 p1, param2 p2, param3 p3, param4 p4) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1, p2, p3, p4))); \ + g_Inside_LeafFunc = false; \ + \ + return MakeRet< ret_type >::Do(0); \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(1), &TestClass##id::Func, (p1, p2, p3, p4)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(1)); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2), &TestClass##id::Func, (p1, p2, p3, p4)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2)); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(3), &TestClass##id::Func, (p1, p2, p3, p4)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(3)); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4), &TestClass##id::Func, (p1, p2, p3, p4)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4)); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall) + + #define THGM_SETUP_PI4(id, p1_type, p1_passtype, p1_flags, p2_type, p2_passtype, p2_flags, p3_type, p3_passtype, p3_flags, p4_type, p4_passtype, p4_flags) \ void setuppi_##id() \ { \ @@ -1642,6 +2660,197 @@ std::ostream& operator <<(std::ostream &os,const ParamState6<0, p1, p2, p3, p4, bool TestClass##id::ms_DoRecall = false; \ SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall); +#define THGM_MAKE_TEST5_vafmt_void(id, param1, param2, param3, param4, param5) \ + struct TestClass##id; \ + typedef ParamState6<0, param1, param2, param3, param4, param5, std::string > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, const char *fmt, ...) \ + { \ + g_Inside_LeafFunc = true; \ + \ + char buf[9999]; \ + va_list ap; \ + va_start(ap, fmt); \ + vsnprintf(buf, 9998, fmt, ap); \ + buf[9998] = 0; \ + va_end(ap); \ + \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1, p2, p3, p4, p5, std::string(buf)))); \ + g_Inside_LeafFunc = false; \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, p5, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, p5, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, p5, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, p5, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall | SourceHook::ProtoInfo::CallConv_HasVafmt); + + +#define THGM_MAKE_TEST5_vafmt(id, ret_type, param1, param2, param3, param4, param5) \ + struct TestClass##id; \ + typedef ret_type RetType##id; \ + typedef ParamState5<0, param1, param2, param3, param4, param5 > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual ret_type Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1, p2, p3, p4, p5))); \ + g_Inside_LeafFunc = false; \ + \ + return MakeRet< ret_type >::Do(0); \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(1), &TestClass##id::Func, (p1, p2, p3, p4, p5)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(1)); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2), &TestClass##id::Func, (p1, p2, p3, p4, p5)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2)); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(3), &TestClass##id::Func, (p1, p2, p3, p4, p5)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(3)); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4), &TestClass##id::Func, (p1, p2, p3, p4, p5)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4)); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall) + + #define THGM_SETUP_PI5(id, p1_type, p1_passtype, p1_flags, p2_type, p2_passtype, p2_flags, p3_type, p3_passtype, p3_flags, p4_type, p4_passtype, p4_flags, p5_type, p5_passtype, p5_flags) \ void setuppi_##id() \ { \ @@ -1867,6 +3076,197 @@ std::ostream& operator <<(std::ostream &os,const ParamState6<0, p1, p2, p3, p4, bool TestClass##id::ms_DoRecall = false; \ SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall); +#define THGM_MAKE_TEST6_vafmt_void(id, param1, param2, param3, param4, param5, param6) \ + struct TestClass##id; \ + typedef ParamState7<0, param1, param2, param3, param4, param5, param6, std::string > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, const char *fmt, ...) \ + { \ + g_Inside_LeafFunc = true; \ + \ + char buf[9999]; \ + va_list ap; \ + va_start(ap, fmt); \ + vsnprintf(buf, 9998, fmt, ap); \ + buf[9998] = 0; \ + va_end(ap); \ + \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1, p2, p3, p4, p5, p6, std::string(buf)))); \ + g_Inside_LeafFunc = false; \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, p6, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5);Increment::type>::Incr(p6); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, p5, p6, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, p6, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5);Increment::type>::Incr(p6); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, p5, p6, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, p6, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5);Increment::type>::Incr(p6); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, p5, p6, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual void Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, p6, buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5);Increment::type>::Incr(p6); \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (p1, p2, p3, p4, p5, p6, "%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall | SourceHook::ProtoInfo::CallConv_HasVafmt); + + +#define THGM_MAKE_TEST6_vafmt(id, ret_type, param1, param2, param3, param4, param5, param6) \ + struct TestClass##id; \ + typedef ret_type RetType##id; \ + typedef ParamState6<0, param1, param2, param3, param4, param5, param6 > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual ret_type Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Func##id(this, ParamState_m##id(p1, p2, p3, p4, p5, p6))); \ + g_Inside_LeafFunc = false; \ + \ + return MakeRet< ret_type >::Do(0); \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, p6))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5);Increment::type>::Incr(p6); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(1), &TestClass##id::Func, (p1, p2, p3, p4, p5, p6)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(1)); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, p6))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5);Increment::type>::Incr(p6); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2), &TestClass##id::Func, (p1, p2, p3, p4, p5, p6)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2)); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, p6))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5);Increment::type>::Incr(p6); \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(3), &TestClass##id::Func, (p1, p2, p3, p4, p5, p6)); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(3)); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual ret_type Call(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(p1, p2, p3, p4, p5, p6))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + Increment::type>::Incr(p1);Increment::type>::Incr(p2);Increment::type>::Incr(p3);Increment::type>::Incr(p4);Increment::type>::Incr(p5);Increment::type>::Incr(p6); \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4), &TestClass##id::Func, (p1, p2, p3, p4, p5, p6)); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4)); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall) + + #define THGM_SETUP_PI6(id, p1_type, p1_passtype, p1_flags, p2_type, p2_passtype, p2_flags, p3_type, p3_passtype, p3_flags, p4_type, p4_passtype, p4_flags, p5_type, p5_passtype, p5_flags, p6_type, p6_passtype, p6_flags) \ void setuppi_##id() \ { \ diff --git a/sourcehook/test/testhookmangen.hxx b/sourcehook/test/testhookmangen.hxx index 100ee2f..8b94fd3 100644 --- a/sourcehook/test/testhookmangen.hxx +++ b/sourcehook/test/testhookmangen.hxx @@ -132,6 +132,20 @@ struct MakeRet< POD > }; // Stores parameter status +template +bool EqualToMyFmtString(T sth) +{ + return false; +} + +bool EqualToMyFmtString(std::string &sth) +{ + if (sth == "Hello %s%d%s") + sth = "Hello BA1L!"; + return true; +} + + @[$1,0,$a: template @@ -145,8 +159,11 @@ struct ParamState$1 @[$2,1,$1: && m_$1 == other.m_$1@] ; } - ParamState$1(@[$2,1,$1|, :p$2 a$2@]) @[$1!=0::@] @[$2,1,$1|, :m_$2(a$2)@] + ParamState$1(@[$2,1,$1:p$2 a$2, @]...) @[$1!=0::@] @[$2,1,$1|, :m_$2(a$2)@] { + @[$2,1,$1: + EqualToMyFmtString(m_$2); + @] } ParamState$1 & operator() (int incrsteps) @@ -364,6 +381,197 @@ std::ostream& operator <<(std::ostream &os,const ParamState$1<0@[$2,1,$1:, p$2@] bool TestClass##id::ms_DoRecall = false; \ SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall); +#define THGM_MAKE_TEST$1_vafmt_void(id@[$2,1,$1:, param$2@]) \ + struct TestClass##id; \ + typedef ParamState@($1+1)<0@[$2,1,$1:, param$2@], std::string > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual void Func(@[$2,1,$1:param$2 p$2, @]const char *fmt, ...) \ + { \ + g_Inside_LeafFunc = true; \ + \ + char buf[9999]; \ + va_list ap; \ + va_start(ap, fmt); \ + vsnprintf(buf, 9998, fmt, ap); \ + buf[9998] = 0; \ + va_end(ap); \ + \ + ADD_STATE(State_Func##id(this, ParamState_m##id(@[$2,1,$1:p$2, @]std::string(buf)))); \ + g_Inside_LeafFunc = false; \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual void Call(@[$2,1,$1:param$2 p$2, @]const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(@[$2,1,$1:p$2, @]buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + @[$2,1,$1:Increment::type>::Incr(p$2);@] \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (@[$2,1,$1:p$2, @]"%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual void Call(@[$2,1,$1:param$2 p$2, @]const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(@[$2,1,$1:p$2, @]buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + @[$2,1,$1:Increment::type>::Incr(p$2);@] \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (@[$2,1,$1:p$2, @]"%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual void Call(@[$2,1,$1:param$2 p$2, @]const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(@[$2,1,$1:p$2, @]buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + @[$2,1,$1:Increment::type>::Incr(p$2);@] \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (@[$2,1,$1:p$2, @]"%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_IGNORED); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual void Call(@[$2,1,$1:param$2 p$2, @]const char *buf) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(@[$2,1,$1:p$2, @]buf))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + @[$2,1,$1:Increment::type>::Incr(p$2);@] \ + RETURN_META_NEWPARAMS(MRES_IGNORED, &TestClass##id::Func, (@[$2,1,$1:p$2, @]"%s!", buf)); \ + } \ + else \ + RETURN_META(MRES_SUPERCEDE); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall | SourceHook::ProtoInfo::CallConv_HasVafmt); + + +#define THGM_MAKE_TEST$1_vafmt(id, ret_type@[$2,1,$1:, param$2@]) \ + struct TestClass##id; \ + typedef ret_type RetType##id; \ + typedef ParamState$1<0@[$2,1,$1:, param$2@] > ParamState_m##id; \ + MAKE_STATE_2(State_Func##id, TestClass##id* /*thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg1_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg2_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg3_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + MAKE_STATE_3(State_Deleg4_##id, TestClass##id* /*ifptr*/, int /*deleg thisptr*/, ParamState_m##id ); \ + \ + struct TestClass##id \ + { \ + static bool ms_DoRecall; \ + \ + virtual ret_type Func(@[$2,1,$1|, :param$2 p$2@]) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Func##id(this, ParamState_m##id(@[$2,1,$1|, :p$2@]))); \ + g_Inside_LeafFunc = false; \ + \ + return MakeRet< ret_type >::Do(0); \ + } \ + \ + struct Delegate1 : public MyDelegate \ + { \ + virtual ret_type Call(@[$2,1,$1|, :param$2 p$2@]) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg1_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(@[$2,1,$1|, :p$2@]))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + @[$2,1,$1:Increment::type>::Incr(p$2);@] \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(1), &TestClass##id::Func, (@[$2,1,$1|, :p$2@])); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(1)); \ + } \ + }; \ + struct Delegate2 : public MyDelegate \ + { \ + virtual ret_type Call(@[$2,1,$1|, :param$2 p$2@]) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg2_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(@[$2,1,$1|, :p$2@]))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + @[$2,1,$1:Increment::type>::Incr(p$2);@] \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2), &TestClass##id::Func, (@[$2,1,$1|, :p$2@])); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(2)); \ + } \ + }; \ + struct Delegate3 : public MyDelegate \ + { \ + virtual ret_type Call(@[$2,1,$1|, :param$2 p$2@]) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg3_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(@[$2,1,$1|, :p$2@]))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + @[$2,1,$1:Increment::type>::Incr(p$2);@] \ + RETURN_META_VALUE_NEWPARAMS(MRES_IGNORED, MakeRet< ret_type >::Do(3), &TestClass##id::Func, (@[$2,1,$1|, :p$2@])); \ + } \ + else \ + RETURN_META_VALUE(MRES_IGNORED, MakeRet< ret_type >::Do(3)); \ + } \ + }; \ + struct Delegate4 : public MyDelegate \ + { \ + virtual ret_type Call(@[$2,1,$1|, :param$2 p$2@]) \ + { \ + g_Inside_LeafFunc = true; \ + ADD_STATE(State_Deleg4_##id(META_IFACEPTR(TestClass##id), PtrBuf(this), ParamState_m##id(@[$2,1,$1|, :p$2@]))); \ + g_Inside_LeafFunc = false; \ + if (ms_DoRecall) \ + { \ + @[$2,1,$1:Increment::type>::Incr(p$2);@] \ + RETURN_META_VALUE_NEWPARAMS(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4), &TestClass##id::Func, (@[$2,1,$1|, :p$2@])); \ + } \ + else \ + RETURN_META_VALUE(MRES_SUPERCEDE, MakeRet< ret_type >::Do(4)); \ + }; \ + }; \ + }; \ + \ + bool TestClass##id::ms_DoRecall = false; \ + SourceHook::CProtoInfoBuilder protoinfo_##id(SourceHook::ProtoInfo::CallConv_ThisCall) + + #define THGM_SETUP_PI$1(id@[$2,1,$1:, p$2_type, p$2_passtype, p$2_flags@]) \ void setuppi_##id() \ { \