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

@@ -5635,204 +5635,408 @@ namespace SourceHook
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)())
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
 	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<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
+	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<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
 	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<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
+	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<Iface*>(shptr->GetIfacePtr());
+	}
+
 }
 
 #endif

sourcehook/generate/sourcehook.hxx

@@ -1353,11 +1353,23 @@ namespace SourceHook
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType@[$2,1,$1:, class Param$2@]>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(@[$2,1,$1:Param$2, @]...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType@[$2,1,$1:, class Param$2@]>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(@[$2,1,$1|, :Param$2@]))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
+
+	template <class Iface, class RetType@[$2,1,$1:, class Param$2@]>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(@[$2,1,$1:Param$2, @]...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
 @]
 }
 

sourcehook/sourcehook.h

@@ -5635,204 +5635,408 @@ namespace SourceHook
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)())
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14))
 	{
 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
+	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...))
+	{
+		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
 	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<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
+	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<Iface*>(shptr->GetIfacePtr());
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16))
 	{
 		return OverrideFunctor<RetType>();
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
+	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...))
+	{
+		return OverrideFunctor<RetType>();
+	}
+
 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
 	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<Iface*>(shptr->GetIfacePtr());
 	}
 
+	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
+	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<Iface*>(shptr->GetIfacePtr());
+	}
+
 }
 
 #endif

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 *ret_ptr					ebp - 28 		-4
-			//   my_rettype orig_ret					ebp - 28 (va: -4) - sizeof(my_rettype)			-4
+			//   my_rettype orig_ret					ebp - 28 - sizeof(my_rettype)			-4
-			//   my_rettype override_ret				ebp - 28 (va: -4) - sizeof(my_rettype)*2			-4
+			//   my_rettype override_ret				ebp - 28 - sizeof(my_rettype)*2			-4
-			//   my_rettype plugin_ret					ebp - 28 (va: -4) - sizeof(my_rettype)*3			-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_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, v_va_argptr, REG_EAX);
+				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 **********************
 

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, 

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<jit_int8_t>(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);

sourcehook/sourcehook_pibuilder.h

@@ -23,7 +23,7 @@ namespace SourceHook
 		CVector<PassInfo> m_Params;
 		CVector<PassInfo::V2Info> m_Params2;
 	public:
-		CProtoInfoBuilder(ProtoInfo::CallConvention cc)
+		CProtoInfoBuilder(int cc)
 		{
 			memset(reinterpret_cast<void*>(&m_PI), 0, sizeof(ProtoInfo));
 			m_PI.convention = cc;

sourcehook/test/testhookmangen.cpp

@@ -219,6 +219,15 @@ namespace
 		}
 	};
 
+	template<>
+	struct Increment<std::string>
+	{
+		static void Incr(std::string &what)
+		{
+			what += "!";
+		}
+	};
+
 	#include "testhookmangen.h"
 
 	template <class T>
@@ -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);

sourcehook/test/testhookmangen.hxx

@@ -132,6 +132,20 @@ struct MakeRet< POD<SIZE> >
 };
 
 // Stores parameter status
+template <class T>
+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<int dummy@[$2,1,$1:, class p$2@]>
@@ -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<dummy@[$2,1,$1:, p$2@]> & 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<StripRef< param$2 >::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<StripRef< param$2 >::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<StripRef< param$2 >::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<StripRef< param$2 >::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<StripRef< param$2 >::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<StripRef< param$2 >::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<StripRef< param$2 >::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<StripRef< param$2 >::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() \
 	{ \