sourcehook/sourcehook.h
changeset 58 71016f952503
parent 50 4b6bbaf375dc
child 61 f9b4e9ded36d
     1.1 --- a/sourcehook/sourcehook.h	Wed May 04 13:59:57 2005 +0000
     1.2 +++ b/sourcehook/sourcehook.h	Thu May 05 10:40:47 2005 +0000
     1.3 @@ -1,6 +1,10 @@
     1.4  /* ======== SourceHook ========
     1.5 -* By PM
     1.6 +* Copyright (C) 2004-2005 Metamod:Source Development Team
     1.7  * No warranties of any kind
     1.8 +*
     1.9 +* License: zlib/libpng
    1.10 +*
    1.11 +* Author(s): Pavol "PM OnoTo" Marko
    1.12  * ============================
    1.13  */
    1.14  
    1.15 @@ -12,6 +16,9 @@
    1.16  #ifndef __SOURCEHOOK_H__
    1.17  #define __SOURCEHOOK_H__
    1.18  
    1.19 +#define SH_IFACE_VERSION 1
    1.20 +#define SH_IMPL_VERSION 1
    1.21 +
    1.22  #ifndef SH_GLOB_SHPTR
    1.23  #define SH_GLOB_SHPTR g_SHPtr
    1.24  #endif
    1.25 @@ -89,6 +96,15 @@
    1.26  	};
    1.27  
    1.28  	/**
    1.29 +	*	@brief Implicit cast.
    1.30 +	*/
    1.31 +	template <class In, class Out>
    1.32 +		inline Out implicit_cast(In input)
    1.33 +		{
    1.34 +			return input;
    1.35 +		}
    1.36 +
    1.37 +	/**
    1.38  	*	@brief A plugin typedef
    1.39  	*
    1.40  	*	SourceHook doesn't really care what this is. As long as the ==, != and = operators work on it
    1.41 @@ -164,6 +180,7 @@
    1.42  					ISHDelegate *handler;			//!< Pointer to the handler
    1.43  					bool paused;					//!< If true, the hook should not be executed
    1.44  					Plugin plug;					//!< The owner plugin
    1.45 +					int thisptr_offs;				//!< This pointer offset
    1.46  				};
    1.47  				void *ptr;							//!< Pointer to the interface instance
    1.48  				std::list<Hook> hooks_pre;			//!< A list of pre-hooks
    1.49 @@ -205,8 +222,9 @@
    1.50  
    1.51  	template<class B> struct CallClass
    1.52  	{
    1.53 -		B *ptr;
    1.54 -		OrigVTables vt;
    1.55 +		B *ptr;					//!< Pointer to the actual object
    1.56 +		size_t objsize;			//!< Size of the instance
    1.57 +		OrigVTables vt;			//!< Info about vtables & functions
    1.58  	};
    1.59  
    1.60  	typedef CallClass<void> GenericCallClass;
    1.61 @@ -218,6 +236,16 @@
    1.62  	{
    1.63  	public:
    1.64  		/**
    1.65 +		*	@brief Return interface version
    1.66 +		*/
    1.67 +		virtual int GetIfaceVersion() = 0;
    1.68 +
    1.69 +		/**
    1.70 +		*	@brief Return implementation version
    1.71 +		*/
    1.72 +		virtual int GetImplVersion() = 0;
    1.73 +
    1.74 +		/**
    1.75  		*	@brief Add a hook.
    1.76  		*
    1.77  		*	@return True if the function succeeded, false otherwise
    1.78 @@ -255,9 +283,9 @@
    1.79  		*	@brief Return a pointer to a callclass. Generate a new one if required.
    1.80  		*
    1.81  		*	@param iface The interface pointer
    1.82 -		*	@param size Size of the class
    1.83 +		*	@param size Size of the class instance
    1.84  		*/
    1.85 -		virtual GenericCallClass *GetCallClass(void *iface) = 0;
    1.86 +		virtual GenericCallClass *GetCallClass(void *iface, size_t size) = 0;
    1.87  
    1.88  		/**
    1.89  		*	@brief Release a callclass
    1.90 @@ -274,12 +302,12 @@
    1.91  		virtual void *GetIfacePtr() = 0;					//!< Gets the interface pointer
    1.92  		//////////////////////////////////////////////////////////////////////////
    1.93  		// For hook managers
    1.94 -		virtual META_RES &GetCurResRef() = 0;				//!< Gets the pointer to the current meta result
    1.95 -		virtual META_RES &GetPrevResRef() = 0;				//!< Gets the pointer to the previous meta result
    1.96 -		virtual META_RES &GetStatusRef() = 0;				//!< Gets the pointer to the status variable
    1.97 +		virtual META_RES &GetCurResRef() = 0;				//!< Gets the reference to the current meta result
    1.98 +		virtual META_RES &GetPrevResRef() = 0;				//!< Gets the reference to the previous meta result
    1.99 +		virtual META_RES &GetStatusRef() = 0;				//!< Gets the reference to the status variable
   1.100 +		virtual void* &GetIfacePtrRef() = 0;				//!< Gets the reference to the interface this pointer
   1.101  		virtual void SetOrigRet(const void *ptr) = 0;		//!< Sets the original return pointer
   1.102  		virtual void SetOverrideRet(const void *ptr) = 0;	//!< Sets the override result pointer
   1.103 -		virtual void SetIfacePtr(void *ptr) = 0;			//!< Sets the interface this pointer
   1.104  	};
   1.105  }
   1.106  
   1.107 @@ -306,7 +334,7 @@
   1.108  inline SourceHook::CallClass<ifacetype> *SH_GET_CALLCLASS_R(SourceHook::ISourceHook *shptr, ifacetype *ptr)
   1.109  {
   1.110  	return reinterpret_cast<SourceHook::CallClass<ifacetype>*>(
   1.111 -		shptr->GetCallClass(reinterpret_cast<void*>(ptr)));
   1.112 +		shptr->GetCallClass(reinterpret_cast<void*>(ptr), sizeof(ifacetype)));
   1.113  }
   1.114  
   1.115  template<class ifacetype>
   1.116 @@ -319,14 +347,16 @@
   1.117  #define SH_RELEASE_CALLCLASS(ptr) SH_RELEASE_CALLCLASS_R(SH_GLOB_SHPTR, ptr)
   1.118  
   1.119  #define SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
   1.120 -	__SourceHook_FHAdd##ifacetype##ifacefunc((void*)ifaceptr, post, handler)
   1.121 +	__SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
   1.122 +	post, handler)
   1.123  #define SH_ADD_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \
   1.124  	SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, fastdelegate::MakeDelegate(handler), post)
   1.125  #define SH_ADD_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \
   1.126  	SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, fastdelegate::MakeDelegate(handler_inst, handler_func), post)
   1.127  
   1.128  #define SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
   1.129 -	__SourceHook_FHRemove##ifacetype##ifacefunc((void*)ifaceptr, post, handler)
   1.130 +	__SourceHook_FHRemove##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
   1.131 +	post, handler)
   1.132  #define SH_REMOVE_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \
   1.133  	SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, fastdelegate::MakeDelegate(handler), post)
   1.134  #define SH_REMOVE_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \
   1.135 @@ -355,6 +385,10 @@
   1.136  	static int HookManPubFunc(::SourceHook::HookManagerAction action, ::SourceHook::HookManagerInfo *param) \
   1.137  	{ \
   1.138  		using namespace ::SourceHook; \
   1.139 +		/* Verify interface version */ \
   1.140 +		if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \
   1.141 +			return 1; \
   1.142 +		\
   1.143  		if (action == ::SourceHook::HA_GetInfo) \
   1.144  		{ \
   1.145  			param->proto = ms_Proto; \
   1.146 @@ -458,8 +492,8 @@
   1.147  	META_RES &cur_res = SH_GLOB_SHPTR->GetCurResRef(); \
   1.148  	META_RES &prev_res = SH_GLOB_SHPTR->GetPrevResRef(); \
   1.149  	META_RES &status = SH_GLOB_SHPTR->GetStatusRef(); \
   1.150 +	void* &ifptr = SH_GLOB_SHPTR->GetIfacePtrRef(); \
   1.151  	status = MRES_IGNORED; \
   1.152 -	SH_GLOB_SHPTR->SetIfacePtr(this); \
   1.153  	SH_GLOB_SHPTR->SetOrigRet(reinterpret_cast<void*>(&orig_ret)); \
   1.154  	SH_GLOB_SHPTR->SetOverrideRet(NULL);
   1.155  
   1.156 @@ -469,6 +503,7 @@
   1.157  	{ \
   1.158  		if (hiter->paused) continue; \
   1.159  		cur_res = MRES_IGNORED; \
   1.160 +		ifptr = reinterpret_cast<void*>(reinterpret_cast<char*>(this) - hiter->thisptr_offs); \
   1.161  		plugin_ret = reinterpret_cast<CSHDelegate<FD>*>(hiter->handler)->GetDeleg() params; \
   1.162  		prev_res = cur_res; \
   1.163  		if (cur_res > status) \
   1.164 @@ -532,8 +567,8 @@
   1.165  	META_RES &cur_res = SH_GLOB_SHPTR->GetCurResRef(); \
   1.166  	META_RES &prev_res = SH_GLOB_SHPTR->GetPrevResRef(); \
   1.167  	META_RES &status = SH_GLOB_SHPTR->GetStatusRef(); \
   1.168 +	void* &ifptr = SH_GLOB_SHPTR->GetIfacePtrRef(); \
   1.169  	status = MRES_IGNORED; \
   1.170 -	SH_GLOB_SHPTR->SetIfacePtr(this); \
   1.171  	SH_GLOB_SHPTR->SetOverrideRet(NULL);
   1.172  
   1.173  #define SH_CALL_HOOKS_void(post, params) \
   1.174 @@ -542,6 +577,7 @@
   1.175  	{ \
   1.176  		if (hiter->paused) continue; \
   1.177  		cur_res = MRES_IGNORED; \
   1.178 +		ifptr = reinterpret_cast<void*>(reinterpret_cast<char*>(this) - hiter->thisptr_offs); \
   1.179  		reinterpret_cast<CSHDelegate<FD>*>(hiter->handler)->GetDeleg() params; \
   1.180  		prev_res = cur_res; \
   1.181  		if (cur_res > status) \
   1.182 @@ -1460,8 +1496,8 @@
   1.183  { \
   1.184  	using namespace ::SourceHook; \
   1.185  	MemFuncInfo mfi; \
   1.186 -	MFI_Impl<sizeof(m_MFP)>::GetFuncInfo(m_MFP, mfi); \
   1.187 -	OrigVTables::const_iterator iter = m_CC->vt.find(mfi.vtbloffs); \
   1.188 +	GetFuncInfo(m_CC->ptr, m_MFP, mfi); \
   1.189 +	OrigVTables::const_iterator iter = m_CC->vt.find(mfi.thisptroffs + mfi.vtbloffs); \
   1.190  	if (iter == m_CC->vt.end() || mfi.vtblindex >= (int)iter->second.size() || iter->second[mfi.vtblindex] == NULL) \
   1.191  		return (m_CC->ptr->*m_MFP)call; \
   1.192  	\
   1.193 @@ -1473,7 +1509,8 @@
   1.194  	} u; \
   1.195  	u.addr = iter->second[mfi.vtblindex]; \
   1.196  	\
   1.197 -	return (reinterpret_cast<EmptyClass*>(m_CC->ptr)->*u.mfpnew)call; \
   1.198 +	void *adjustedthisptr = reinterpret_cast<void*>(reinterpret_cast<char*>(m_CC->ptr) + mfi.thisptroffs); \
   1.199 +	return (reinterpret_cast<EmptyClass*>(adjustedthisptr)->*u.mfpnew)call; \
   1.200  }
   1.201  
   1.202  
   1.203 @@ -1559,499 +1596,529 @@
   1.204  	};
   1.205  }
   1.206  
   1.207 +// SH_CALL needs to deduce the return type -> it uses templates and function overloading
   1.208 +// That's why SH_CALL takes two parameters: "mfp2" of type RetType(X::*mfp)(params), and "mfp" of type MFP
   1.209 +// The only purpose of the mfp2 parameter is to extract the return type
   1.210 +
   1.211  // Support for 0 arguments
   1.212 -template <class X, class Y, class RetType>
   1.213 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)()>
   1.214 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)())
   1.215 +template <class X, class Y, class MFP, class RetType>
   1.216 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.217 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)())
   1.218  {
   1.219 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)()>(ptr, mfp);
   1.220 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.221  }
   1.222  
   1.223 -template <class X, class Y, class RetType>
   1.224 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)() const>
   1.225 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)()const)
   1.226 +template <class X, class Y, class MFP, class RetType>
   1.227 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.228 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)()const)
   1.229  {
   1.230 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)() const>(ptr, mfp);
   1.231 -}
   1.232 -
   1.233 -template <class X, class Y, class RetType>
   1.234 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(...)>
   1.235 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(...))
   1.236 -{
   1.237 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(...)>(ptr, mfp);
   1.238 -}
   1.239 -
   1.240 -template <class X, class Y, class RetType>
   1.241 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(...) const>
   1.242 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(...)const)
   1.243 -{
   1.244 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(...) const>(ptr, mfp);
   1.245 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.246  }
   1.247  
   1.248  // Support for 1 arguments
   1.249 -template <class X, class Y, class RetType, class Param1>
   1.250 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1)>
   1.251 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1))
   1.252 +template <class X, class Y, class MFP, class RetType, class Param1>
   1.253 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.254 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1))
   1.255  {
   1.256 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1)>(ptr, mfp);
   1.257 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.258  }
   1.259  
   1.260 -template <class X, class Y, class RetType, class Param1>
   1.261 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1) const>
   1.262 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1)const)
   1.263 +template <class X, class Y, class MFP, class RetType, class Param1>
   1.264 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.265 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1)const)
   1.266  {
   1.267 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1) const>(ptr, mfp);
   1.268 -}
   1.269 -
   1.270 -template <class X, class Y, class RetType, class Param1>
   1.271 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, ...)>
   1.272 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, ...))
   1.273 -{
   1.274 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, ...)>(ptr, mfp);
   1.275 -}
   1.276 -
   1.277 -template <class X, class Y, class RetType, class Param1>
   1.278 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, ...) const>
   1.279 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, ...)const)
   1.280 -{
   1.281 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, ...) const>(ptr, mfp);
   1.282 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.283  }
   1.284  
   1.285  // Support for 2 arguments
   1.286 -template <class X, class Y, class RetType, class Param1, class Param2>
   1.287 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2)>
   1.288 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2))
   1.289 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
   1.290 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.291 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2))
   1.292  {
   1.293 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2)>(ptr, mfp);
   1.294 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.295  }
   1.296  
   1.297 -template <class X, class Y, class RetType, class Param1, class Param2>
   1.298 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2) const>
   1.299 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2)const)
   1.300 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
   1.301 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.302 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2)const)
   1.303  {
   1.304 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2) const>(ptr, mfp);
   1.305 -}
   1.306 -
   1.307 -template <class X, class Y, class RetType, class Param1, class Param2>
   1.308 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, ...)>
   1.309 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, ...))
   1.310 -{
   1.311 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, ...)>(ptr, mfp);
   1.312 -}
   1.313 -
   1.314 -template <class X, class Y, class RetType, class Param1, class Param2>
   1.315 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, ...) const>
   1.316 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, ...)const)
   1.317 -{
   1.318 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, ...) const>(ptr, mfp);
   1.319 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.320  }
   1.321  
   1.322  // Support for 3 arguments
   1.323 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3>
   1.324 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3)>
   1.325 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3))
   1.326 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
   1.327 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.328 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3))
   1.329  {
   1.330 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3)>(ptr, mfp);
   1.331 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.332  }
   1.333  
   1.334 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3>
   1.335 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3) const>
   1.336 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3)const)
   1.337 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
   1.338 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.339 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3)const)
   1.340  {
   1.341 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3) const>(ptr, mfp);
   1.342 -}
   1.343 -
   1.344 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3>
   1.345 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, ...)>
   1.346 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, ...))
   1.347 -{
   1.348 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, ...)>(ptr, mfp);
   1.349 -}
   1.350 -
   1.351 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3>
   1.352 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, ...) const>
   1.353 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, ...)const)
   1.354 -{
   1.355 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, ...) const>(ptr, mfp);
   1.356 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.357  }
   1.358  
   1.359  // Support for 4 arguments
   1.360 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
   1.361 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4)>
   1.362 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4))
   1.363 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
   1.364 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.365 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4))
   1.366  {
   1.367 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4)>(ptr, mfp);
   1.368 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.369  }
   1.370  
   1.371 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
   1.372 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4) const>
   1.373 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4)const)
   1.374 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
   1.375 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.376 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4)const)
   1.377  {
   1.378 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4) const>(ptr, mfp);
   1.379 -}
   1.380 -
   1.381 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
   1.382 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, ...)>
   1.383 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, ...))
   1.384 -{
   1.385 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, ...)>(ptr, mfp);
   1.386 -}
   1.387 -
   1.388 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
   1.389 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, ...) const>
   1.390 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, ...)const)
   1.391 -{
   1.392 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, ...) const>(ptr, mfp);
   1.393 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.394  }
   1.395  
   1.396  // Support for 5 arguments
   1.397 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   1.398 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5)>
   1.399 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5))
   1.400 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   1.401 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.402 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5))
   1.403  {
   1.404 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5)>(ptr, mfp);
   1.405 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.406  }
   1.407  
   1.408 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   1.409 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5) const>
   1.410 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5)const)
   1.411 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   1.412 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.413 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5)const)
   1.414  {
   1.415 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5) const>(ptr, mfp);
   1.416 -}
   1.417 -
   1.418 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   1.419 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, ...)>
   1.420 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, ...))
   1.421 -{
   1.422 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, ...)>(ptr, mfp);
   1.423 -}
   1.424 -
   1.425 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   1.426 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, ...) const>
   1.427 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, ...)const)
   1.428 -{
   1.429 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, ...) const>(ptr, mfp);
   1.430 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.431  }
   1.432  
   1.433  // Support for 6 arguments
   1.434 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   1.435 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6)>
   1.436 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6))
   1.437 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   1.438 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.439 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6))
   1.440  {
   1.441 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6)>(ptr, mfp);
   1.442 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.443  }
   1.444  
   1.445 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   1.446 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6) const>
   1.447 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6)const)
   1.448 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   1.449 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.450 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6)const)
   1.451  {
   1.452 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6) const>(ptr, mfp);
   1.453 -}
   1.454 -
   1.455 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   1.456 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, ...)>
   1.457 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...))
   1.458 -{
   1.459 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, ...)>(ptr, mfp);
   1.460 -}
   1.461 -
   1.462 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   1.463 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, ...) const>
   1.464 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...)const)
   1.465 -{
   1.466 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, ...) const>(ptr, mfp);
   1.467 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.468  }
   1.469  
   1.470  // Support for 7 arguments
   1.471 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   1.472 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7)>
   1.473 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7))
   1.474 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   1.475 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.476 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7))
   1.477  {
   1.478 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7)>(ptr, mfp);
   1.479 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.480  }
   1.481  
   1.482 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   1.483 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7) const>
   1.484 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7)const)
   1.485 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   1.486 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.487 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7)const)
   1.488  {
   1.489 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7) const>(ptr, mfp);
   1.490 -}
   1.491 -
   1.492 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   1.493 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...)>
   1.494 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...))
   1.495 -{
   1.496 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...)>(ptr, mfp);
   1.497 -}
   1.498 -
   1.499 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   1.500 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...) const>
   1.501 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...)const)
   1.502 -{
   1.503 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...) const>(ptr, mfp);
   1.504 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.505  }
   1.506  
   1.507  // Support for 8 arguments
   1.508 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   1.509 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8)>
   1.510 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8))
   1.511 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   1.512 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.513 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8))
   1.514  {
   1.515 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8)>(ptr, mfp);
   1.516 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.517  }
   1.518  
   1.519 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   1.520 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8) const>
   1.521 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8)const)
   1.522 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   1.523 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.524 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8)const)
   1.525  {
   1.526 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8) const>(ptr, mfp);
   1.527 -}
   1.528 -
   1.529 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   1.530 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...)>
   1.531 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...))
   1.532 -{
   1.533 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...)>(ptr, mfp);
   1.534 -}
   1.535 -
   1.536 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   1.537 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...) const>
   1.538 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...)const)
   1.539 -{
   1.540 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...) const>(ptr, mfp);
   1.541 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.542  }
   1.543  
   1.544  // Support for 9 arguments
   1.545 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
   1.546 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9)>
   1.547 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9))
   1.548 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
   1.549 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.550 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9))
   1.551  {
   1.552 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9)>(ptr, mfp);
   1.553 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.554  }
   1.555  
   1.556 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
   1.557 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9) const>
   1.558 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9)const)
   1.559 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
   1.560 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.561 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9)const)
   1.562  {
   1.563 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9) const>(ptr, mfp);
   1.564 -}
   1.565 -
   1.566 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
   1.567 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...)>
   1.568 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...))
   1.569 -{
   1.570 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...)>(ptr, mfp);
   1.571 -}
   1.572 -
   1.573 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
   1.574 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...) const>
   1.575 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...)const)
   1.576 -{
   1.577 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...) const>(ptr, mfp);
   1.578 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.579  }
   1.580  
   1.581  // Support for 10 arguments
   1.582 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
   1.583 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10)>
   1.584 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10))
   1.585 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
   1.586 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.587 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10))
   1.588  {
   1.589 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10)>(ptr, mfp);
   1.590 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.591  }
   1.592  
   1.593 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
   1.594 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10) const>
   1.595 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10)const)
   1.596 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
   1.597 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.598 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10)const)
   1.599  {
   1.600 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10) const>(ptr, mfp);
   1.601 -}
   1.602 -
   1.603 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
   1.604 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...)>
   1.605 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...))
   1.606 -{
   1.607 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...)>(ptr, mfp);
   1.608 -}
   1.609 -
   1.610 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
   1.611 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...) const>
   1.612 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...)const)
   1.613 -{
   1.614 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...) const>(ptr, mfp);
   1.615 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.616  }
   1.617  
   1.618  // Support for 11 arguments
   1.619 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
   1.620 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11)>
   1.621 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11))
   1.622 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
   1.623 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.624 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11))
   1.625  {
   1.626 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11)>(ptr, mfp);
   1.627 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.628  }
   1.629  
   1.630 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
   1.631 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11) const>
   1.632 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11)const)
   1.633 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
   1.634 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.635 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11)const)
   1.636  {
   1.637 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11) const>(ptr, mfp);
   1.638 -}
   1.639 -
   1.640 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
   1.641 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...)>
   1.642 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...))
   1.643 -{
   1.644 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...)>(ptr, mfp);
   1.645 -}
   1.646 -
   1.647 -template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
   1.648 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...) const>
   1.649 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...)const)
   1.650 -{
   1.651 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...) const>(ptr, mfp);
   1.652 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.653  }
   1.654  
   1.655  // Support for 12 arguments
   1.656 -template <class X, class Y, 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>
   1.657 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12)>
   1.658 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12))
   1.659 +template <class X, class Y, class MFP, 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>
   1.660 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.661 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12))
   1.662  {
   1.663 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12)>(ptr, mfp);
   1.664 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.665  }
   1.666  
   1.667 -template <class X, class Y, 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>
   1.668 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12) const>
   1.669 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12)const)
   1.670 +template <class X, class Y, class MFP, 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>
   1.671 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.672 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12)const)
   1.673  {
   1.674 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12) const>(ptr, mfp);
   1.675 -}
   1.676 -
   1.677 -template <class X, class Y, 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>
   1.678 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...)>
   1.679 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...))
   1.680 -{
   1.681 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...)>(ptr, mfp);
   1.682 -}
   1.683 -
   1.684 -template <class X, class Y, 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>
   1.685 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...) const>
   1.686 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...)const)
   1.687 -{
   1.688 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...) const>(ptr, mfp);
   1.689 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.690  }
   1.691  
   1.692  // Support for 13 arguments
   1.693 -template <class X, class Y, 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>
   1.694 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13)>
   1.695 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13))
   1.696 +template <class X, class Y, class MFP, 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>
   1.697 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.698 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13))
   1.699  {
   1.700 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13)>(ptr, mfp);
   1.701 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.702  }
   1.703  
   1.704 -template <class X, class Y, 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>
   1.705 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13) const>
   1.706 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13)const)
   1.707 +template <class X, class Y, class MFP, 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>
   1.708 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.709 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13)const)
   1.710  {
   1.711 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13) const>(ptr, mfp);
   1.712 -}
   1.713 -
   1.714 -template <class X, class Y, 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>
   1.715 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...)>
   1.716 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...))
   1.717 -{
   1.718 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...)>(ptr, mfp);
   1.719 -}
   1.720 -
   1.721 -template <class X, class Y, 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>
   1.722 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...) const>
   1.723 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...)const)
   1.724 -{
   1.725 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...) const>(ptr, mfp);
   1.726 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.727  }
   1.728  
   1.729  // Support for 14 arguments
   1.730 -template <class X, class Y, 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>
   1.731 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14)>
   1.732 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14))
   1.733 +template <class X, class Y, class MFP, 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>
   1.734 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.735 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14))
   1.736  {
   1.737 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14)>(ptr, mfp);
   1.738 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.739  }
   1.740  
   1.741 -template <class X, class Y, 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>
   1.742 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14) const>
   1.743 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14)const)
   1.744 +template <class X, class Y, class MFP, 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>
   1.745 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.746 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14)const)
   1.747  {
   1.748 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14) const>(ptr, mfp);
   1.749 -}
   1.750 -
   1.751 -template <class X, class Y, 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>
   1.752 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...)>
   1.753 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...))
   1.754 -{
   1.755 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...)>(ptr, mfp);
   1.756 -}
   1.757 -
   1.758 -template <class X, class Y, 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>
   1.759 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...) const>
   1.760 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...)const)
   1.761 -{
   1.762 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...) const>(ptr, mfp);
   1.763 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.764  }
   1.765  
   1.766  // Support for 15 arguments
   1.767 -template <class X, class Y, 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>
   1.768 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15)>
   1.769 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15))
   1.770 +template <class X, class Y, class MFP, 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>
   1.771 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.772 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15))
   1.773  {
   1.774 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15)>(ptr, mfp);
   1.775 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.776  }
   1.777  
   1.778 -template <class X, class Y, 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>
   1.779 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15) const>
   1.780 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15)const)
   1.781 +template <class X, class Y, class MFP, 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>
   1.782 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.783 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15)const)
   1.784  {
   1.785 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15) const>(ptr, mfp);
   1.786 -}
   1.787 -
   1.788 -template <class X, class Y, 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>
   1.789 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...)>
   1.790 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...))
   1.791 -{
   1.792 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...)>(ptr, mfp);
   1.793 -}
   1.794 -
   1.795 -template <class X, class Y, 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>
   1.796 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...) const>
   1.797 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...)const)
   1.798 -{
   1.799 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...) const>(ptr, mfp);
   1.800 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.801  }
   1.802  
   1.803  // Support for 16 arguments
   1.804 -template <class X, class Y, 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>
   1.805 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16)>
   1.806 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16))
   1.807 +template <class X, class Y, class MFP, 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>
   1.808 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.809 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16))
   1.810 +{
   1.811 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.812 +}
   1.813 +
   1.814 +template <class X, class Y, class MFP, 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>
   1.815 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.816 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16)const)
   1.817 +{
   1.818 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.819 +}
   1.820 +
   1.821 +
   1.822 +#if SH_COMP != SH_COMP_MSVC
   1.823 +
   1.824 +// **** MSVC doesn't like these, GCC needs them ****
   1.825 +
   1.826 +// Support for 0 arguments
   1.827 +template <class X, class Y, class MFP, class RetType>
   1.828 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.829 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(...))
   1.830 +{
   1.831 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.832 +}
   1.833 +
   1.834 +template <class X, class Y, class MFP, class RetType>
   1.835 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.836 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(...)const)
   1.837  {
   1.838 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16)>(ptr, mfp);
   1.839 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.840 +}
   1.841 +
   1.842 +// Support for 1 arguments
   1.843 +template <class X, class Y, class MFP, class RetType, class Param1>
   1.844 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.845 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, ...))
   1.846 +{
   1.847 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.848 +}
   1.849 +
   1.850 +template <class X, class Y, class MFP, class RetType, class Param1>
   1.851 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.852 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, ...)const)
   1.853 +{
   1.854 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.855 +}
   1.856 +
   1.857 +// Support for 2 arguments
   1.858 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
   1.859 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.860 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, ...))
   1.861 +{
   1.862 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.863 +}
   1.864 +
   1.865 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
   1.866 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.867 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, ...)const)
   1.868 +{
   1.869 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.870  }
   1.871  
   1.872 -template <class X, class Y, 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>
   1.873 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16) const>
   1.874 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16)const)
   1.875 +// Support for 3 arguments
   1.876 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
   1.877 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.878 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, ...))
   1.879 +{
   1.880 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.881 +}
   1.882 +
   1.883 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
   1.884 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.885 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, ...)const)
   1.886 +{
   1.887 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.888 +}
   1.889 +
   1.890 +// Support for 4 arguments
   1.891 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
   1.892 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.893 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, ...))
   1.894 +{
   1.895 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.896 +}
   1.897 +
   1.898 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
   1.899 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.900 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, ...)const)
   1.901 +{
   1.902 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.903 +}
   1.904 +
   1.905 +// Support for 5 arguments
   1.906 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   1.907 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.908 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...))
   1.909  {
   1.910 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16) const>(ptr, mfp);
   1.911 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.912 +}
   1.913 +
   1.914 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   1.915 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.916 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...)const)
   1.917 +{
   1.918 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.919 +}
   1.920 +
   1.921 +// Support for 6 arguments
   1.922 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   1.923 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.924 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...))
   1.925 +{
   1.926 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.927 +}
   1.928 +
   1.929 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   1.930 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.931 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...)const)
   1.932 +{
   1.933 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.934 +}
   1.935 +
   1.936 +// Support for 7 arguments
   1.937 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   1.938 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.939 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...))
   1.940 +{
   1.941 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.942 +}
   1.943 +
   1.944 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   1.945 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.946 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...)const)
   1.947 +{
   1.948 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.949  }
   1.950  
   1.951 -template <class X, class Y, 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>
   1.952 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...)>
   1.953 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...))
   1.954 +// Support for 8 arguments
   1.955 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   1.956 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.957 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...))
   1.958 +{
   1.959 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.960 +}
   1.961 +
   1.962 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   1.963 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.964 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...)const)
   1.965 +{
   1.966 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.967 +}
   1.968 +
   1.969 +// Support for 9 arguments
   1.970 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
   1.971 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.972 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...))
   1.973 +{
   1.974 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.975 +}
   1.976 +
   1.977 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
   1.978 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.979 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...)const)
   1.980  {
   1.981 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...)>(ptr, mfp);
   1.982 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.983 +}
   1.984 +
   1.985 +// Support for 10 arguments
   1.986 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
   1.987 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.988 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...))
   1.989 +{
   1.990 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.991 +}
   1.992 +
   1.993 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
   1.994 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
   1.995 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...)const)
   1.996 +{
   1.997 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
   1.998 +}
   1.999 +
  1.1000 +// Support for 11 arguments
  1.1001 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
  1.1002 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1003 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...))
  1.1004 +{
  1.1005 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1006 +}
  1.1007 +
  1.1008 +template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
  1.1009 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1010 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...)const)
  1.1011 +{
  1.1012 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1013 +}
  1.1014 +
  1.1015 +// Support for 12 arguments
  1.1016 +template <class X, class Y, class MFP, 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>
  1.1017 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1018 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...))
  1.1019 +{
  1.1020 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1021  }
  1.1022  
  1.1023 -template <class X, class Y, 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>
  1.1024 -SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...) const>
  1.1025 -SH_CALL(SourceHook::CallClass<Y> *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...)const)
  1.1026 +template <class X, class Y, class MFP, 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>
  1.1027 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1028 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...)const)
  1.1029 +{
  1.1030 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1031 +}
  1.1032 +
  1.1033 +// Support for 13 arguments
  1.1034 +template <class X, class Y, class MFP, 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>
  1.1035 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1036 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...))
  1.1037  {
  1.1038 -	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, RetType (X::*)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...) const>(ptr, mfp);
  1.1039 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1040 +}
  1.1041 +
  1.1042 +template <class X, class Y, class MFP, 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>
  1.1043 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1044 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...)const)
  1.1045 +{
  1.1046 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1047 +}
  1.1048 +
  1.1049 +// Support for 14 arguments
  1.1050 +template <class X, class Y, class MFP, 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>
  1.1051 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1052 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...))
  1.1053 +{
  1.1054 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1055  }
  1.1056  
  1.1057 +template <class X, class Y, class MFP, 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>
  1.1058 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1059 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...)const)
  1.1060 +{
  1.1061 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1062 +}
  1.1063 +
  1.1064 +// Support for 15 arguments
  1.1065 +template <class X, class Y, class MFP, 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>
  1.1066 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1067 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...))
  1.1068 +{
  1.1069 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1070 +}
  1.1071 +
  1.1072 +template <class X, class Y, class MFP, 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>
  1.1073 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1074 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...)const)
  1.1075 +{
  1.1076 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1077 +}
  1.1078 +
  1.1079 +// Support for 16 arguments
  1.1080 +template <class X, class Y, class MFP, 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>
  1.1081 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1082 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...))
  1.1083 +{
  1.1084 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1085 +}
  1.1086 +
  1.1087 +template <class X, class Y, class MFP, 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>
  1.1088 +SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>
  1.1089 +SH_CALL2(SourceHook::CallClass<Y> *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...)const)
  1.1090 +{
  1.1091 +	return SourceHook::ExecutableClass<SourceHook::CallClass<Y>, RetType, MFP>(ptr, mfp);
  1.1092 +}
  1.1093 +
  1.1094 +
  1.1095 +#endif
  1.1096 +
  1.1097 +#define SH_CALL(ptr, mfp) SH_CALL2((ptr), (mfp), (mfp))
  1.1098  
  1.1099  #undef SH_MAKE_EXECUTABLECLASS_BODY
  1.1100