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