1 /* ======== SourceHook ========
2 * Copyright (C) 2004-2007 Metamod:Source Development Team
3 * No warranties of any kind
7 * Author(s): Pavol "PM OnoTo" Marko
8 * ============================
13 * @brief Contains the public SourceHook API
16 #ifndef __SOURCEHOOK_H__
17 #define __SOURCEHOOK_H__
19 // Interface revisions:
20 // 1 - Initial revision
21 // 2 - Changed to virtual functions for iterators and all queries
22 // 3 - Added "hook loop status variable"
24 // 5 - New "V2" interface
25 #define SH_IFACE_VERSION 5
29 // 4 - addition of hook ids and vp hooks (with them, AddHookNew and RemoveHookNew)
30 // This is not a SH_IFACE_VERSION change so that old plugins continue working!
31 // 5 - implementation of the new "V2" interface
32 #define SH_IMPL_VERSION 5
36 #define SH_HOOKMAN_VERSION 1
38 // The value of SH_GLOB_SHPTR has to be a pointer to SourceHook::ISourceHook
39 // It's used in various macros
41 #define SH_GLOB_SHPTR g_SHPtr
44 // Used to identify the current plugin
45 #ifndef SH_GLOB_PLUGPTR
46 #define SH_GLOB_PLUGPTR g_PLID
53 # define SH_ASSERT(x, info) \
57 printf("SOURCEHOOK DEBUG ASSERTION FAILED: %s:%u(%s): %s: ", __FILE__, __LINE__, __FUNCTION__, #x); \
65 # define SH_ASSERT(x, info)
69 #define SH_SYS_WIN32 1
70 #define SH_SYS_LINUX 2
73 # define SH_SYS SH_SYS_WIN32
74 #elif defined __linux__
75 # define SH_SYS SH_SYS_LINUX
77 # error Unsupported system
82 #define SH_COMP_MSVC 2
85 # define SH_COMP SH_COMP_MSVC
86 #elif defined __GNUC__
87 # define SH_COMP SH_COMP_GCC
89 # error Unsupported compiler
92 #if SH_COMP==SH_COMP_MSVC
93 # define vsnprintf _vsnprintf
96 #if SH_SYS != SH_SYS_WIN32
100 #define SH_PTRSIZE sizeof(void*)
102 #include "sh_memfuncinfo.h"
103 #include "FastDelegate.h"
107 // Flags returned by a plugin's api function.
108 // NOTE: order is crucial, as greater/less comparisons are made.
111 MRES_IGNORED=0, // plugin didn't take any action
112 MRES_HANDLED, // plugin did something, but real function should still be called
113 MRES_OVERRIDE, // call real function, but use my return value
114 MRES_SUPERCEDE // skip real function; use my return value
121 * @brief Specifies the size (in bytes) for the internal buffer of vafmt(printf-like) function handlers
123 const int STRBUF_LEN=4096;
126 * @brief An empty class. No inheritance used. Used for original-function-call hacks
133 * @brief Implicit cast.
135 template <class In, class Out>
136 inline Out implicit_cast(In input)
142 * @brief A plugin typedef
144 * SourceHook doesn't really care what this is. As long as the ==, != and = operators work on it and every
145 * plugin has a unique identifier, everything is ok.
146 * It should also be possible to set it to 0.
151 template <class T> class CallClass : public T
154 typedef void ManualCallClass;
157 * @brief Describes the way a parameter/retval is passed.
163 PassType_Unknown=0, /**< Unknown -- no extra info available */
164 PassType_Basic, /**< Plain old register data (pointers, integers) */
165 PassType_Float, /**< Floating point data */
166 PassType_Object, /**< Object or structure */
171 PassFlag_ByVal = (1<<0), /**< Passing by value */
172 PassFlag_ByRef = (1<<1), /**< Passing by reference */
173 PassFlag_ODtor = (1<<2), /**< Object has a destructor */
174 PassFlag_OCtor = (1<<3), /**< Object has a constructor */
175 PassFlag_AssignOp = (1<<4) /**< Object has an assignment operator */
178 size_t size; //!< Size of the data being passed
181 // (might be used in future versions for automatic hookfunc generation)
182 int type; //!< PassType value
183 unsigned int flags; //!< Pass/return flags
190 CallConv_Unknown, /**< Unknown -- no extra info available */
191 CallConv_ThisCall, /**< This call (object pointer required) */
192 CallConv_Cdecl, /**< Standard C call */
195 int numOfParams; //!< number of parameters
196 PassInfo retPassInfo; //!< PassInfo for the return value. size=0 -> no retval
197 const PassInfo *paramsPassInfo; //!< PassInfos for the parameters
203 struct IHookManagerInfo;
206 * @brief Pointer to hook manager interface function
208 * The hook manager should store hi for later use if store==true. It should then call hi->SetInfo(...) if hi
209 * is non-null. The hook manager can return 0 for success or a non-zero value if it doesn't want to be used.
211 * @param hi A pointer to IHookManagerInfo
213 typedef int (*HookManagerPubFunc)(bool store, IHookManagerInfo *hi);
218 virtual bool IsEqual(ISHDelegate *pOtherDeleg) = 0; // pOtherDeleg is from the same plugin and hookman
219 virtual void DeleteThis() = 0;
222 struct IHookManagerInfo
224 virtual void SetInfo(int hookman_version, int vtbloffs, int vtblidx,
225 ProtoInfo *proto, void *hookfunc_vfnptr) = 0;
228 // I'm adding support for functions which return references.
231 // SH_SETUPCALLS doesn't use plain rettype to store the temporary return values (plugin ret, orig ret,
232 // override ret) anymore; instead, it uses SourceHook::ReferenceCarrier<rettype>::type
233 // this is typedefed to the original rettype normally, but if the rettype is a reference, it's a special class
234 // which stores the reference as a pointer, and implements constructors, operator= and a conversion operator.
235 // special cases were needed for getoverrideret / getorigret; these are implemented through the
236 // SourceHook::MacroRefHelpers structs.
237 // Furthermore, SetOverrideRet had to be changed a bit; see SourceHook::OverrideFunctor somewhere down in this file.
238 template <class T> struct ReferenceCarrier
243 template <class T> struct ReferenceCarrier<T&>
249 type() : m_StoredRef(NULL)
252 type(T& ref) : m_StoredRef(&ref)
256 T& operator= (T& ref)
271 virtual ISHDelegate *GetNext() = 0;
272 virtual void *GetOverrideRetPtr() = 0;
273 virtual const void *GetOrigRetPtr() = 0;
274 virtual bool ShouldCallOrig() = 0;
278 * @brief The main SourceHook interface
284 * @brief Return interface version
286 virtual int GetIfaceVersion() = 0;
289 * @brief Return implementation version
291 virtual int GetImplVersion() = 0;
294 * @brief Modes for the new AddHook
304 * @brief Add a (VP) hook.
306 * @return non-zero hook id on success, 0 otherwise
308 * @param plug The unique identifier of the plugin that calls this function
309 * @param mode Can be either Hook_Normal or Hook_VP (vtable-wide hook)
310 * @param iface The interface pointer
311 * @param ifacesize The size of the class iface points to
312 * @param myHookMan A hook manager function that should be capable of handling the function
313 * @param handler A pointer to the hook handler something
314 * @param post Set to true if you want a post handler
316 virtual int AddHook(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
317 ISHDelegate *handler, bool post) = 0;
319 // Source backwarts compat (only for normal hooks)
320 virtual bool RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
321 ISHDelegate *handler, bool post) = 0;
324 * @brief Remove a hook by ID.
326 * @return true on success, false otherwise
328 * @param hookid The hook id (returned by AddHook)
330 virtual bool RemoveHookByID(int hookid) = 0;
333 * @brief Pause a hook by ID.
335 * @return true on success, false otherwise
337 * @param hookid The hook id (returned by AddHook)
339 virtual bool PauseHookByID(int hookid) = 0;
342 * @brief Unpause a hook by ID.
344 * @return true on success, false otherwise
346 * @param hookid The hook id (returned by AddHook)
348 virtual bool UnpauseHookByID(int hookid) = 0;
351 * @brief Checks whether a plugin has (a) hook manager(s) that is/are currently used by other plugins
353 * @param plug The unique identifier of the plugin in question
356 virtual void SetRes(META_RES res) = 0; //!< Sets the meta result
357 virtual META_RES GetPrevRes() = 0; //!< Gets the meta result of the
358 //!< previously calledhandler
359 virtual META_RES GetStatus() = 0; //!< Gets the highest meta result
360 virtual const void *GetOrigRet() = 0; //!< Gets the original result.
361 //!< If not in post function, undefined
362 virtual const void *GetOverrideRet() = 0; //!< Gets the override result.
363 //!< If none is specified, NULL
364 virtual void *GetIfacePtr() = 0; //!< Gets the interface pointer
366 virtual void *GetOverrideRetPtr() = 0; //!< Used for setting the override return value
369 * @brief Remove a hook manager. Auto-removes all hooks attached to it from plugin plug.
371 * @param plug The owner of the hook manager
372 * @param pubFunc The hook manager's info function
374 virtual void RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc) = 0;
379 * @brief Makes sure that hooks are going to be ignored on the next call of vfnptr
381 * @param plug The unique identifier of the plugin that calls this function
382 * @param vfnptr The virtual function pointer of the function in question
384 virtual void SetIgnoreHooks(void *vfnptr) = 0;
387 * @brief Reverses SetIgnoreHooks' effect
389 * @param plug The unique identifier of the plugin that calls this function
390 * @param vfnptr The virtual function pointer of the function in question
392 virtual void ResetIgnoreHooks(void *vfnptr) = 0;
395 * @brief Finds the original entry of a virtual function pointer
397 * @param vfnptr The virtual function pointer
398 * @return The original entry if the virtual function pointer has been patched; NULL otherwise.
400 virtual void *GetOrigVfnPtrEntry(void *vfnptr) = 0;
402 //////////////////////////////////////////////////////////////////////////
406 // Returns the current iface ptr
407 virtual void DoRecall() = 0; //!< Initiates a recall sequence
413 Users want the ability to change parameters of the called function
414 from inside their handler.
417 2) Recall the function
418 3) => SH's hook func gets called:
419 4) The first iterator points at the first hook the last hookfunc didn't execute yet
420 5) does all iteration and returns normally
421 6) The user's handler returns immediately
422 7) The hook func returns immediately as well
424 Also note that the recalled hookfunc starts with the status the recalling hookfunc
425 ended with. The last handler (doing the recall) is also able to specify its own
430 * @brief Set up the hook loop.
432 * @param statusPtr pointer to status variable
433 * @param prevResPtr pointer to previous result variable
434 * @param curResPtr pointer to current result variable
435 * @param ifacePtrPtr pointer to interface this pointer variable
436 * @param origRetPr pointer to original return value variable. NULL for void funcs
437 * @param overrideRetPtr pointer to override return value variable. NULL for void funcs
439 * @return Override Return Pointer the hookfunc should use (may differ from overrideRetPtr
440 * when the hook func is being called as part of a recall
442 virtual IHookContext *SetupHookLoop(IHookManagerInfo *hi, void *vfnptr, void *thisptr, void **origentry,
443 META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr,
444 const void *origRetPtr, void *overrideRetPtr) = 0;
446 virtual void EndContext(IHookContext *pCtx) = 0;
449 // For META_RESULT_ORIG_RET and META_RESULT_OVERRIDE_RET:
450 // These have to be able to return references. If T is a reference, the pointers returned
451 // from the SH_GLOB_SHPTR are pointers to instances of ReferenceCarrier<T>::type.
452 template <class T> struct MacroRefHelpers
454 inline static const T* GetOrigRet(ISourceHook *shptr)
456 return reinterpret_cast<const T*>(shptr->GetOrigRet());
458 inline static const T* GetOverrideRet(ISourceHook *shptr)
460 return reinterpret_cast<const T*>(shptr->GetOverrideRet());
464 template <class T> struct MacroRefHelpers<T&>
466 inline static T* GetOrigRet(ISourceHook *shptr)
468 T &ref = *reinterpret_cast<const typename ReferenceCarrier<T&>::type *>(shptr->GetOrigRet());
471 inline static T* GetOverrideRet(ISourceHook *shptr)
473 T &ref = *reinterpret_cast<const typename ReferenceCarrier<T&>::type *>(shptr->GetOverrideRet());
478 template <class X, class MFP>
479 void *GetOrigVfnPtrEntry(X *pInstance, MFP mfp, ISourceHook *pSH)
481 SourceHook::MemFuncInfo info = {true, -1, 0, 0};
482 SourceHook::GetFuncInfo(pInstance, mfp, info);
484 void *vfnptr = reinterpret_cast<void*>(
485 *reinterpret_cast<void***>(reinterpret_cast<char*>(pInstance) + info.thisptroffs + info.vtbloffs) + info.vtblindex);
487 void *origentry = pSH->GetOrigVfnPtrEntry(vfnptr);
489 return origentry ? origentry : *reinterpret_cast<void**>(vfnptr);
493 /************************************************************************/
494 /* High level interface */
495 /************************************************************************/
496 #define META_RESULT_STATUS SH_GLOB_SHPTR->GetStatus()
497 #define META_RESULT_PREVIOUS SH_GLOB_SHPTR->GetPrevRes()
498 #define META_RESULT_ORIG_RET(type) *SourceHook::MacroRefHelpers<type>::GetOrigRet(SH_GLOB_SHPTR)
499 #define META_RESULT_OVERRIDE_RET(type) *SourceHook::MacroRefHelpers<type>::GetOverrideRet(SH_GLOB_SHPTR)
500 #define META_IFACEPTR(type) reinterpret_cast<type*>(SH_GLOB_SHPTR->GetIfacePtr())
502 #define SET_META_RESULT(result) SH_GLOB_SHPTR->SetRes(result)
503 #define RETURN_META(result) do { SET_META_RESULT(result); return; } while(0)
504 #define RETURN_META_VALUE(result, value) do { SET_META_RESULT(result); return (value); } while(0)
508 SourceHook::CallClass<T> *SH_GET_CALLCLASS(T *p)
510 return static_cast< SourceHook::CallClass<T> *>(p);
512 #define SH_RELEASE_CALLCLASS(p)
514 #define SH_GET_MCALLCLASS(p, size) reinterpret_cast<void*>(p)
516 // only call these from the hook handlers directly!
518 // If a hook on a function which returns a reference does not want to specify a return value,
519 // it can use this macro.
520 // ONLY USE THIS WITH MRES_IGNORED AND MRES_HANDLED !!!
521 #define RETURN_META_NOREF(result, rettype) do { SET_META_RESULT(result); return reinterpret_cast<rettype>(*SH_GLOB_SHPTR); } while(0)
523 // Why take a memfuncptr instead of iface and func when we have to deduce the iface anyway now?
524 // Well, without it, there'd be no way to specify which overloaded version we want in _VALUE
526 // SourceHook::SetOverrideRet is defined later.
527 #define RETURN_META_NEWPARAMS(result, memfuncptr, newparams) \
529 SET_META_RESULT(result); \
530 SH_GLOB_SHPTR->DoRecall(); \
531 (SourceHook::RecallGetIface(SH_GLOB_SHPTR, memfuncptr)->*(memfuncptr)) newparams; \
532 RETURN_META(MRES_SUPERCEDE); \
535 #define RETURN_META_VALUE_NEWPARAMS(result, value, memfuncptr, newparams) \
537 SET_META_RESULT(result); \
538 SH_GLOB_SHPTR->DoRecall(); \
539 if ((result) >= MRES_OVERRIDE) \
541 /* meh, set the override result here because we don't get a chance to return */ \
542 /* before continuing the hook loop through the recall */ \
543 SourceHook::SetOverrideResult(memfuncptr)(SH_GLOB_SHPTR, value); \
545 RETURN_META_VALUE(MRES_SUPERCEDE, \
546 (SourceHook::RecallGetIface(SH_GLOB_SHPTR, memfuncptr)->*(memfuncptr)) newparams); \
549 // :TODO: thisptroffs in MNEWPARAMS ??
551 #if SH_COMP == SH_COMP_MSVC
553 #define SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname) \
556 SH_MFHCls(hookname)::ECMFP mfp; \
559 SourceHook::EmptyClass *thisptr = reinterpret_cast<SourceHook::EmptyClass*>(SH_GLOB_SHPTR->GetIfacePtr()); \
560 u.addr = (*reinterpret_cast<void***>(reinterpret_cast<char*>(thisptr) + SH_MFHCls(hookname)::ms_MFI.vtbloffs))[ \
561 SH_MFHCls(hookname)::ms_MFI.vtblindex];
563 #elif SH_COMP == SH_COMP_GCC
565 #define SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname) \
568 SH_MFHCls(hookname)::ECMFP mfp; \
575 SourceHook::EmptyClass *thisptr = reinterpret_cast<SourceHook::EmptyClass*>(SH_GLOB_SHPTR->GetIfacePtr()); \
576 u.s.addr = (*reinterpret_cast<void***>(reinterpret_cast<char*>(thisptr) + SH_MFHCls(hookname)::ms_MFI.vtbloffs))[ \
577 SH_MFHCls(hookname)::ms_MFI.vtblindex]; \
582 #define RETURN_META_MNEWPARAMS(result, hookname, newparams) \
584 SET_META_RESULT(result); \
585 SH_GLOB_SHPTR->DoRecall(); \
586 SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname); \
587 (thisptr->*(u.mfp)) newparams; \
588 RETURN_META(MRES_SUPERCEDE); \
591 #define RETURN_META_VALUE_MNEWPARAMS(result, value, hookname, newparams) \
593 SET_META_RESULT(result); \
594 SH_GLOB_SHPTR->DoRecall(); \
595 if ((result) >= MRES_OVERRIDE) \
597 /* see RETURN_META_VALUE_NEWPARAMS */ \
598 SourceHook::SetOverrideResult<SH_MFHCls(hookname)::RetType>(SH_GLOB_SHPTR, value); \
600 SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname); \
601 RETURN_META_VALUE(MRES_SUPERCEDE, (thisptr->*(u.mfp)) newparams); \
605 #define SH_MANUALHOOK_RECONFIGURE(hookname, pvtblindex, pvtbloffs, pthisptroffs) \
607 SH_GLOB_SHPTR->RemoveHookManager(SH_GLOB_PLUGPTR, SH_MFHCls(hookname)::HookManPubFunc); \
608 SH_MFHCls(hookname)::ms_MFI.thisptroffs = pthisptroffs; \
609 SH_MFHCls(hookname)::ms_MFI.vtblindex = pvtblindex; \
610 SH_MFHCls(hookname)::ms_MFI.vtbloffs = pvtbloffs; \
613 #define SH_GET_ORIG_VFNPTR_ENTRY(inst, mfp) (SourceHook::GetOrigVfnPtrEntry(inst, mfp, SH_GLOB_SHPTR))
615 // New ADD / REMOVE macros.
616 #define SH_STATIC(func) fastdelegate::MakeDelegate(func)
617 #define SH_MEMBER(inst, func) fastdelegate::MakeDelegate(inst, func)
619 #define SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
620 __SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
621 SourceHook::ISourceHook::Hook_Normal, post, handler)
623 #define SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
624 __SourceHook_FHRemove##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
627 #define SH_ADD_MANUALHOOK(hookname, ifaceptr, handler, post) \
628 __SourceHook_FHMAdd##hookname(reinterpret_cast<void*>(ifaceptr), \
629 SourceHook::ISourceHook::Hook_Normal, post, handler)
631 #define SH_REMOVE_MANUALHOOK(hookname, ifaceptr, handler, post) \
632 __SourceHook_FHMRemove##hookname(reinterpret_cast<void*>(ifaceptr), post, handler)
634 #define SH_ADD_VPHOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
635 __SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
636 SourceHook::ISourceHook::Hook_VP, post, handler)
638 #define SH_ADD_DVPHOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
639 __SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
640 SourceHook::ISourceHook::Hook_DVP, post, handler)
642 #define SH_ADD_MANUALVPHOOK(hookname, ifaceptr, handler, post) \
643 __SourceHook_FHMAdd##hookname(reinterpret_cast<void*>(ifaceptr), SourceHook::ISourceHook::Hook_VP, post, handler)
645 #define SH_ADD_MANUALDVPHOOK(hookname, ifaceptr, handler, post) \
646 __SourceHook_FHMAdd##hookname(reinterpret_cast<void*>(ifaceptr), SourceHook::ISourceHook::Hook_DVP, post, handler)
648 #define SH_REMOVE_HOOK_ID(hookid) \
649 (SH_GLOB_SHPTR->RemoveHookByID(hookid))
652 // !! These are now deprecated. Instead, use one of these:
653 // SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
654 // SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post)
656 #define SH_ADD_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \
657 SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
658 #define SH_ADD_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \
659 SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
661 // SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
662 // SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post)
664 #define SH_REMOVE_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \
665 SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
666 #define SH_REMOVE_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \
667 SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
669 // SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
670 // SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post)
672 #define SH_ADD_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \
673 SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
674 #define SH_ADD_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \
675 SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
677 // SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
678 // SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post)
680 #define SH_REMOVE_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \
681 SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
682 #define SH_REMOVE_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \
683 SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
690 #if SH_COMP == SH_COMP_MSVC
691 # define SH_SETUP_MFP(mfp) \
692 reinterpret_cast<void**>(&mfp)[0] = vfnptr_origentry;
693 #elif SH_COMP == SH_COMP_GCC
694 # define SH_SETUP_MFP(mfp) \
695 reinterpret_cast<void**>(&mfp)[0] = vfnptr_origentry; \
696 reinterpret_cast<void**>(&mfp)[1] = 0;
698 # error Not supported yet.
701 //////////////////////////////////////////////////////////////////////////
702 #define SH_FHCls(ift, iff, ov) __SourceHook_FHCls_##ift##iff##ov
703 #define SH_MFHCls(hookname) __SourceHook_MFHCls_##hookname
705 #define SHINT_MAKE_HOOKMANPUBFUNC(ifacetype, ifacefunc, overload, funcptr) \
706 static int HookManPubFunc(bool store, ::SourceHook::IHookManagerInfo *hi) \
708 using namespace ::SourceHook; \
709 GetFuncInfo(funcptr, ms_MFI); \
710 /* Verify interface version */ \
711 if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \
713 if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \
719 MemFuncInfo mfi = {true, -1, 0, 0}; \
720 GetFuncInfo(&SH_FHCls(ifacetype,ifacefunc,overload)::Func, mfi); \
721 hi->SetInfo(SH_HOOKMAN_VERSION, ms_MFI.vtbloffs, ms_MFI.vtblindex, &ms_Proto, \
722 reinterpret_cast<void**>(reinterpret_cast<char*>(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex] ); \
727 // It has to be possible to use the macros in namespaces
728 // -> So we need to access and extend the global SourceHook namespace
729 // We use a namespace alias for this
730 #define SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, funcptr) \
731 struct SH_FHCls(ifacetype,ifacefunc,overload) \
733 static SH_FHCls(ifacetype,ifacefunc,overload) ms_Inst; \
734 static ::SourceHook::MemFuncInfo ms_MFI; \
735 static ::SourceHook::IHookManagerInfo *ms_HI; \
736 static ::SourceHook::ProtoInfo ms_Proto; \
737 SHINT_MAKE_HOOKMANPUBFUNC(ifacetype, ifacefunc, overload, funcptr)
739 #define SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, funcptr) \
741 SH_FHCls(ifacetype,ifacefunc,overload) SH_FHCls(ifacetype,ifacefunc,overload)::ms_Inst; \
742 ::SourceHook::MemFuncInfo SH_FHCls(ifacetype,ifacefunc,overload)::ms_MFI; \
743 ::SourceHook::IHookManagerInfo *SH_FHCls(ifacetype,ifacefunc,overload)::ms_HI; \
744 int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
745 SH_FHCls(ifacetype,ifacefunc,overload)::FD handler) \
747 using namespace ::SourceHook; \
748 MemFuncInfo mfi = {true, -1, 0, 0}; \
749 GetFuncInfo(funcptr, mfi); \
750 if (mfi.thisptroffs < 0 || !mfi.isVirtual) \
751 return false; /* No non-virtual functions / virtual inheritance supported */ \
753 return SH_GLOB_SHPTR->AddHook(SH_GLOB_PLUGPTR, mode, \
754 iface, mfi.thisptroffs, SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, \
755 new SH_FHCls(ifacetype,ifacefunc,overload)::CMyDelegateImpl(handler), post); \
757 bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \
758 SH_FHCls(ifacetype,ifacefunc,overload)::FD handler) \
760 using namespace ::SourceHook; \
761 MemFuncInfo mfi = {true, -1, 0, 0}; \
762 GetFuncInfo(funcptr, mfi); \
763 SH_FHCls(ifacetype,ifacefunc,overload)::CMyDelegateImpl tmp(handler); \
764 return SH_GLOB_SHPTR->RemoveHook(SH_GLOB_PLUGPTR, iface, mfi.thisptroffs, \
765 SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, &tmp, post); \
768 #define SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, pvtbloffs, pvtblidx, pthisptroffs) \
769 struct SH_MFHCls(hookname) \
771 static SH_MFHCls(hookname) ms_Inst; \
772 static ::SourceHook::MemFuncInfo ms_MFI; \
773 static ::SourceHook::IHookManagerInfo *ms_HI; \
774 static ::SourceHook::ProtoInfo ms_Proto; \
776 SH_MFHCls(hookname)() \
778 ms_MFI.isVirtual = true; \
779 ms_MFI.thisptroffs = pthisptroffs; \
780 ms_MFI.vtblindex = pvtblidx; \
781 ms_MFI.vtbloffs = pvtbloffs; \
783 static int HookManPubFunc(bool store, ::SourceHook::IHookManagerInfo *hi) \
785 using namespace ::SourceHook; \
786 /* Verify interface version */ \
787 if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \
789 if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \
795 MemFuncInfo mfi = {true, -1, 0, 0}; \
796 GetFuncInfo(&SH_MFHCls(hookname)::Func, mfi); \
797 hi->SetInfo(SH_HOOKMAN_VERSION, ms_MFI.vtbloffs, ms_MFI.vtblindex, &ms_Proto, \
798 reinterpret_cast<void**>(reinterpret_cast<char*>(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex] ); \
803 #define SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, pvtbloffs, pvtblidx, pthisptroffs) \
805 SH_MFHCls(hookname) SH_MFHCls(hookname)::ms_Inst; \
806 ::SourceHook::MemFuncInfo SH_MFHCls(hookname)::ms_MFI; \
807 ::SourceHook::IHookManagerInfo *SH_MFHCls(hookname)::ms_HI; \
808 int __SourceHook_FHMAdd##hookname(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
809 SH_MFHCls(hookname)::FD handler) \
811 return SH_GLOB_SHPTR->AddHook(SH_GLOB_PLUGPTR, mode, \
812 iface, pthisptroffs, SH_MFHCls(hookname)::HookManPubFunc, \
813 new SH_MFHCls(hookname)::CMyDelegateImpl(handler), post); \
815 bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \
816 SH_MFHCls(hookname)::FD handler) \
818 SH_MFHCls(hookname)::CMyDelegateImpl tmp(handler); \
819 return SH_GLOB_SHPTR->RemoveHook(SH_GLOB_PLUGPTR, iface, pthisptroffs, \
820 SH_MFHCls(hookname)::HookManPubFunc, &tmp, post); \
823 #define SH_SETUPCALLS(rettype, paramtypes, params) \
825 using namespace ::SourceHook; \
826 void *ourvfnptr = reinterpret_cast<void*>( \
827 *reinterpret_cast<void***>(reinterpret_cast<char*>(this) + ms_MFI.vtbloffs) + ms_MFI.vtblindex); \
828 void *vfnptr_origentry; \
830 META_RES status = MRES_IGNORED; \
834 typedef ReferenceCarrier<rettype>::type my_rettype; \
835 my_rettype orig_ret; \
836 my_rettype override_ret; \
837 my_rettype plugin_ret; \
839 IHookContext *pContext = SH_GLOB_SHPTR->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast<void*>(this), \
840 &vfnptr_origentry, &status, &prev_res, &cur_res, &orig_ret, &override_ret);
842 #define SH_CALL_HOOKS(post, params) \
843 prev_res = MRES_IGNORED; \
844 while ( (iter = static_cast<IMyDelegate*>(pContext->GetNext())) ) \
846 cur_res = MRES_IGNORED; \
847 plugin_ret = iter->Call params; \
848 prev_res = cur_res; \
849 if (cur_res > status) \
851 if (cur_res >= MRES_OVERRIDE) \
852 *reinterpret_cast<my_rettype*>(pContext->GetOverrideRetPtr()) = plugin_ret; \
855 #define SH_CALL_ORIG(rettype, paramtypes, params) \
856 if (status != MRES_SUPERCEDE && pContext->ShouldCallOrig()) \
858 rettype (EmptyClass::*mfp)paramtypes; \
860 orig_ret = (reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
863 orig_ret = override_ret; /* :TODO: ??? : use pContext->GetOverrideRetPtr() or not? */
865 #define SH_RETURN() \
866 const my_rettype *retptr = reinterpret_cast<const my_rettype*>( \
867 (status >= MRES_OVERRIDE) ? pContext->GetOverrideRetPtr() : pContext->GetOrigRetPtr()); \
868 SH_GLOB_SHPTR->EndContext(pContext); \
871 #define SH_HANDLEFUNC(paramtypes, params, rettype) \
872 SH_SETUPCALLS(rettype, paramtypes, params) \
873 SH_CALL_HOOKS(pre, params) \
874 SH_CALL_ORIG(rettype, paramtypes, params) \
875 SH_CALL_HOOKS(post, params) \
878 //////////////////////////////////////////////////////////////////////////
879 #define SH_SETUPCALLS_void(paramtypes, params) \
881 using namespace ::SourceHook; \
882 void *ourvfnptr = reinterpret_cast<void*>( \
883 *reinterpret_cast<void***>(reinterpret_cast<char*>(this) + ms_MFI.vtbloffs) + ms_MFI.vtblindex); \
884 void *vfnptr_origentry; \
886 META_RES status = MRES_IGNORED; \
891 IHookContext *pContext = SH_GLOB_SHPTR->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast<void*>(this), \
892 &vfnptr_origentry, &status, &prev_res, &cur_res, NULL, NULL);
894 #define SH_CALL_HOOKS_void(post, params) \
895 prev_res = MRES_IGNORED; \
896 while ( (iter = static_cast<IMyDelegate*>(pContext->GetNext())) ) \
898 cur_res = MRES_IGNORED; \
900 prev_res = cur_res; \
901 if (cur_res > status) \
905 #define SH_CALL_ORIG_void(paramtypes, params) \
906 if (status != MRES_SUPERCEDE && pContext->ShouldCallOrig()) \
908 void (EmptyClass::*mfp)paramtypes; \
910 (reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
913 #define SH_RETURN_void() \
914 SH_GLOB_SHPTR->EndContext(pContext);
916 #define SH_HANDLEFUNC_void(paramtypes, params) \
917 SH_SETUPCALLS_void(paramtypes, params) \
918 SH_CALL_HOOKS_void(pre, params) \
919 SH_CALL_ORIG_void(paramtypes, params) \
920 SH_CALL_HOOKS_void(post, params) \
924 // Special vafmt handlers
926 #define SH_HANDLEFUNC_vafmt(paramtypes, params_orig, params_plug, rettype) \
927 SH_SETUPCALLS(rettype, paramtypes, params_orig) \
928 SH_CALL_HOOKS(pre, params_plug) \
929 SH_CALL_ORIG(rettype, paramtypes, params_orig) \
930 SH_CALL_HOOKS(post, params_plug) \
933 #define SH_HANDLEFUNC_void_vafmt(paramtypes, params_orig, params_plug) \
934 SH_SETUPCALLS_void(paramtypes, params_orig) \
935 SH_CALL_HOOKS_void(pre, params_plug) \
936 SH_CALL_ORIG_void(paramtypes, params_orig) \
937 SH_CALL_HOOKS_void(post, params_plug) \
940 //////////////////////////////////////////////////////////////////////////
942 #define MAKE_DELEG(ret_type, params_decl, params_pass) \
943 struct IMyDelegate : ::SourceHook::ISHDelegate { virtual ret_type Call params_decl = 0; }; \
944 struct CMyDelegateImpl : IMyDelegate \
947 CMyDelegateImpl(FD deleg) : m_Deleg(deleg) {} \
948 ret_type Call params_decl { return m_Deleg params_pass; } \
949 void DeleteThis() { delete this; } \
950 bool IsEqual(ISHDelegate *pOtherDeleg) { return m_Deleg == static_cast<CMyDelegateImpl*>(pOtherDeleg)->m_Deleg; } \
953 #define MAKE_DELEG_void(params_decl, params_pass) \
954 struct IMyDelegate : ::SourceHook::ISHDelegate { virtual void Call params_decl = 0; }; \
955 struct CMyDelegateImpl : IMyDelegate \
958 CMyDelegateImpl(FD deleg) : m_Deleg(deleg) {} \
959 void Call params_decl { m_Deleg params_pass; } \
960 void DeleteThis() { delete this; } \
961 bool IsEqual(ISHDelegate *pOtherDeleg) { return m_Deleg == static_cast<CMyDelegateImpl*>(pOtherDeleg)->m_Deleg; } \
965 // sizeof on references returns the size of the datatype, NOT the pointer size or something
966 // -> one should probably flag references in __SourceHook_ParamSizes_* !
967 // or simply assume that their size is sizeof(void*)=SH_PTRSIZE... could be doable through a simple template
970 // ********* Support for 0 arguments *********
971 #define SH_DECL_HOOK0(ifacetype, ifacefunc, attr, overload, rettype) \
972 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)() attr> \
973 (&ifacetype::ifacefunc))) \
974 typedef fastdelegate::FastDelegate0<rettype> FD; \
975 MAKE_DELEG(rettype, (), ()); \
976 virtual rettype Func() \
977 { SH_HANDLEFUNC((), (), rettype); } \
978 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
979 (static_cast<rettype (ifacetype::*)() attr>(&ifacetype::ifacefunc))) \
981 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0} }; \
982 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 0, { sizeof(rettype), 0, 0 }, \
983 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
986 #define SH_DECL_HOOK0_void(ifacetype, ifacefunc, attr, overload) \
987 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)() attr> \
988 (&ifacetype::ifacefunc))) \
989 typedef fastdelegate::FastDelegate0<> FD; \
990 MAKE_DELEG_void((), ()); \
991 virtual void Func() \
992 { SH_HANDLEFUNC_void((), ()); } \
993 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
994 (static_cast<void (ifacetype::*)() attr>(&ifacetype::ifacefunc))) \
996 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0} }; \
997 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 0, { 0, 0, 0 }, \
998 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1000 #define SH_DECL_HOOK0_vafmt(ifacetype, ifacefunc, attr, overload, rettype) \
1001 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(const char *, ...) attr> \
1002 (&ifacetype::ifacefunc))) \
1003 typedef fastdelegate::FastDelegate1<const char *, rettype> FD; \
1004 MAKE_DELEG(rettype, (const char *px), (px)); \
1005 virtual rettype Func( const char *fmt, ...) \
1007 char buf[::SourceHook::STRBUF_LEN]; \
1009 va_start(ap, fmt); \
1010 vsnprintf(buf, sizeof(buf), fmt, ap); \
1012 SH_HANDLEFUNC_vafmt((...), ("%s", buf), (buf), rettype); \
1014 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1015 (static_cast<rettype (ifacetype::*)(const char *, ...) attr>(&ifacetype::ifacefunc))) \
1017 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0} }; \
1018 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 0, { sizeof(rettype), 0, 0 }, \
1019 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1021 #define SH_DECL_HOOK0_void_vafmt(ifacetype, ifacefunc, attr, overload) \
1022 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(const char *, ...) attr> \
1023 (&ifacetype::ifacefunc))) \
1024 typedef fastdelegate::FastDelegate1<const char *> FD; \
1025 MAKE_DELEG_void((const char *px), (px)); \
1026 virtual void Func(const char *fmt, ...) \
1028 char buf[::SourceHook::STRBUF_LEN]; \
1030 va_start(ap, fmt); \
1031 vsnprintf(buf, sizeof(buf), fmt, ap); \
1033 SH_HANDLEFUNC_void_vafmt((...), ("%s", buf), (buf)); \
1035 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1036 (static_cast<void (ifacetype::*)(const char *, ...) attr>(&ifacetype::ifacefunc))) \
1038 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0} }; \
1039 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 0, { 0, 0, 0 }, \
1040 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1042 #define SH_DECL_MANUALHOOK0(hookname, vtblidx, vtbloffs, thisptroffs, rettype) \
1043 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1044 typedef fastdelegate::FastDelegate0<rettype> FD; \
1045 MAKE_DELEG(rettype, (), ()); \
1046 virtual rettype Func() \
1047 { SH_HANDLEFUNC((), (), rettype); } \
1048 typedef rettype(::SourceHook::EmptyClass::*ECMFP)(); \
1049 typedef rettype RetType; \
1050 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1052 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0} }; \
1053 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 0, { sizeof(rettype), 0, 0 }, \
1054 __SourceHook_ParamInfosM_##hookname, 0 };
1056 #define SH_DECL_MANUALHOOK0_void(hookname, vtblidx, vtbloffs, thisptroffs) \
1057 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1058 typedef fastdelegate::FastDelegate0<> FD; \
1059 MAKE_DELEG_void((), ()); \
1060 virtual void Func() \
1061 { SH_HANDLEFUNC_void((), ()); } \
1062 typedef void(::SourceHook::EmptyClass::*ECMFP)(); \
1063 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1065 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0} }; \
1066 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 0, { 0, 0, 0 }, \
1067 __SourceHook_ParamInfosM_##hookname , 0 };
1070 // ********* Support for 1 arguments *********
1071 #define SH_DECL_HOOK1(ifacetype, ifacefunc, attr, overload, rettype, param1) \
1072 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1) attr> \
1073 (&ifacetype::ifacefunc))) \
1074 typedef fastdelegate::FastDelegate1<param1, rettype> FD; \
1075 MAKE_DELEG(rettype, (param1 p1), (p1)); \
1076 virtual rettype Func(param1 p1) \
1077 { SH_HANDLEFUNC((param1), (p1), rettype); } \
1078 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1079 (static_cast<rettype (ifacetype::*)(param1) attr>(&ifacetype::ifacefunc))) \
1081 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0} }; \
1082 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 1, { sizeof(rettype), 0, 0 }, \
1083 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1086 #define SH_DECL_HOOK1_void(ifacetype, ifacefunc, attr, overload, param1) \
1087 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1) attr> \
1088 (&ifacetype::ifacefunc))) \
1089 typedef fastdelegate::FastDelegate1<param1> FD; \
1090 MAKE_DELEG_void((param1 p1), (p1)); \
1091 virtual void Func(param1 p1) \
1092 { SH_HANDLEFUNC_void((param1), (p1)); } \
1093 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1094 (static_cast<void (ifacetype::*)(param1) attr>(&ifacetype::ifacefunc))) \
1096 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0} }; \
1097 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 1, { 0, 0, 0 }, \
1098 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1100 #define SH_DECL_HOOK1_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1) \
1101 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, const char *, ...) attr> \
1102 (&ifacetype::ifacefunc))) \
1103 typedef fastdelegate::FastDelegate2<param1, const char *, rettype> FD; \
1104 MAKE_DELEG(rettype, (param1 p1, const char *px), (p1, px)); \
1105 virtual rettype Func(param1 p1 , const char *fmt, ...) \
1107 char buf[::SourceHook::STRBUF_LEN]; \
1109 va_start(ap, fmt); \
1110 vsnprintf(buf, sizeof(buf), fmt, ap); \
1112 SH_HANDLEFUNC_vafmt((param1, ...), (p1, "%s", buf), (p1, buf), rettype); \
1114 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1115 (static_cast<rettype (ifacetype::*)(param1, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1117 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0} }; \
1118 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 1, { sizeof(rettype), 0, 0 }, \
1119 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1121 #define SH_DECL_HOOK1_void_vafmt(ifacetype, ifacefunc, attr, overload, param1) \
1122 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, const char *, ...) attr> \
1123 (&ifacetype::ifacefunc))) \
1124 typedef fastdelegate::FastDelegate2<param1, const char *> FD; \
1125 MAKE_DELEG_void((param1 p1, const char *px), (p1, px)); \
1126 virtual void Func(param1 p1, const char *fmt, ...) \
1128 char buf[::SourceHook::STRBUF_LEN]; \
1130 va_start(ap, fmt); \
1131 vsnprintf(buf, sizeof(buf), fmt, ap); \
1133 SH_HANDLEFUNC_void_vafmt((param1, ...), (p1, "%s", buf), (p1, buf)); \
1135 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1136 (static_cast<void (ifacetype::*)(param1, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1138 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0} }; \
1139 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 1, { 0, 0, 0 }, \
1140 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1142 #define SH_DECL_MANUALHOOK1(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1) \
1143 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1144 typedef fastdelegate::FastDelegate1<param1, rettype> FD; \
1145 MAKE_DELEG(rettype, (param1 p1), (p1)); \
1146 virtual rettype Func(param1 p1) \
1147 { SH_HANDLEFUNC((param1), (p1), rettype); } \
1148 typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1); \
1149 typedef rettype RetType; \
1150 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1152 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0} }; \
1153 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 1, { sizeof(rettype), 0, 0 }, \
1154 __SourceHook_ParamInfosM_##hookname, 0 };
1156 #define SH_DECL_MANUALHOOK1_void(hookname, vtblidx, vtbloffs, thisptroffs, param1) \
1157 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1158 typedef fastdelegate::FastDelegate1<param1> FD; \
1159 MAKE_DELEG_void((param1 p1), (p1)); \
1160 virtual void Func(param1 p1) \
1161 { SH_HANDLEFUNC_void((param1), (p1)); } \
1162 typedef void(::SourceHook::EmptyClass::*ECMFP)(param1); \
1163 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1165 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0} }; \
1166 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 1, { 0, 0, 0 }, \
1167 __SourceHook_ParamInfosM_##hookname , 0 };
1170 // ********* Support for 2 arguments *********
1171 #define SH_DECL_HOOK2(ifacetype, ifacefunc, attr, overload, rettype, param1, param2) \
1172 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2) attr> \
1173 (&ifacetype::ifacefunc))) \
1174 typedef fastdelegate::FastDelegate2<param1, param2, rettype> FD; \
1175 MAKE_DELEG(rettype, (param1 p1, param2 p2), (p1, p2)); \
1176 virtual rettype Func(param1 p1, param2 p2) \
1177 { SH_HANDLEFUNC((param1, param2), (p1, p2), rettype); } \
1178 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1179 (static_cast<rettype (ifacetype::*)(param1, param2) attr>(&ifacetype::ifacefunc))) \
1181 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0} }; \
1182 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 2, { sizeof(rettype), 0, 0 }, \
1183 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1186 #define SH_DECL_HOOK2_void(ifacetype, ifacefunc, attr, overload, param1, param2) \
1187 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2) attr> \
1188 (&ifacetype::ifacefunc))) \
1189 typedef fastdelegate::FastDelegate2<param1, param2> FD; \
1190 MAKE_DELEG_void((param1 p1, param2 p2), (p1, p2)); \
1191 virtual void Func(param1 p1, param2 p2) \
1192 { SH_HANDLEFUNC_void((param1, param2), (p1, p2)); } \
1193 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1194 (static_cast<void (ifacetype::*)(param1, param2) attr>(&ifacetype::ifacefunc))) \
1196 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0} }; \
1197 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 2, { 0, 0, 0 }, \
1198 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1200 #define SH_DECL_HOOK2_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2) \
1201 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, const char *, ...) attr> \
1202 (&ifacetype::ifacefunc))) \
1203 typedef fastdelegate::FastDelegate3<param1, param2, const char *, rettype> FD; \
1204 MAKE_DELEG(rettype, (param1 p1, param2 p2, const char *px), (p1, p2, px)); \
1205 virtual rettype Func(param1 p1, param2 p2 , const char *fmt, ...) \
1207 char buf[::SourceHook::STRBUF_LEN]; \
1209 va_start(ap, fmt); \
1210 vsnprintf(buf, sizeof(buf), fmt, ap); \
1212 SH_HANDLEFUNC_vafmt((param1, param2, ...), (p1, p2, "%s", buf), (p1, p2, buf), rettype); \
1214 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1215 (static_cast<rettype (ifacetype::*)(param1, param2, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1217 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0} }; \
1218 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 2, { sizeof(rettype), 0, 0 }, \
1219 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1221 #define SH_DECL_HOOK2_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2) \
1222 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, const char *, ...) attr> \
1223 (&ifacetype::ifacefunc))) \
1224 typedef fastdelegate::FastDelegate3<param1, param2, const char *> FD; \
1225 MAKE_DELEG_void((param1 p1, param2 p2, const char *px), (p1, p2, px)); \
1226 virtual void Func(param1 p1, param2 p2, const char *fmt, ...) \
1228 char buf[::SourceHook::STRBUF_LEN]; \
1230 va_start(ap, fmt); \
1231 vsnprintf(buf, sizeof(buf), fmt, ap); \
1233 SH_HANDLEFUNC_void_vafmt((param1, param2, ...), (p1, p2, "%s", buf), (p1, p2, buf)); \
1235 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1236 (static_cast<void (ifacetype::*)(param1, param2, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1238 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0} }; \
1239 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 2, { 0, 0, 0 }, \
1240 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1242 #define SH_DECL_MANUALHOOK2(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2) \
1243 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1244 typedef fastdelegate::FastDelegate2<param1, param2, rettype> FD; \
1245 MAKE_DELEG(rettype, (param1 p1, param2 p2), (p1, p2)); \
1246 virtual rettype Func(param1 p1, param2 p2) \
1247 { SH_HANDLEFUNC((param1, param2), (p1, p2), rettype); } \
1248 typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2); \
1249 typedef rettype RetType; \
1250 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1252 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0} }; \
1253 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 2, { sizeof(rettype), 0, 0 }, \
1254 __SourceHook_ParamInfosM_##hookname, 0 };
1256 #define SH_DECL_MANUALHOOK2_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2) \
1257 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1258 typedef fastdelegate::FastDelegate2<param1, param2> FD; \
1259 MAKE_DELEG_void((param1 p1, param2 p2), (p1, p2)); \
1260 virtual void Func(param1 p1, param2 p2) \
1261 { SH_HANDLEFUNC_void((param1, param2), (p1, p2)); } \
1262 typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2); \
1263 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1265 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0} }; \
1266 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 2, { 0, 0, 0 }, \
1267 __SourceHook_ParamInfosM_##hookname , 0 };
1270 // ********* Support for 3 arguments *********
1271 #define SH_DECL_HOOK3(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3) \
1272 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3) attr> \
1273 (&ifacetype::ifacefunc))) \
1274 typedef fastdelegate::FastDelegate3<param1, param2, param3, rettype> FD; \
1275 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3), (p1, p2, p3)); \
1276 virtual rettype Func(param1 p1, param2 p2, param3 p3) \
1277 { SH_HANDLEFUNC((param1, param2, param3), (p1, p2, p3), rettype); } \
1278 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1279 (static_cast<rettype (ifacetype::*)(param1, param2, param3) attr>(&ifacetype::ifacefunc))) \
1281 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0} }; \
1282 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 3, { sizeof(rettype), 0, 0 }, \
1283 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1286 #define SH_DECL_HOOK3_void(ifacetype, ifacefunc, attr, overload, param1, param2, param3) \
1287 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3) attr> \
1288 (&ifacetype::ifacefunc))) \
1289 typedef fastdelegate::FastDelegate3<param1, param2, param3> FD; \
1290 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3), (p1, p2, p3)); \
1291 virtual void Func(param1 p1, param2 p2, param3 p3) \
1292 { SH_HANDLEFUNC_void((param1, param2, param3), (p1, p2, p3)); } \
1293 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1294 (static_cast<void (ifacetype::*)(param1, param2, param3) attr>(&ifacetype::ifacefunc))) \
1296 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0} }; \
1297 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 3, { 0, 0, 0 }, \
1298 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1300 #define SH_DECL_HOOK3_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3) \
1301 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, const char *, ...) attr> \
1302 (&ifacetype::ifacefunc))) \
1303 typedef fastdelegate::FastDelegate4<param1, param2, param3, const char *, rettype> FD; \
1304 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, const char *px), (p1, p2, p3, px)); \
1305 virtual rettype Func(param1 p1, param2 p2, param3 p3 , const char *fmt, ...) \
1307 char buf[::SourceHook::STRBUF_LEN]; \
1309 va_start(ap, fmt); \
1310 vsnprintf(buf, sizeof(buf), fmt, ap); \
1312 SH_HANDLEFUNC_vafmt((param1, param2, param3, ...), (p1, p2, p3, "%s", buf), (p1, p2, p3, buf), rettype); \
1314 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1315 (static_cast<rettype (ifacetype::*)(param1, param2, param3, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1317 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0} }; \
1318 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 3, { sizeof(rettype), 0, 0 }, \
1319 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1321 #define SH_DECL_HOOK3_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2, param3) \
1322 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, const char *, ...) attr> \
1323 (&ifacetype::ifacefunc))) \
1324 typedef fastdelegate::FastDelegate4<param1, param2, param3, const char *> FD; \
1325 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, const char *px), (p1, p2, p3, px)); \
1326 virtual void Func(param1 p1, param2 p2, param3 p3, const char *fmt, ...) \
1328 char buf[::SourceHook::STRBUF_LEN]; \
1330 va_start(ap, fmt); \
1331 vsnprintf(buf, sizeof(buf), fmt, ap); \
1333 SH_HANDLEFUNC_void_vafmt((param1, param2, param3, ...), (p1, p2, p3, "%s", buf), (p1, p2, p3, buf)); \
1335 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1336 (static_cast<void (ifacetype::*)(param1, param2, param3, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1338 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0} }; \
1339 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 3, { 0, 0, 0 }, \
1340 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1342 #define SH_DECL_MANUALHOOK3(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2, param3) \
1343 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1344 typedef fastdelegate::FastDelegate3<param1, param2, param3, rettype> FD; \
1345 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3), (p1, p2, p3)); \
1346 virtual rettype Func(param1 p1, param2 p2, param3 p3) \
1347 { SH_HANDLEFUNC((param1, param2, param3), (p1, p2, p3), rettype); } \
1348 typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3); \
1349 typedef rettype RetType; \
1350 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1352 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0} }; \
1353 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 3, { sizeof(rettype), 0, 0 }, \
1354 __SourceHook_ParamInfosM_##hookname, 0 };
1356 #define SH_DECL_MANUALHOOK3_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2, param3) \
1357 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1358 typedef fastdelegate::FastDelegate3<param1, param2, param3> FD; \
1359 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3), (p1, p2, p3)); \
1360 virtual void Func(param1 p1, param2 p2, param3 p3) \
1361 { SH_HANDLEFUNC_void((param1, param2, param3), (p1, p2, p3)); } \
1362 typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3); \
1363 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1365 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0} }; \
1366 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 3, { 0, 0, 0 }, \
1367 __SourceHook_ParamInfosM_##hookname , 0 };
1370 // ********* Support for 4 arguments *********
1371 #define SH_DECL_HOOK4(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4) \
1372 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4) attr> \
1373 (&ifacetype::ifacefunc))) \
1374 typedef fastdelegate::FastDelegate4<param1, param2, param3, param4, rettype> FD; \
1375 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4), (p1, p2, p3, p4)); \
1376 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4) \
1377 { SH_HANDLEFUNC((param1, param2, param3, param4), (p1, p2, p3, p4), rettype); } \
1378 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1379 (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4) attr>(&ifacetype::ifacefunc))) \
1381 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0} }; \
1382 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 4, { sizeof(rettype), 0, 0 }, \
1383 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1386 #define SH_DECL_HOOK4_void(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4) \
1387 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4) attr> \
1388 (&ifacetype::ifacefunc))) \
1389 typedef fastdelegate::FastDelegate4<param1, param2, param3, param4> FD; \
1390 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4), (p1, p2, p3, p4)); \
1391 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4) \
1392 { SH_HANDLEFUNC_void((param1, param2, param3, param4), (p1, p2, p3, p4)); } \
1393 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1394 (static_cast<void (ifacetype::*)(param1, param2, param3, param4) attr>(&ifacetype::ifacefunc))) \
1396 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0} }; \
1397 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 4, { 0, 0, 0 }, \
1398 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1400 #define SH_DECL_HOOK4_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4) \
1401 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, const char *, ...) attr> \
1402 (&ifacetype::ifacefunc))) \
1403 typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, const char *, rettype> FD; \
1404 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4, const char *px), (p1, p2, p3, p4, px)); \
1405 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4 , const char *fmt, ...) \
1407 char buf[::SourceHook::STRBUF_LEN]; \
1409 va_start(ap, fmt); \
1410 vsnprintf(buf, sizeof(buf), fmt, ap); \
1412 SH_HANDLEFUNC_vafmt((param1, param2, param3, param4, ...), (p1, p2, p3, p4, "%s", buf), (p1, p2, p3, p4, buf), rettype); \
1414 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1415 (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1417 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0} }; \
1418 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 4, { sizeof(rettype), 0, 0 }, \
1419 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1421 #define SH_DECL_HOOK4_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4) \
1422 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, const char *, ...) attr> \
1423 (&ifacetype::ifacefunc))) \
1424 typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, const char *> FD; \
1425 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4, const char *px), (p1, p2, p3, p4, px)); \
1426 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, const char *fmt, ...) \
1428 char buf[::SourceHook::STRBUF_LEN]; \
1430 va_start(ap, fmt); \
1431 vsnprintf(buf, sizeof(buf), fmt, ap); \
1433 SH_HANDLEFUNC_void_vafmt((param1, param2, param3, param4, ...), (p1, p2, p3, p4, "%s", buf), (p1, p2, p3, p4, buf)); \
1435 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1436 (static_cast<void (ifacetype::*)(param1, param2, param3, param4, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1438 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0} }; \
1439 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 4, { 0, 0, 0 }, \
1440 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1442 #define SH_DECL_MANUALHOOK4(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2, param3, param4) \
1443 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1444 typedef fastdelegate::FastDelegate4<param1, param2, param3, param4, rettype> FD; \
1445 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4), (p1, p2, p3, p4)); \
1446 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4) \
1447 { SH_HANDLEFUNC((param1, param2, param3, param4), (p1, p2, p3, p4), rettype); } \
1448 typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4); \
1449 typedef rettype RetType; \
1450 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1452 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0} }; \
1453 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 4, { sizeof(rettype), 0, 0 }, \
1454 __SourceHook_ParamInfosM_##hookname, 0 };
1456 #define SH_DECL_MANUALHOOK4_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2, param3, param4) \
1457 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1458 typedef fastdelegate::FastDelegate4<param1, param2, param3, param4> FD; \
1459 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4), (p1, p2, p3, p4)); \
1460 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4) \
1461 { SH_HANDLEFUNC_void((param1, param2, param3, param4), (p1, p2, p3, p4)); } \
1462 typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4); \
1463 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1465 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0} }; \
1466 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 4, { 0, 0, 0 }, \
1467 __SourceHook_ParamInfosM_##hookname , 0 };
1470 // ********* Support for 5 arguments *********
1471 #define SH_DECL_HOOK5(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5) \
1472 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5) attr> \
1473 (&ifacetype::ifacefunc))) \
1474 typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, param5, rettype> FD; \
1475 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4, param5 p5), (p1, p2, p3, p4, p5)); \
1476 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \
1477 { SH_HANDLEFUNC((param1, param2, param3, param4, param5), (p1, p2, p3, p4, p5), rettype); } \
1478 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1479 (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5) attr>(&ifacetype::ifacefunc))) \
1481 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0} }; \
1482 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 5, { sizeof(rettype), 0, 0 }, \
1483 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1486 #define SH_DECL_HOOK5_void(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5) \
1487 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5) attr> \
1488 (&ifacetype::ifacefunc))) \
1489 typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, param5> FD; \
1490 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4, param5 p5), (p1, p2, p3, p4, p5)); \
1491 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \
1492 { SH_HANDLEFUNC_void((param1, param2, param3, param4, param5), (p1, p2, p3, p4, p5)); } \
1493 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1494 (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5) attr>(&ifacetype::ifacefunc))) \
1496 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0} }; \
1497 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 5, { 0, 0, 0 }, \
1498 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1500 #define SH_DECL_HOOK5_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5) \
1501 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, const char *, ...) attr> \
1502 (&ifacetype::ifacefunc))) \
1503 typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, const char *, rettype> FD; \
1504 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, const char *px), (p1, p2, p3, p4, p5, px)); \
1505 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5 , const char *fmt, ...) \
1507 char buf[::SourceHook::STRBUF_LEN]; \
1509 va_start(ap, fmt); \
1510 vsnprintf(buf, sizeof(buf), fmt, ap); \
1512 SH_HANDLEFUNC_vafmt((param1, param2, param3, param4, param5, ...), (p1, p2, p3, p4, p5, "%s", buf), (p1, p2, p3, p4, p5, buf), rettype); \
1514 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1515 (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1517 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0} }; \
1518 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 5, { sizeof(rettype), 0, 0 }, \
1519 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1521 #define SH_DECL_HOOK5_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5) \
1522 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, const char *, ...) attr> \
1523 (&ifacetype::ifacefunc))) \
1524 typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, const char *> FD; \
1525 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, const char *px), (p1, p2, p3, p4, p5, px)); \
1526 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, const char *fmt, ...) \
1528 char buf[::SourceHook::STRBUF_LEN]; \
1530 va_start(ap, fmt); \
1531 vsnprintf(buf, sizeof(buf), fmt, ap); \
1533 SH_HANDLEFUNC_void_vafmt((param1, param2, param3, param4, param5, ...), (p1, p2, p3, p4, p5, "%s", buf), (p1, p2, p3, p4, p5, buf)); \
1535 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1536 (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1538 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0} }; \
1539 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 5, { 0, 0, 0 }, \
1540 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1542 #define SH_DECL_MANUALHOOK5(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2, param3, param4, param5) \
1543 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1544 typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, param5, rettype> FD; \
1545 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4, param5 p5), (p1, p2, p3, p4, p5)); \
1546 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \
1547 { SH_HANDLEFUNC((param1, param2, param3, param4, param5), (p1, p2, p3, p4, p5), rettype); } \
1548 typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5); \
1549 typedef rettype RetType; \
1550 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1552 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0} }; \
1553 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 5, { sizeof(rettype), 0, 0 }, \
1554 __SourceHook_ParamInfosM_##hookname, 0 };
1556 #define SH_DECL_MANUALHOOK5_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2, param3, param4, param5) \
1557 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1558 typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, param5> FD; \
1559 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4, param5 p5), (p1, p2, p3, p4, p5)); \
1560 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \
1561 { SH_HANDLEFUNC_void((param1, param2, param3, param4, param5), (p1, p2, p3, p4, p5)); } \
1562 typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5); \
1563 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1565 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0} }; \
1566 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 5, { 0, 0, 0 }, \
1567 __SourceHook_ParamInfosM_##hookname , 0 };
1570 // ********* Support for 6 arguments *********
1571 #define SH_DECL_HOOK6(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5, param6) \
1572 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6) attr> \
1573 (&ifacetype::ifacefunc))) \
1574 typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, param6, rettype> FD; \
1575 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6), (p1, p2, p3, p4, p5, p6)); \
1576 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \
1577 { SH_HANDLEFUNC((param1, param2, param3, param4, param5, param6), (p1, p2, p3, p4, p5, p6), rettype); } \
1578 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1579 (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6) attr>(&ifacetype::ifacefunc))) \
1581 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0} }; \
1582 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 6, { sizeof(rettype), 0, 0 }, \
1583 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1586 #define SH_DECL_HOOK6_void(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5, param6) \
1587 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6) attr> \
1588 (&ifacetype::ifacefunc))) \
1589 typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, param6> FD; \
1590 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6), (p1, p2, p3, p4, p5, p6)); \
1591 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \
1592 { SH_HANDLEFUNC_void((param1, param2, param3, param4, param5, param6), (p1, p2, p3, p4, p5, p6)); } \
1593 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1594 (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6) attr>(&ifacetype::ifacefunc))) \
1596 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0} }; \
1597 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 6, { 0, 0, 0 }, \
1598 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1600 #define SH_DECL_HOOK6_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5, param6) \
1601 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, const char *, ...) attr> \
1602 (&ifacetype::ifacefunc))) \
1603 typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, const char *, rettype> FD; \
1604 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, const char *px), (p1, p2, p3, p4, p5, p6, px)); \
1605 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6 , const char *fmt, ...) \
1607 char buf[::SourceHook::STRBUF_LEN]; \
1609 va_start(ap, fmt); \
1610 vsnprintf(buf, sizeof(buf), fmt, ap); \
1612 SH_HANDLEFUNC_vafmt((param1, param2, param3, param4, param5, param6, ...), (p1, p2, p3, p4, p5, p6, "%s", buf), (p1, p2, p3, p4, p5, p6, buf), rettype); \
1614 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1615 (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1617 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0} }; \
1618 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 6, { sizeof(rettype), 0, 0 }, \
1619 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1621 #define SH_DECL_HOOK6_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5, param6) \
1622 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, const char *, ...) attr> \
1623 (&ifacetype::ifacefunc))) \
1624 typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, const char *> FD; \
1625 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, const char *px), (p1, p2, p3, p4, p5, p6, px)); \
1626 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, const char *fmt, ...) \
1628 char buf[::SourceHook::STRBUF_LEN]; \
1630 va_start(ap, fmt); \
1631 vsnprintf(buf, sizeof(buf), fmt, ap); \
1633 SH_HANDLEFUNC_void_vafmt((param1, param2, param3, param4, param5, param6, ...), (p1, p2, p3, p4, p5, p6, "%s", buf), (p1, p2, p3, p4, p5, p6, buf)); \
1635 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1636 (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1638 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0} }; \
1639 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 6, { 0, 0, 0 }, \
1640 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1642 #define SH_DECL_MANUALHOOK6(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2, param3, param4, param5, param6) \
1643 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1644 typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, param6, rettype> FD; \
1645 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6), (p1, p2, p3, p4, p5, p6)); \
1646 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \
1647 { SH_HANDLEFUNC((param1, param2, param3, param4, param5, param6), (p1, p2, p3, p4, p5, p6), rettype); } \
1648 typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5, param6); \
1649 typedef rettype RetType; \
1650 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1652 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0} }; \
1653 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 6, { sizeof(rettype), 0, 0 }, \
1654 __SourceHook_ParamInfosM_##hookname, 0 };
1656 #define SH_DECL_MANUALHOOK6_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2, param3, param4, param5, param6) \
1657 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1658 typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, param6> FD; \
1659 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6), (p1, p2, p3, p4, p5, p6)); \
1660 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \
1661 { SH_HANDLEFUNC_void((param1, param2, param3, param4, param5, param6), (p1, p2, p3, p4, p5, p6)); } \
1662 typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5, param6); \
1663 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1665 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0} }; \
1666 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 6, { 0, 0, 0 }, \
1667 __SourceHook_ParamInfosM_##hookname , 0 };
1670 // ********* Support for 7 arguments *********
1671 #define SH_DECL_HOOK7(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5, param6, param7) \
1672 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7) attr> \
1673 (&ifacetype::ifacefunc))) \
1674 typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, param7, rettype> FD; \
1675 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7), (p1, p2, p3, p4, p5, p6, p7)); \
1676 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7) \
1677 { SH_HANDLEFUNC((param1, param2, param3, param4, param5, param6, param7), (p1, p2, p3, p4, p5, p6, p7), rettype); } \
1678 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1679 (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7) attr>(&ifacetype::ifacefunc))) \
1681 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0}, {sizeof(param7), 0, 0} }; \
1682 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 7, { sizeof(rettype), 0, 0 }, \
1683 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1686 #define SH_DECL_HOOK7_void(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5, param6, param7) \
1687 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7) attr> \
1688 (&ifacetype::ifacefunc))) \
1689 typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, param7> FD; \
1690 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7), (p1, p2, p3, p4, p5, p6, p7)); \
1691 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7) \
1692 { SH_HANDLEFUNC_void((param1, param2, param3, param4, param5, param6, param7), (p1, p2, p3, p4, p5, p6, p7)); } \
1693 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1694 (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7) attr>(&ifacetype::ifacefunc))) \
1696 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0}, {sizeof(param7), 0, 0} }; \
1697 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 7, { 0, 0, 0 }, \
1698 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1700 #define SH_DECL_HOOK7_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5, param6, param7) \
1701 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7, const char *, ...) attr> \
1702 (&ifacetype::ifacefunc))) \
1703 typedef fastdelegate::FastDelegate8<param1, param2, param3, param4, param5, param6, param7, const char *, rettype> FD; \
1704 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7, const char *px), (p1, p2, p3, p4, p5, p6, p7, px)); \
1705 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7 , const char *fmt, ...) \
1707 char buf[::SourceHook::STRBUF_LEN]; \
1709 va_start(ap, fmt); \
1710 vsnprintf(buf, sizeof(buf), fmt, ap); \
1712 SH_HANDLEFUNC_vafmt((param1, param2, param3, param4, param5, param6, param7, ...), (p1, p2, p3, p4, p5, p6, p7, "%s", buf), (p1, p2, p3, p4, p5, p6, p7, buf), rettype); \
1714 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1715 (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1717 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0}, {sizeof(param7), 0, 0} }; \
1718 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 7, { sizeof(rettype), 0, 0 }, \
1719 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1721 #define SH_DECL_HOOK7_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5, param6, param7) \
1722 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7, const char *, ...) attr> \
1723 (&ifacetype::ifacefunc))) \
1724 typedef fastdelegate::FastDelegate8<param1, param2, param3, param4, param5, param6, param7, const char *> FD; \
1725 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7, const char *px), (p1, p2, p3, p4, p5, p6, p7, px)); \
1726 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7, const char *fmt, ...) \
1728 char buf[::SourceHook::STRBUF_LEN]; \
1730 va_start(ap, fmt); \
1731 vsnprintf(buf, sizeof(buf), fmt, ap); \
1733 SH_HANDLEFUNC_void_vafmt((param1, param2, param3, param4, param5, param6, param7, ...), (p1, p2, p3, p4, p5, p6, p7, "%s", buf), (p1, p2, p3, p4, p5, p6, p7, buf)); \
1735 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1736 (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7, const char *, ...) attr>(&ifacetype::ifacefunc))) \
1738 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0}, {sizeof(param7), 0, 0} }; \
1739 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { 7, { 0, 0, 0 }, \
1740 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0 };
1742 #define SH_DECL_MANUALHOOK7(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2, param3, param4, param5, param6, param7) \
1743 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1744 typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, param7, rettype> FD; \
1745 MAKE_DELEG(rettype, (param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7), (p1, p2, p3, p4, p5, p6, p7)); \
1746 virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7) \
1747 { SH_HANDLEFUNC((param1, param2, param3, param4, param5, param6, param7), (p1, p2, p3, p4, p5, p6, p7), rettype); } \
1748 typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5, param6, param7); \
1749 typedef rettype RetType; \
1750 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1752 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0}, {sizeof(param7), 0, 0} }; \
1753 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 7, { sizeof(rettype), 0, 0 }, \
1754 __SourceHook_ParamInfosM_##hookname, 0 };
1756 #define SH_DECL_MANUALHOOK7_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2, param3, param4, param5, param6, param7) \
1757 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1758 typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, param7> FD; \
1759 MAKE_DELEG_void((param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7), (p1, p2, p3, p4, p5, p6, p7)); \
1760 virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7) \
1761 { SH_HANDLEFUNC_void((param1, param2, param3, param4, param5, param6, param7), (p1, p2, p3, p4, p5, p6, p7)); } \
1762 typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5, param6, param7); \
1763 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1765 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {0, 0, 0}, {sizeof(param1), 0, 0}, {sizeof(param2), 0, 0}, {sizeof(param3), 0, 0}, {sizeof(param4), 0, 0}, {sizeof(param5), 0, 0}, {sizeof(param6), 0, 0}, {sizeof(param7), 0, 0} }; \
1766 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { 7, { 0, 0, 0 }, \
1767 __SourceHook_ParamInfosM_##hookname , 0 };
1772 //////////////////////////////////////////////////////////////////////////
1775 #define SH_MAKE_EXECUTABLECLASS_OB(call, prms) \
1777 using namespace ::SourceHook; \
1779 m_pSH->SetIgnoreHooks(m_VfnPtr); \
1780 RetType tmpret = (m_ThisPtr->*m_MFP)call; \
1781 m_pSH->ResetIgnoreHooks(m_VfnPtr); \
1785 #define SH_MAKE_EXECUTABLECLASS_OB_void(call, prms) \
1787 using namespace ::SourceHook; \
1789 m_pSH->SetIgnoreHooks(m_VfnPtr); \
1790 (m_ThisPtr->*m_MFP)call; \
1791 m_pSH->ResetIgnoreHooks(m_VfnPtr); \
1794 namespace SourceHook
1797 // Support for 0 arguments
1798 template<class ObjType, class MFPType, class RetType> class ExecutableClass0
1805 ExecutableClass0(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
1806 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
1808 RetType operator()() const
1809 SH_MAKE_EXECUTABLECLASS_OB((), ())
1812 template <class Param1> RetType operator()(Param1 p1) const
1813 SH_MAKE_EXECUTABLECLASS_OB((p1), (Param1))
1815 template <class Param1, class Param2> RetType operator()(Param1 p1, Param2 p2) const
1816 SH_MAKE_EXECUTABLECLASS_OB((p1, p2), (Param1, Param2))
1818 template <class Param1, class Param2, class Param3> RetType operator()(Param1 p1, Param2 p2, Param3 p3) const
1819 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3), (Param1, Param2, Param3))
1821 template <class Param1, class Param2, class Param3, class Param4> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
1822 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
1824 template <class Param1, class Param2, class Param3, class Param4, class Param5> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
1825 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
1827 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
1828 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
1830 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
1831 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
1835 template<class ObjType, class MFPType> class ExecutableClass0<ObjType, MFPType, void>
1842 ExecutableClass0(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
1843 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
1845 void operator()() const
1846 SH_MAKE_EXECUTABLECLASS_OB_void((), ())
1849 template <class Param1> void operator()(Param1 p1) const
1850 SH_MAKE_EXECUTABLECLASS_OB_void((p1), (Param1))
1852 template <class Param1, class Param2> void operator()(Param1 p1, Param2 p2) const
1853 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2), (Param1, Param2))
1855 template <class Param1, class Param2, class Param3> void operator()(Param1 p1, Param2 p2, Param3 p3) const
1856 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3), (Param1, Param2, Param3))
1858 template <class Param1, class Param2, class Param3, class Param4> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
1859 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
1861 template <class Param1, class Param2, class Param3, class Param4, class Param5> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
1862 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
1864 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
1865 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
1867 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
1868 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
1872 // Support for 1 arguments
1873 template<class ObjType, class MFPType, class RetType, class Param1> class ExecutableClass1
1880 ExecutableClass1(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
1881 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
1883 RetType operator()(Param1 p1) const
1884 SH_MAKE_EXECUTABLECLASS_OB((p1), (Param1))
1887 template <class Param2> RetType operator()(Param1 p1, Param2 p2) const
1888 SH_MAKE_EXECUTABLECLASS_OB((p1, p2), (Param1, Param2))
1890 template <class Param2, class Param3> RetType operator()(Param1 p1, Param2 p2, Param3 p3) const
1891 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3), (Param1, Param2, Param3))
1893 template <class Param2, class Param3, class Param4> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
1894 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
1896 template <class Param2, class Param3, class Param4, class Param5> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
1897 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
1899 template <class Param2, class Param3, class Param4, class Param5, class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
1900 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
1902 template <class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
1903 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
1907 template<class ObjType, class MFPType, class Param1> class ExecutableClass1<ObjType, MFPType, void, Param1>
1914 ExecutableClass1(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
1915 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
1917 void operator()(Param1 p1) const
1918 SH_MAKE_EXECUTABLECLASS_OB_void((p1), (Param1))
1921 template <class Param2> void operator()(Param1 p1, Param2 p2) const
1922 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2), (Param1, Param2))
1924 template <class Param2, class Param3> void operator()(Param1 p1, Param2 p2, Param3 p3) const
1925 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3), (Param1, Param2, Param3))
1927 template <class Param2, class Param3, class Param4> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
1928 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
1930 template <class Param2, class Param3, class Param4, class Param5> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
1931 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
1933 template <class Param2, class Param3, class Param4, class Param5, class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
1934 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
1936 template <class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
1937 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
1941 // Support for 2 arguments
1942 template<class ObjType, class MFPType, class RetType, class Param1, class Param2> class ExecutableClass2
1949 ExecutableClass2(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
1950 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
1952 RetType operator()(Param1 p1, Param2 p2) const
1953 SH_MAKE_EXECUTABLECLASS_OB((p1, p2), (Param1, Param2))
1956 template <class Param3> RetType operator()(Param1 p1, Param2 p2, Param3 p3) const
1957 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3), (Param1, Param2, Param3))
1959 template <class Param3, class Param4> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
1960 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
1962 template <class Param3, class Param4, class Param5> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
1963 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
1965 template <class Param3, class Param4, class Param5, class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
1966 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
1968 template <class Param3, class Param4, class Param5, class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
1969 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
1973 template<class ObjType, class MFPType, class Param1, class Param2> class ExecutableClass2<ObjType, MFPType, void, Param1, Param2>
1980 ExecutableClass2(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
1981 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
1983 void operator()(Param1 p1, Param2 p2) const
1984 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2), (Param1, Param2))
1987 template <class Param3> void operator()(Param1 p1, Param2 p2, Param3 p3) const
1988 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3), (Param1, Param2, Param3))
1990 template <class Param3, class Param4> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
1991 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
1993 template <class Param3, class Param4, class Param5> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
1994 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
1996 template <class Param3, class Param4, class Param5, class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
1997 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
1999 template <class Param3, class Param4, class Param5, class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
2000 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2004 // Support for 3 arguments
2005 template<class ObjType, class MFPType, class RetType, class Param1, class Param2, class Param3> class ExecutableClass3
2012 ExecutableClass3(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
2013 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
2015 RetType operator()(Param1 p1, Param2 p2, Param3 p3) const
2016 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3), (Param1, Param2, Param3))
2019 template <class Param4> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
2020 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
2022 template <class Param4, class Param5> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
2023 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
2025 template <class Param4, class Param5, class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
2026 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
2028 template <class Param4, class Param5, class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
2029 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2033 template<class ObjType, class MFPType, class Param1, class Param2, class Param3> class ExecutableClass3<ObjType, MFPType, void, Param1, Param2, Param3>
2040 ExecutableClass3(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
2041 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
2043 void operator()(Param1 p1, Param2 p2, Param3 p3) const
2044 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3), (Param1, Param2, Param3))
2047 template <class Param4> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
2048 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
2050 template <class Param4, class Param5> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
2051 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
2053 template <class Param4, class Param5, class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
2054 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
2056 template <class Param4, class Param5, class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
2057 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2061 // Support for 4 arguments
2062 template<class ObjType, class MFPType, class RetType, class Param1, class Param2, class Param3, class Param4> class ExecutableClass4
2069 ExecutableClass4(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
2070 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
2072 RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
2073 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
2076 template <class Param5> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
2077 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
2079 template <class Param5, class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
2080 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
2082 template <class Param5, class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
2083 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2087 template<class ObjType, class MFPType, class Param1, class Param2, class Param3, class Param4> class ExecutableClass4<ObjType, MFPType, void, Param1, Param2, Param3, Param4>
2094 ExecutableClass4(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
2095 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
2097 void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
2098 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
2101 template <class Param5> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
2102 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
2104 template <class Param5, class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
2105 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
2107 template <class Param5, class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
2108 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2112 // Support for 5 arguments
2113 template<class ObjType, class MFPType, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5> class ExecutableClass5
2120 ExecutableClass5(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
2121 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
2123 RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
2124 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
2127 template <class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
2128 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
2130 template <class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
2131 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2135 template<class ObjType, class MFPType, class Param1, class Param2, class Param3, class Param4, class Param5> class ExecutableClass5<ObjType, MFPType, void, Param1, Param2, Param3, Param4, Param5>
2142 ExecutableClass5(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
2143 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
2145 void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
2146 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
2149 template <class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
2150 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
2152 template <class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
2153 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2157 // Support for 6 arguments
2158 template<class ObjType, class MFPType, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6> class ExecutableClass6
2165 ExecutableClass6(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
2166 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
2168 RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
2169 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
2172 template <class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
2173 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2177 template<class ObjType, class MFPType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6> class ExecutableClass6<ObjType, MFPType, void, Param1, Param2, Param3, Param4, Param5, Param6>
2184 ExecutableClass6(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
2185 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
2187 void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
2188 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
2191 template <class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
2192 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2196 // Support for 7 arguments
2197 template<class ObjType, class MFPType, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> class ExecutableClass7
2204 ExecutableClass7(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
2205 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
2207 RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
2208 SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2213 template<class ObjType, class MFPType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> class ExecutableClass7<ObjType, MFPType, void, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
2220 ExecutableClass7(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
2221 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
2223 void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
2224 SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2232 #define SH__CALL_GET_VFNPTR_NORMAL \
2233 using namespace ::SourceHook; \
2234 MemFuncInfo mfi = {true, -1, 0, 0}; \
2235 GetFuncInfo(ptr, mfp, mfi); \
2236 void *vfnptr = reinterpret_cast<void*>( \
2237 *reinterpret_cast<void***>(reinterpret_cast<char*>(ptr) + mfi.thisptroffs + mfi.vtbloffs) + mfi.vtblindex);
2239 #define SH__CALL_GET_VFNPTR_MANUAL \
2240 using namespace ::SourceHook; \
2241 void *vfnptr = reinterpret_cast<void*>( \
2242 *reinterpret_cast<void***>( (reinterpret_cast<char*>(ptr) + thisptroffs + vtbloffs) ) + vtblidx); \
2244 *reinterpret_cast<void**>(&mfp) = *reinterpret_cast<void**>(vfnptr);
2246 // SH_CALL needs to deduce the return type -> it uses templates and function overloading
2247 // That's why SH_CALL takes two parameters: "mfp2" of type RetType(X::*mfp)(params), and "mfp" of type MFP
2248 // The only purpose of the mfp2 parameter is to extract the return type
2251 // Support for 0 arguments
2252 template <class X, class Y, class MFP, class RetType>
2253 SourceHook::ExecutableClass0<Y, MFP, RetType>
2254 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(), SourceHook::ISourceHook *shptr)
2256 SH__CALL_GET_VFNPTR_NORMAL
2257 return SourceHook::ExecutableClass0<Y, MFP, RetType>(ptr, mfp, vfnptr, shptr);
2260 template <class X, class Y, class MFP, class RetType>
2261 SourceHook::ExecutableClass0<Y, MFP, RetType>
2262 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)()const, SourceHook::ISourceHook *shptr)
2264 SH__CALL_GET_VFNPTR_NORMAL
2265 return SourceHook::ExecutableClass0<Y, MFP, RetType>(ptr, mfp, vfnptr, shptr);
2268 template <class X, class Y, class MFP, class RetType>
2269 SourceHook::ExecutableClass0<SourceHook::EmptyClass, MFP, RetType>
2270 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr)
2272 SH__CALL_GET_VFNPTR_MANUAL
2273 return SourceHook::ExecutableClass0<EmptyClass, MFP, RetType>(
2274 reinterpret_cast<SourceHook::EmptyClass*>(ptr), mfp, vfnptr, shptr);
2277 // Support for 1 arguments
2278 template <class X, class Y, class MFP, class RetType, class Param1>
2279 SourceHook::ExecutableClass1<Y, MFP, RetType, Param1>
2280 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1), SourceHook::ISourceHook *shptr)
2282 SH__CALL_GET_VFNPTR_NORMAL
2283 return SourceHook::ExecutableClass1<Y, MFP, RetType, Param1>(ptr, mfp, vfnptr, shptr);
2286 template <class X, class Y, class MFP, class RetType, class Param1>
2287 SourceHook::ExecutableClass1<Y, MFP, RetType, Param1>
2288 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1)const, SourceHook::ISourceHook *shptr)
2290 SH__CALL_GET_VFNPTR_NORMAL
2291 return SourceHook::ExecutableClass1<Y, MFP, RetType, Param1>(ptr, mfp, vfnptr, shptr);
2294 template <class X, class Y, class MFP, class RetType, class Param1>
2295 SourceHook::ExecutableClass1<SourceHook::EmptyClass, MFP, RetType, Param1>
2296 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr)
2298 SH__CALL_GET_VFNPTR_MANUAL
2299 return SourceHook::ExecutableClass1<EmptyClass, MFP, RetType, Param1>(
2300 reinterpret_cast<SourceHook::EmptyClass*>(ptr), mfp, vfnptr, shptr);
2303 // Support for 2 arguments
2304 template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
2305 SourceHook::ExecutableClass2<Y, MFP, RetType, Param1, Param2>
2306 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2), SourceHook::ISourceHook *shptr)
2308 SH__CALL_GET_VFNPTR_NORMAL
2309 return SourceHook::ExecutableClass2<Y, MFP, RetType, Param1, Param2>(ptr, mfp, vfnptr, shptr);
2312 template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
2313 SourceHook::ExecutableClass2<Y, MFP, RetType, Param1, Param2>
2314 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2)const, SourceHook::ISourceHook *shptr)
2316 SH__CALL_GET_VFNPTR_NORMAL
2317 return SourceHook::ExecutableClass2<Y, MFP, RetType, Param1, Param2>(ptr, mfp, vfnptr, shptr);
2320 template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
2321 SourceHook::ExecutableClass2<SourceHook::EmptyClass, MFP, RetType, Param1, Param2>
2322 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr)
2324 SH__CALL_GET_VFNPTR_MANUAL
2325 return SourceHook::ExecutableClass2<EmptyClass, MFP, RetType, Param1, Param2>(
2326 reinterpret_cast<SourceHook::EmptyClass*>(ptr), mfp, vfnptr, shptr);
2329 // Support for 3 arguments
2330 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
2331 SourceHook::ExecutableClass3<Y, MFP, RetType, Param1, Param2, Param3>
2332 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3), SourceHook::ISourceHook *shptr)
2334 SH__CALL_GET_VFNPTR_NORMAL
2335 return SourceHook::ExecutableClass3<Y, MFP, RetType, Param1, Param2, Param3>(ptr, mfp, vfnptr, shptr);
2338 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
2339 SourceHook::ExecutableClass3<Y, MFP, RetType, Param1, Param2, Param3>
2340 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3)const, SourceHook::ISourceHook *shptr)
2342 SH__CALL_GET_VFNPTR_NORMAL
2343 return SourceHook::ExecutableClass3<Y, MFP, RetType, Param1, Param2, Param3>(ptr, mfp, vfnptr, shptr);
2346 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
2347 SourceHook::ExecutableClass3<SourceHook::EmptyClass, MFP, RetType, Param1, Param2, Param3>
2348 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr)
2350 SH__CALL_GET_VFNPTR_MANUAL
2351 return SourceHook::ExecutableClass3<EmptyClass, MFP, RetType, Param1, Param2, Param3>(
2352 reinterpret_cast<SourceHook::EmptyClass*>(ptr), mfp, vfnptr, shptr);
2355 // Support for 4 arguments
2356 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
2357 SourceHook::ExecutableClass4<Y, MFP, RetType, Param1, Param2, Param3, Param4>
2358 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4), SourceHook::ISourceHook *shptr)
2360 SH__CALL_GET_VFNPTR_NORMAL
2361 return SourceHook::ExecutableClass4<Y, MFP, RetType, Param1, Param2, Param3, Param4>(ptr, mfp, vfnptr, shptr);
2364 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
2365 SourceHook::ExecutableClass4<Y, MFP, RetType, Param1, Param2, Param3, Param4>
2366 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4)const, SourceHook::ISourceHook *shptr)
2368 SH__CALL_GET_VFNPTR_NORMAL
2369 return SourceHook::ExecutableClass4<Y, MFP, RetType, Param1, Param2, Param3, Param4>(ptr, mfp, vfnptr, shptr);
2372 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
2373 SourceHook::ExecutableClass4<SourceHook::EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4>
2374 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr)
2376 SH__CALL_GET_VFNPTR_MANUAL
2377 return SourceHook::ExecutableClass4<EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4>(
2378 reinterpret_cast<SourceHook::EmptyClass*>(ptr), mfp, vfnptr, shptr);
2381 // Support for 5 arguments
2382 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
2383 SourceHook::ExecutableClass5<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5>
2384 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5), SourceHook::ISourceHook *shptr)
2386 SH__CALL_GET_VFNPTR_NORMAL
2387 return SourceHook::ExecutableClass5<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5>(ptr, mfp, vfnptr, shptr);
2390 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
2391 SourceHook::ExecutableClass5<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5>
2392 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5)const, SourceHook::ISourceHook *shptr)
2394 SH__CALL_GET_VFNPTR_NORMAL
2395 return SourceHook::ExecutableClass5<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5>(ptr, mfp, vfnptr, shptr);
2398 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
2399 SourceHook::ExecutableClass5<SourceHook::EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5>
2400 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr)
2402 SH__CALL_GET_VFNPTR_MANUAL
2403 return SourceHook::ExecutableClass5<EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5>(
2404 reinterpret_cast<SourceHook::EmptyClass*>(ptr), mfp, vfnptr, shptr);
2407 // Support for 6 arguments
2408 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
2409 SourceHook::ExecutableClass6<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>
2410 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6), SourceHook::ISourceHook *shptr)
2412 SH__CALL_GET_VFNPTR_NORMAL
2413 return SourceHook::ExecutableClass6<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>(ptr, mfp, vfnptr, shptr);
2416 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
2417 SourceHook::ExecutableClass6<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>
2418 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6)const, SourceHook::ISourceHook *shptr)
2420 SH__CALL_GET_VFNPTR_NORMAL
2421 return SourceHook::ExecutableClass6<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>(ptr, mfp, vfnptr, shptr);
2424 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
2425 SourceHook::ExecutableClass6<SourceHook::EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>
2426 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr)
2428 SH__CALL_GET_VFNPTR_MANUAL
2429 return SourceHook::ExecutableClass6<EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>(
2430 reinterpret_cast<SourceHook::EmptyClass*>(ptr), mfp, vfnptr, shptr);
2433 // Support for 7 arguments
2434 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
2435 SourceHook::ExecutableClass7<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
2436 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7), SourceHook::ISourceHook *shptr)
2438 SH__CALL_GET_VFNPTR_NORMAL
2439 return SourceHook::ExecutableClass7<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>(ptr, mfp, vfnptr, shptr);
2442 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
2443 SourceHook::ExecutableClass7<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
2444 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7)const, SourceHook::ISourceHook *shptr)
2446 SH__CALL_GET_VFNPTR_NORMAL
2447 return SourceHook::ExecutableClass7<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>(ptr, mfp, vfnptr, shptr);
2450 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
2451 SourceHook::ExecutableClass7<SourceHook::EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
2452 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr)
2454 SH__CALL_GET_VFNPTR_MANUAL
2455 return SourceHook::ExecutableClass7<EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>(
2456 reinterpret_cast<SourceHook::EmptyClass*>(ptr), mfp, vfnptr, shptr);
2460 #if SH_COMP != SH_COMP_MSVC || _MSC_VER > 1300
2461 // GCC & MSVC 7.1 need this, MSVC 7.0 doesn't like it
2464 // Support for 0 arguments
2465 template <class X, class Y, class MFP, class RetType>
2466 SourceHook::ExecutableClass0<Y, MFP, RetType>
2467 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(...), SourceHook::ISourceHook *shptr)
2469 SH__CALL_GET_VFNPTR_NORMAL
2470 return SourceHook::ExecutableClass0<Y, MFP, RetType>(ptr, mfp, vfnptr, shptr);
2473 template <class X, class Y, class MFP, class RetType>
2474 SourceHook::ExecutableClass0<Y, MFP, RetType>
2475 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(...)const, SourceHook::ISourceHook *shptr)
2477 SH__CALL_GET_VFNPTR_NORMAL
2478 return SourceHook::ExecutableClass0<Y, MFP, RetType>(ptr, mfp, vfnptr, shptr);
2482 // Support for 1 arguments
2483 template <class X, class Y, class MFP, class RetType, class Param1>
2484 SourceHook::ExecutableClass1<Y, MFP, RetType, Param1>
2485 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, ...), SourceHook::ISourceHook *shptr)
2487 SH__CALL_GET_VFNPTR_NORMAL
2488 return SourceHook::ExecutableClass1<Y, MFP, RetType, Param1>(ptr, mfp, vfnptr, shptr);
2491 template <class X, class Y, class MFP, class RetType, class Param1>
2492 SourceHook::ExecutableClass1<Y, MFP, RetType, Param1>
2493 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, ...)const, SourceHook::ISourceHook *shptr)
2495 SH__CALL_GET_VFNPTR_NORMAL
2496 return SourceHook::ExecutableClass1<Y, MFP, RetType, Param1>(ptr, mfp, vfnptr, shptr);
2500 // Support for 2 arguments
2501 template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
2502 SourceHook::ExecutableClass2<Y, MFP, RetType, Param1, Param2>
2503 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, ...), SourceHook::ISourceHook *shptr)
2505 SH__CALL_GET_VFNPTR_NORMAL
2506 return SourceHook::ExecutableClass2<Y, MFP, RetType, Param1, Param2>(ptr, mfp, vfnptr, shptr);
2509 template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
2510 SourceHook::ExecutableClass2<Y, MFP, RetType, Param1, Param2>
2511 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, ...)const, SourceHook::ISourceHook *shptr)
2513 SH__CALL_GET_VFNPTR_NORMAL
2514 return SourceHook::ExecutableClass2<Y, MFP, RetType, Param1, Param2>(ptr, mfp, vfnptr, shptr);
2518 // Support for 3 arguments
2519 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
2520 SourceHook::ExecutableClass3<Y, MFP, RetType, Param1, Param2, Param3>
2521 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, ...), SourceHook::ISourceHook *shptr)
2523 SH__CALL_GET_VFNPTR_NORMAL
2524 return SourceHook::ExecutableClass3<Y, MFP, RetType, Param1, Param2, Param3>(ptr, mfp, vfnptr, shptr);
2527 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
2528 SourceHook::ExecutableClass3<Y, MFP, RetType, Param1, Param2, Param3>
2529 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, ...)const, SourceHook::ISourceHook *shptr)
2531 SH__CALL_GET_VFNPTR_NORMAL
2532 return SourceHook::ExecutableClass3<Y, MFP, RetType, Param1, Param2, Param3>(ptr, mfp, vfnptr, shptr);
2536 // Support for 4 arguments
2537 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
2538 SourceHook::ExecutableClass4<Y, MFP, RetType, Param1, Param2, Param3, Param4>
2539 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, ...), SourceHook::ISourceHook *shptr)
2541 SH__CALL_GET_VFNPTR_NORMAL
2542 return SourceHook::ExecutableClass4<Y, MFP, RetType, Param1, Param2, Param3, Param4>(ptr, mfp, vfnptr, shptr);
2545 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
2546 SourceHook::ExecutableClass4<Y, MFP, RetType, Param1, Param2, Param3, Param4>
2547 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, ...)const, SourceHook::ISourceHook *shptr)
2549 SH__CALL_GET_VFNPTR_NORMAL
2550 return SourceHook::ExecutableClass4<Y, MFP, RetType, Param1, Param2, Param3, Param4>(ptr, mfp, vfnptr, shptr);
2554 // Support for 5 arguments
2555 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
2556 SourceHook::ExecutableClass5<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5>
2557 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...), SourceHook::ISourceHook *shptr)
2559 SH__CALL_GET_VFNPTR_NORMAL
2560 return SourceHook::ExecutableClass5<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5>(ptr, mfp, vfnptr, shptr);
2563 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
2564 SourceHook::ExecutableClass5<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5>
2565 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...)const, SourceHook::ISourceHook *shptr)
2567 SH__CALL_GET_VFNPTR_NORMAL
2568 return SourceHook::ExecutableClass5<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5>(ptr, mfp, vfnptr, shptr);
2572 // Support for 6 arguments
2573 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
2574 SourceHook::ExecutableClass6<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>
2575 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...), SourceHook::ISourceHook *shptr)
2577 SH__CALL_GET_VFNPTR_NORMAL
2578 return SourceHook::ExecutableClass6<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>(ptr, mfp, vfnptr, shptr);
2581 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
2582 SourceHook::ExecutableClass6<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>
2583 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...)const, SourceHook::ISourceHook *shptr)
2585 SH__CALL_GET_VFNPTR_NORMAL
2586 return SourceHook::ExecutableClass6<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>(ptr, mfp, vfnptr, shptr);
2590 // Support for 7 arguments
2591 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
2592 SourceHook::ExecutableClass7<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
2593 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...), SourceHook::ISourceHook *shptr)
2595 SH__CALL_GET_VFNPTR_NORMAL
2596 return SourceHook::ExecutableClass7<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>(ptr, mfp, vfnptr, shptr);
2599 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
2600 SourceHook::ExecutableClass7<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
2601 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...)const, SourceHook::ISourceHook *shptr)
2603 SH__CALL_GET_VFNPTR_NORMAL
2604 return SourceHook::ExecutableClass7<Y, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>(ptr, mfp, vfnptr, shptr);
2611 #define SH_CALL(ptr, mfp) SH_CALL2((ptr), (mfp), (mfp), SH_GLOB_SHPTR)
2612 #define SH_MCALL2(ptr, mfp, vtblidx, vtbloffs, thisptroffs) SH_MCALL3((ptr), (mfp), (mfp), (vtblidx), (vtbloffs), (thisptroffs), SH_GLOB_SHPTR)
2613 #define SH_MCALL(ptr, mhookname) SH_MCALL2((ptr), SH_MFHCls(mhookname)::ECMFP(), SH_MFHCls(mhookname)::ms_MFI.vtblindex, \
2614 SH_MFHCls(mhookname)::ms_MFI.vtbloffs, SH_MFHCls(mhookname)::ms_MFI.thisptroffs)
2616 #undef SH_MAKE_EXECUTABLECLASS_OB
2617 #undef SH_MAKE_EXECUTABLECLASS_OB_void
2619 //////////////////////////////////////////////////////////////////////////
2620 // SetOverrideRet and RecallGetIface for recalls
2621 // These take a ISourceHook pointer instead of using SH_GLOB_SHPTR directly
2622 // The reason is that the user may want to redefine SH_GLOB_SHPTR - then the macros
2623 // (META_RETURN_VALUE_NEWPARAMS) should obey the new pointer.
2625 namespace SourceHook
2627 template <class RetType>
2628 void SetOverrideResult(ISourceHook *shptr, const RetType res)
2630 *reinterpret_cast<RetType*>(shptr->GetOverrideRetPtr()) = res;
2633 // SetOverrideResult used to be implemented like this:
2634 // SetOverrideResult(shptr, memfuncptr, return);
2635 // normally the compiler can deduce the return type from memfuncptr, but (at least msvc8) failed when it was a reference
2636 // (it thought it was ambigous - the ref and non-ref type)
2637 // so now SetOverrideResult(memfuncptr) deduces the ret type, and returns a functor which does the work
2638 // new syntax: SetOverrideResult(memfuncptr)(shptr, return)
2639 // This also allows us to create a special version for references which respects ReferenceCarrier.
2641 template <class T> struct OverrideFunctor
2643 void operator()(ISourceHook *shptr, T res)
2645 *reinterpret_cast<T*>(shptr->GetOverrideRetPtr()) = res;
2648 template <class T> struct OverrideFunctor<T&>
2650 void operator()(ISourceHook *shptr, T &res)
2652 // overrideretptr points to ReferenceCarrier<T&>
2653 *reinterpret_cast<typename ReferenceCarrier<T&>::type *>(shptr->GetOverrideRetPtr()) = res;
2657 template <class Iface, class RetType>
2658 OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)())
2660 return OverrideFunctor<RetType>();
2663 template <class Iface, class RetType>
2664 Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)())
2666 return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
2669 template <class Iface, class RetType, class Param1>
2670 OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1))
2672 return OverrideFunctor<RetType>();
2675 template <class Iface, class RetType, class Param1>
2676 Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1))
2678 return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
2681 template <class Iface, class RetType, class Param1, class Param2>
2682 OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2))
2684 return OverrideFunctor<RetType>();
2687 template <class Iface, class RetType, class Param1, class Param2>
2688 Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2))
2690 return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
2693 template <class Iface, class RetType, class Param1, class Param2, class Param3>
2694 OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3))
2696 return OverrideFunctor<RetType>();
2699 template <class Iface, class RetType, class Param1, class Param2, class Param3>
2700 Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3))
2702 return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
2705 template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
2706 OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4))
2708 return OverrideFunctor<RetType>();
2711 template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
2712 Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4))
2714 return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
2717 template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
2718 OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5))
2720 return OverrideFunctor<RetType>();
2723 template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
2724 Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5))
2726 return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
2729 template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
2730 OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6))
2732 return OverrideFunctor<RetType>();
2735 template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
2736 Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6))
2738 return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
2741 template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
2742 OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2744 return OverrideFunctor<RetType>();
2747 template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
2748 Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7))
2750 return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
2756 // The pope is dead. -> :(