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 normal non-trivial constructor */
175 PassFlag_AssignOp = (1<<4), /**< Object has a non-trivial assignment operator */
176 PassFlag_CCtor = (1<<5) /**< Object has a copy constructor (which takes const Object& as only parameter) */
179 size_t size; //!< Size of the data being passed
182 // (might be used in future versions for automatic hookfunc generation)
183 int type; //!< PassType value
184 unsigned int flags; //!< Pass/return flags
191 void *pAssignOperator;
199 CallConv_Unknown, /**< Unknown -- no extra info available */
200 CallConv_ThisCall, /**< This call (object pointer required) */
201 CallConv_Cdecl, /**< Standard C call */
204 int numOfParams; //!< number of parameters
205 PassInfo retPassInfo; //!< PassInfo for the return value. size=0 -> no retval
206 const PassInfo *paramsPassInfo; //!< PassInfos for the parameters
208 // paramsPassInfo[0] is basically a dummy parameter.
209 // However, paramsPassInfo[0].size stores the version of the ProtoInfo structure.
215 PassInfo::V2Info retPassInfo2;
216 const PassInfo::V2Info *paramsPassInfo2;
219 struct IHookManagerInfo;
222 * @brief Pointer to hook manager interface function
224 * The hook manager should store hi for later use if store==true. It should then call hi->SetInfo(...) if hi
225 * is non-null. The hook manager can return 0 for success or a non-zero value if it doesn't want to be used.
227 * @param hi A pointer to IHookManagerInfo
229 typedef int (*HookManagerPubFunc)(bool store, IHookManagerInfo *hi);
234 virtual bool IsEqual(ISHDelegate *pOtherDeleg) = 0; // pOtherDeleg is from the same plugin and hookman
235 virtual void DeleteThis() = 0;
238 struct IHookManagerInfo
240 virtual void SetInfo(int hookman_version, int vtbloffs, int vtblidx,
241 ProtoInfo *proto, void *hookfunc_vfnptr) = 0;
244 // I'm adding support for functions which return references.
247 // SH_SETUPCALLS doesn't use plain rettype to store the temporary return values (plugin ret, orig ret,
248 // override ret) anymore; instead, it uses SourceHook::ReferenceCarrier<rettype>::type
249 // this is typedefed to the original rettype normally, but if the rettype is a reference, it's a special class
250 // which stores the reference as a pointer, and implements constructors, operator= and a conversion operator.
251 // special cases were needed for getoverrideret / getorigret; these are implemented through the
252 // SourceHook::MacroRefHelpers structs.
253 // Furthermore, SetOverrideRet had to be changed a bit; see SourceHook::OverrideFunctor somewhere down in this file.
254 template <class T> struct ReferenceCarrier
259 template <class T> struct ReferenceCarrier<T&>
265 type() : m_StoredRef(NULL)
268 type(T& ref) : m_StoredRef(&ref)
272 T& operator= (T& ref)
287 virtual ISHDelegate *GetNext() = 0;
288 virtual void *GetOverrideRetPtr() = 0;
289 virtual const void *GetOrigRetPtr() = 0;
290 virtual bool ShouldCallOrig() = 0;
294 * @brief The main SourceHook interface
300 * @brief Return interface version
302 virtual int GetIfaceVersion() = 0;
305 * @brief Return implementation version
307 virtual int GetImplVersion() = 0;
310 * @brief Modes for the new AddHook
320 * @brief Add a (VP) hook.
322 * @return non-zero hook id on success, 0 otherwise
324 * @param plug The unique identifier of the plugin that calls this function
325 * @param mode Can be either Hook_Normal or Hook_VP (vtable-wide hook)
326 * @param iface The interface pointer
327 * @param ifacesize The size of the class iface points to
328 * @param myHookMan A hook manager function that should be capable of handling the function
329 * @param handler A pointer to the hook handler something
330 * @param post Set to true if you want a post handler
332 virtual int AddHook(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
333 ISHDelegate *handler, bool post) = 0;
335 // Source backwarts compat (only for normal hooks)
336 virtual bool RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
337 ISHDelegate *handler, bool post) = 0;
340 * @brief Remove a hook by ID.
342 * @return true on success, false otherwise
344 * @param hookid The hook id (returned by AddHook)
346 virtual bool RemoveHookByID(int hookid) = 0;
349 * @brief Pause a hook by ID.
351 * @return true on success, false otherwise
353 * @param hookid The hook id (returned by AddHook)
355 virtual bool PauseHookByID(int hookid) = 0;
358 * @brief Unpause a hook by ID.
360 * @return true on success, false otherwise
362 * @param hookid The hook id (returned by AddHook)
364 virtual bool UnpauseHookByID(int hookid) = 0;
367 * @brief Checks whether a plugin has (a) hook manager(s) that is/are currently used by other plugins
369 * @param plug The unique identifier of the plugin in question
372 virtual void SetRes(META_RES res) = 0; //!< Sets the meta result
373 virtual META_RES GetPrevRes() = 0; //!< Gets the meta result of the
374 //!< previously calledhandler
375 virtual META_RES GetStatus() = 0; //!< Gets the highest meta result
376 virtual const void *GetOrigRet() = 0; //!< Gets the original result.
377 //!< If not in post function, undefined
378 virtual const void *GetOverrideRet() = 0; //!< Gets the override result.
379 //!< If none is specified, NULL
380 virtual void *GetIfacePtr() = 0; //!< Gets the interface pointer
382 virtual void *GetOverrideRetPtr() = 0; //!< Used for setting the override return value
385 * @brief Remove a hook manager. Auto-removes all hooks attached to it from plugin plug.
387 * @param plug The owner of the hook manager
388 * @param pubFunc The hook manager's info function
390 virtual void RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc) = 0;
395 * @brief Makes sure that hooks are going to be ignored on the next call of vfnptr
397 * @param plug The unique identifier of the plugin that calls this function
398 * @param vfnptr The virtual function pointer of the function in question
400 virtual void SetIgnoreHooks(void *vfnptr) = 0;
403 * @brief Reverses SetIgnoreHooks' effect
405 * @param plug The unique identifier of the plugin that calls this function
406 * @param vfnptr The virtual function pointer of the function in question
408 virtual void ResetIgnoreHooks(void *vfnptr) = 0;
411 * @brief Finds the original entry of a virtual function pointer
413 * @param vfnptr The virtual function pointer
414 * @return The original entry if the virtual function pointer has been patched; NULL otherwise.
416 virtual void *GetOrigVfnPtrEntry(void *vfnptr) = 0;
418 //////////////////////////////////////////////////////////////////////////
422 // Returns the current iface ptr
423 virtual void DoRecall() = 0; //!< Initiates a recall sequence
429 Users want the ability to change parameters of the called function
430 from inside their handler.
433 2) Recall the function
434 3) => SH's hook func gets called:
435 4) The first iterator points at the first hook the last hookfunc didn't execute yet
436 5) does all iteration and returns normally
437 6) The user's handler returns immediately
438 7) The hook func returns immediately as well
440 Also note that the recalled hookfunc starts with the status the recalling hookfunc
441 ended with. The last handler (doing the recall) is also able to specify its own
446 * @brief Set up the hook loop.
448 * @param statusPtr pointer to status variable
449 * @param prevResPtr pointer to previous result variable
450 * @param curResPtr pointer to current result variable
451 * @param ifacePtrPtr pointer to interface this pointer variable
452 * @param origRetPr pointer to original return value variable. NULL for void funcs
453 * @param overrideRetPtr pointer to override return value variable. NULL for void funcs
455 * @return Override Return Pointer the hookfunc should use (may differ from overrideRetPtr
456 * when the hook func is being called as part of a recall
458 virtual IHookContext *SetupHookLoop(IHookManagerInfo *hi, void *vfnptr, void *thisptr, void **origentry,
459 META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr,
460 const void *origRetPtr, void *overrideRetPtr) = 0;
462 virtual void EndContext(IHookContext *pCtx) = 0;
465 // For META_RESULT_ORIG_RET and META_RESULT_OVERRIDE_RET:
466 // These have to be able to return references. If T is a reference, the pointers returned
467 // from the SH_GLOB_SHPTR are pointers to instances of ReferenceCarrier<T>::type.
468 template <class T> struct MacroRefHelpers
470 inline static const T* GetOrigRet(ISourceHook *shptr)
472 return reinterpret_cast<const T*>(shptr->GetOrigRet());
474 inline static const T* GetOverrideRet(ISourceHook *shptr)
476 return reinterpret_cast<const T*>(shptr->GetOverrideRet());
480 template <class T> struct MacroRefHelpers<T&>
482 inline static T* GetOrigRet(ISourceHook *shptr)
484 T &ref = *reinterpret_cast<const typename ReferenceCarrier<T&>::type *>(shptr->GetOrigRet());
487 inline static T* GetOverrideRet(ISourceHook *shptr)
489 T &ref = *reinterpret_cast<const typename ReferenceCarrier<T&>::type *>(shptr->GetOverrideRet());
494 template <class X, class MFP>
495 void *GetOrigVfnPtrEntry(X *pInstance, MFP mfp, ISourceHook *pSH)
497 SourceHook::MemFuncInfo info = {true, -1, 0, 0};
498 SourceHook::GetFuncInfo(pInstance, mfp, info);
500 void *vfnptr = reinterpret_cast<void*>(
501 *reinterpret_cast<void***>(reinterpret_cast<char*>(pInstance) + info.thisptroffs + info.vtbloffs) + info.vtblindex);
503 void *origentry = pSH->GetOrigVfnPtrEntry(vfnptr);
505 return origentry ? origentry : *reinterpret_cast<void**>(vfnptr);
508 template <class T> struct GetPassInfo
510 static const int type = 0;
511 static const unsigned int flags = PassInfo::PassFlag_ByVal;
514 template <class T> struct GetPassInfo<T&>
516 static const int type = 0;
517 static const unsigned int flags = PassInfo::PassFlag_ByRef;
521 /************************************************************************/
522 /* High level interface */
523 /************************************************************************/
524 #define META_RESULT_STATUS SH_GLOB_SHPTR->GetStatus()
525 #define META_RESULT_PREVIOUS SH_GLOB_SHPTR->GetPrevRes()
526 #define META_RESULT_ORIG_RET(type) *SourceHook::MacroRefHelpers<type>::GetOrigRet(SH_GLOB_SHPTR)
527 #define META_RESULT_OVERRIDE_RET(type) *SourceHook::MacroRefHelpers<type>::GetOverrideRet(SH_GLOB_SHPTR)
528 #define META_IFACEPTR(type) reinterpret_cast<type*>(SH_GLOB_SHPTR->GetIfacePtr())
530 #define SET_META_RESULT(result) SH_GLOB_SHPTR->SetRes(result)
531 #define RETURN_META(result) do { SET_META_RESULT(result); return; } while(0)
532 #define RETURN_META_VALUE(result, value) do { SET_META_RESULT(result); return (value); } while(0)
536 SourceHook::CallClass<T> *SH_GET_CALLCLASS(T *p)
538 return static_cast< SourceHook::CallClass<T> *>(p);
540 #define SH_RELEASE_CALLCLASS(p)
542 #define SH_GET_MCALLCLASS(p, size) reinterpret_cast<void*>(p)
544 // only call these from the hook handlers directly!
546 // If a hook on a function which returns a reference does not want to specify a return value,
547 // it can use this macro.
548 // ONLY USE THIS WITH MRES_IGNORED AND MRES_HANDLED !!!
549 #define RETURN_META_NOREF(result, rettype) do { SET_META_RESULT(result); return reinterpret_cast<rettype>(*SH_GLOB_SHPTR); } while(0)
551 // Why take a memfuncptr instead of iface and func when we have to deduce the iface anyway now?
552 // Well, without it, there'd be no way to specify which overloaded version we want in _VALUE
554 // SourceHook::SetOverrideRet is defined later.
555 #define RETURN_META_NEWPARAMS(result, memfuncptr, newparams) \
557 SET_META_RESULT(result); \
558 SH_GLOB_SHPTR->DoRecall(); \
559 (SourceHook::RecallGetIface(SH_GLOB_SHPTR, memfuncptr)->*(memfuncptr)) newparams; \
560 RETURN_META(MRES_SUPERCEDE); \
563 #define RETURN_META_VALUE_NEWPARAMS(result, value, memfuncptr, newparams) \
565 SET_META_RESULT(result); \
566 SH_GLOB_SHPTR->DoRecall(); \
567 if ((result) >= MRES_OVERRIDE) \
569 /* meh, set the override result here because we don't get a chance to return */ \
570 /* before continuing the hook loop through the recall */ \
571 SourceHook::SetOverrideResult(memfuncptr)(SH_GLOB_SHPTR, value); \
573 RETURN_META_VALUE(MRES_SUPERCEDE, \
574 (SourceHook::RecallGetIface(SH_GLOB_SHPTR, memfuncptr)->*(memfuncptr)) newparams); \
577 // :TODO: thisptroffs in MNEWPARAMS ??
579 #if SH_COMP == SH_COMP_MSVC
581 #define SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname) \
584 SH_MFHCls(hookname)::ECMFP mfp; \
587 u.addr = (*reinterpret_cast<void***>(reinterpret_cast<char*>(thisptr) + SH_MFHCls(hookname)::ms_MFI.vtbloffs))[ \
588 SH_MFHCls(hookname)::ms_MFI.vtblindex];
590 #elif SH_COMP == SH_COMP_GCC
592 #define SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname) \
595 SH_MFHCls(hookname)::ECMFP mfp; \
602 u.s.addr = (*reinterpret_cast<void***>(reinterpret_cast<char*>(thisptr) + SH_MFHCls(hookname)::ms_MFI.vtbloffs))[ \
603 SH_MFHCls(hookname)::ms_MFI.vtblindex]; \
608 #define RETURN_META_MNEWPARAMS(result, hookname, newparams) \
610 SET_META_RESULT(result); \
611 SH_GLOB_SHPTR->DoRecall(); \
612 SourceHook::EmptyClass *thisptr = reinterpret_cast<SourceHook::EmptyClass*>(SH_GLOB_SHPTR->GetIfacePtr()); \
613 (thisptr->*(__SoureceHook_FHM_GetRecallMFP##hookname(thisptr))) newparams; \
614 RETURN_META(MRES_SUPERCEDE); \
617 #define RETURN_META_VALUE_MNEWPARAMS(result, value, hookname, newparams) \
619 SET_META_RESULT(result); \
620 SH_GLOB_SHPTR->DoRecall(); \
621 if ((result) >= MRES_OVERRIDE) \
623 /* see RETURN_META_VALUE_NEWPARAMS */ \
624 __SoureceHook_FHM_SetOverrideResult##hookname(SH_GLOB_SHPTR, value); \
626 SourceHook::EmptyClass *thisptr = reinterpret_cast<SourceHook::EmptyClass*>(SH_GLOB_SHPTR->GetIfacePtr()); \
627 RETURN_META_VALUE(MRES_SUPERCEDE, (thisptr->*(__SoureceHook_FHM_GetRecallMFP##hookname(thisptr))) newparams); \
631 #define SH_MANUALHOOK_RECONFIGURE(hookname, pvtblindex, pvtbloffs, pthisptroffs) \
632 __SourceHook_FHM_Reconfigure##hookname(pvtblindex, pvtbloffs, pthisptroffs)
634 #define SH_GET_ORIG_VFNPTR_ENTRY(inst, mfp) (SourceHook::GetOrigVfnPtrEntry(inst, mfp, SH_GLOB_SHPTR))
636 // New ADD / REMOVE macros.
637 #define SH_STATIC(func) fastdelegate::MakeDelegate(func)
638 #define SH_MEMBER(inst, func) fastdelegate::MakeDelegate(inst, func)
640 #define SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
641 __SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
642 SourceHook::ISourceHook::Hook_Normal, post, handler)
644 #define SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
645 __SourceHook_FHRemove##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
648 #define SH_ADD_MANUALHOOK(hookname, ifaceptr, handler, post) \
649 __SourceHook_FHMAdd##hookname(reinterpret_cast<void*>(ifaceptr), \
650 SourceHook::ISourceHook::Hook_Normal, post, handler)
652 #define SH_REMOVE_MANUALHOOK(hookname, ifaceptr, handler, post) \
653 __SourceHook_FHMRemove##hookname(reinterpret_cast<void*>(ifaceptr), post, handler)
655 #define SH_ADD_VPHOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
656 __SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
657 SourceHook::ISourceHook::Hook_VP, post, handler)
659 #define SH_ADD_DVPHOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
660 __SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
661 SourceHook::ISourceHook::Hook_DVP, post, handler)
663 #define SH_ADD_MANUALVPHOOK(hookname, ifaceptr, handler, post) \
664 __SourceHook_FHMAdd##hookname(reinterpret_cast<void*>(ifaceptr), SourceHook::ISourceHook::Hook_VP, post, handler)
666 #define SH_ADD_MANUALDVPHOOK(hookname, ifaceptr, handler, post) \
667 __SourceHook_FHMAdd##hookname(reinterpret_cast<void*>(ifaceptr), SourceHook::ISourceHook::Hook_DVP, post, handler)
669 #define SH_REMOVE_HOOK_ID(hookid) \
670 (SH_GLOB_SHPTR->RemoveHookByID(hookid))
673 // !! These are now deprecated. Instead, use one of these:
674 // SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
675 // SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post)
677 #define SH_ADD_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \
678 SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
679 #define SH_ADD_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \
680 SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
682 // SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
683 // SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post)
685 #define SH_REMOVE_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \
686 SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
687 #define SH_REMOVE_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \
688 SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
690 // SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
691 // SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post)
693 #define SH_ADD_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \
694 SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
695 #define SH_ADD_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \
696 SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
698 // SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
699 // SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post)
701 #define SH_REMOVE_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \
702 SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
703 #define SH_REMOVE_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \
704 SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
711 #if SH_COMP == SH_COMP_MSVC
712 # define SH_SETUP_MFP(mfp) \
713 reinterpret_cast<void**>(&mfp)[0] = vfnptr_origentry;
714 #elif SH_COMP == SH_COMP_GCC
715 # define SH_SETUP_MFP(mfp) \
716 reinterpret_cast<void**>(&mfp)[0] = vfnptr_origentry; \
717 reinterpret_cast<void**>(&mfp)[1] = 0;
719 # error Not supported yet.
722 //////////////////////////////////////////////////////////////////////////
723 #define SH_FHCls(ift, iff, ov) __SourceHook_FHCls_##ift##iff##ov
724 #define SH_MFHCls(hookname) __SourceHook_MFHCls_##hookname
726 #define SHINT_MAKE_HOOKMANPUBFUNC(ifacetype, ifacefunc, overload, funcptr) \
727 static int HookManPubFunc(bool store, ::SourceHook::IHookManagerInfo *hi) \
729 using namespace ::SourceHook; \
730 GetFuncInfo(funcptr, ms_MFI); \
731 /* Verify interface version */ \
732 if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \
734 if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \
740 MemFuncInfo mfi = {true, -1, 0, 0}; \
741 GetFuncInfo(&SH_FHCls(ifacetype,ifacefunc,overload)::Func, mfi); \
742 hi->SetInfo(SH_HOOKMAN_VERSION, ms_MFI.vtbloffs, ms_MFI.vtblindex, &ms_Proto, \
743 reinterpret_cast<void**>(reinterpret_cast<char*>(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex] ); \
748 // It has to be possible to use the macros in namespaces
749 // -> So we need to access and extend the global SourceHook namespace
750 // We use a namespace alias for this
751 #define SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, funcptr) \
752 struct SH_FHCls(ifacetype,ifacefunc,overload) \
754 static SH_FHCls(ifacetype,ifacefunc,overload) ms_Inst; \
755 static ::SourceHook::MemFuncInfo ms_MFI; \
756 static ::SourceHook::IHookManagerInfo *ms_HI; \
757 static ::SourceHook::ProtoInfo ms_Proto; \
758 SHINT_MAKE_HOOKMANPUBFUNC(ifacetype, ifacefunc, overload, funcptr)
760 #define SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, funcptr) \
762 SH_FHCls(ifacetype,ifacefunc,overload) SH_FHCls(ifacetype,ifacefunc,overload)::ms_Inst; \
763 ::SourceHook::MemFuncInfo SH_FHCls(ifacetype,ifacefunc,overload)::ms_MFI; \
764 ::SourceHook::IHookManagerInfo *SH_FHCls(ifacetype,ifacefunc,overload)::ms_HI; \
765 int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
766 SH_FHCls(ifacetype,ifacefunc,overload)::FD handler) \
768 using namespace ::SourceHook; \
769 MemFuncInfo mfi = {true, -1, 0, 0}; \
770 GetFuncInfo(funcptr, mfi); \
771 if (mfi.thisptroffs < 0 || !mfi.isVirtual) \
772 return false; /* No non-virtual functions / virtual inheritance supported */ \
774 return SH_GLOB_SHPTR->AddHook(SH_GLOB_PLUGPTR, mode, \
775 iface, mfi.thisptroffs, SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, \
776 new SH_FHCls(ifacetype,ifacefunc,overload)::CMyDelegateImpl(handler), post); \
778 bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \
779 SH_FHCls(ifacetype,ifacefunc,overload)::FD handler) \
781 using namespace ::SourceHook; \
782 MemFuncInfo mfi = {true, -1, 0, 0}; \
783 GetFuncInfo(funcptr, mfi); \
784 SH_FHCls(ifacetype,ifacefunc,overload)::CMyDelegateImpl tmp(handler); \
785 return SH_GLOB_SHPTR->RemoveHook(SH_GLOB_PLUGPTR, iface, mfi.thisptroffs, \
786 SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, &tmp, post); \
789 #define SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, pvtbloffs, pvtblidx, pthisptroffs) \
790 struct SH_MFHCls(hookname) \
792 static SH_MFHCls(hookname) ms_Inst; \
793 static ::SourceHook::MemFuncInfo ms_MFI; \
794 static ::SourceHook::IHookManagerInfo *ms_HI; \
795 static ::SourceHook::ProtoInfo ms_Proto; \
797 SH_MFHCls(hookname)() \
799 ms_MFI.isVirtual = true; \
800 ms_MFI.thisptroffs = pthisptroffs; \
801 ms_MFI.vtblindex = pvtblidx; \
802 ms_MFI.vtbloffs = pvtbloffs; \
804 static int HookManPubFunc(bool store, ::SourceHook::IHookManagerInfo *hi) \
806 using namespace ::SourceHook; \
807 /* Verify interface version */ \
808 if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \
810 if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \
816 MemFuncInfo mfi = {true, -1, 0, 0}; \
817 GetFuncInfo(&SH_MFHCls(hookname)::Func, mfi); \
818 hi->SetInfo(SH_HOOKMAN_VERSION, ms_MFI.vtbloffs, ms_MFI.vtblindex, &ms_Proto, \
819 reinterpret_cast<void**>(reinterpret_cast<char*>(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex] ); \
824 #define SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, pvtbloffs, pvtblidx, pthisptroffs) \
826 SH_MFHCls(hookname) SH_MFHCls(hookname)::ms_Inst; \
827 ::SourceHook::MemFuncInfo SH_MFHCls(hookname)::ms_MFI; \
828 ::SourceHook::IHookManagerInfo *SH_MFHCls(hookname)::ms_HI; \
829 int __SourceHook_FHMAdd##hookname(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
830 SH_MFHCls(hookname)::FD handler) \
832 return SH_GLOB_SHPTR->AddHook(SH_GLOB_PLUGPTR, mode, \
833 iface, pthisptroffs, SH_MFHCls(hookname)::HookManPubFunc, \
834 new SH_MFHCls(hookname)::CMyDelegateImpl(handler), post); \
836 bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \
837 SH_MFHCls(hookname)::FD handler) \
839 SH_MFHCls(hookname)::CMyDelegateImpl tmp(handler); \
840 return SH_GLOB_SHPTR->RemoveHook(SH_GLOB_PLUGPTR, iface, pthisptroffs, \
841 SH_MFHCls(hookname)::HookManPubFunc, &tmp, post); \
843 SH_MFHCls(hookname)::ECMFP __SoureceHook_FHM_GetRecallMFP##hookname(::SourceHook::EmptyClass *thisptr) \
845 SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname); \
848 SH_MFHCls(hookname)::CallEC __SoureceHook_FHM_SHCall##hookname(void *ptr) \
850 SH_MFHCls(hookname)::ECMFP mfp; \
851 void *vfnptr = reinterpret_cast<void*>( \
852 *reinterpret_cast<void***>( (reinterpret_cast<char*>(ptr) + SH_MFHCls(hookname)::ms_MFI.thisptroffs + SH_MFHCls(hookname)::ms_MFI.vtbloffs) ) + SH_MFHCls(hookname)::ms_MFI.vtblindex); \
854 *reinterpret_cast<void**>(&mfp) = *reinterpret_cast<void**>(vfnptr); \
855 if (sizeof(mfp) == 2*sizeof(void*)) /* gcc */ \
856 *(reinterpret_cast<void**>(&mfp) + 1) = 0; \
857 return SH_MFHCls(hookname)::CallEC(reinterpret_cast< ::SourceHook::EmptyClass* >(ptr), mfp, vfnptr, SH_GLOB_SHPTR); \
859 void __SourceHook_FHM_Reconfigure##hookname(int p_vtblindex, int p_vtbloffs, int p_thisptroffs) \
861 SH_GLOB_SHPTR->RemoveHookManager(SH_GLOB_PLUGPTR, SH_MFHCls(hookname)::HookManPubFunc); \
862 SH_MFHCls(hookname)::ms_MFI.thisptroffs = p_thisptroffs; \
863 SH_MFHCls(hookname)::ms_MFI.vtblindex = p_vtblindex; \
864 SH_MFHCls(hookname)::ms_MFI.vtbloffs = p_vtbloffs; \
867 #define SH_SETUPCALLS(rettype, paramtypes, params) \
869 using namespace ::SourceHook; \
870 void *ourvfnptr = reinterpret_cast<void*>( \
871 *reinterpret_cast<void***>(reinterpret_cast<char*>(this) + ms_MFI.vtbloffs) + ms_MFI.vtblindex); \
872 void *vfnptr_origentry; \
874 META_RES status = MRES_IGNORED; \
878 typedef ReferenceCarrier< rettype >::type my_rettype; \
879 my_rettype orig_ret; \
880 my_rettype override_ret; \
881 my_rettype plugin_ret; \
883 IHookContext *pContext = SH_GLOB_SHPTR->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast<void*>(this), \
884 &vfnptr_origentry, &status, &prev_res, &cur_res, &orig_ret, &override_ret);
886 #define SH_CALL_HOOKS(post, params) \
887 prev_res = MRES_IGNORED; \
888 while ( (iter = static_cast<IMyDelegate*>(pContext->GetNext())) ) \
890 cur_res = MRES_IGNORED; \
891 plugin_ret = iter->Call params; \
892 prev_res = cur_res; \
893 if (cur_res > status) \
895 if (cur_res >= MRES_OVERRIDE) \
896 *reinterpret_cast<my_rettype*>(pContext->GetOverrideRetPtr()) = plugin_ret; \
899 #define SH_CALL_ORIG(rettype, paramtypes, params) \
900 if (status != MRES_SUPERCEDE && pContext->ShouldCallOrig()) \
902 rettype (EmptyClass::*mfp)paramtypes; \
904 orig_ret = (reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
907 orig_ret = override_ret; /* :TODO: ??? : use pContext->GetOverrideRetPtr() or not? */
909 #define SH_RETURN() \
910 const my_rettype *retptr = reinterpret_cast<const my_rettype*>( \
911 (status >= MRES_OVERRIDE) ? pContext->GetOverrideRetPtr() : pContext->GetOrigRetPtr()); \
912 SH_GLOB_SHPTR->EndContext(pContext); \
915 #define SH_HANDLEFUNC(paramtypes, params, rettype) \
916 SH_SETUPCALLS(rettype, paramtypes, params) \
917 SH_CALL_HOOKS(pre, params) \
918 SH_CALL_ORIG(rettype, paramtypes, params) \
919 SH_CALL_HOOKS(post, params) \
922 //////////////////////////////////////////////////////////////////////////
923 #define SH_SETUPCALLS_void(paramtypes, params) \
925 using namespace ::SourceHook; \
926 void *ourvfnptr = reinterpret_cast<void*>( \
927 *reinterpret_cast<void***>(reinterpret_cast<char*>(this) + ms_MFI.vtbloffs) + ms_MFI.vtblindex); \
928 void *vfnptr_origentry; \
930 META_RES status = MRES_IGNORED; \
935 IHookContext *pContext = SH_GLOB_SHPTR->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast<void*>(this), \
936 &vfnptr_origentry, &status, &prev_res, &cur_res, NULL, NULL);
938 #define SH_CALL_HOOKS_void(post, params) \
939 prev_res = MRES_IGNORED; \
940 while ( (iter = static_cast<IMyDelegate*>(pContext->GetNext())) ) \
942 cur_res = MRES_IGNORED; \
944 prev_res = cur_res; \
945 if (cur_res > status) \
949 #define SH_CALL_ORIG_void(paramtypes, params) \
950 if (status != MRES_SUPERCEDE && pContext->ShouldCallOrig()) \
952 void (EmptyClass::*mfp)paramtypes; \
954 (reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
957 #define SH_RETURN_void() \
958 SH_GLOB_SHPTR->EndContext(pContext);
960 #define SH_HANDLEFUNC_void(paramtypes, params) \
961 SH_SETUPCALLS_void(paramtypes, params) \
962 SH_CALL_HOOKS_void(pre, params) \
963 SH_CALL_ORIG_void(paramtypes, params) \
964 SH_CALL_HOOKS_void(post, params) \
968 // Special vafmt handlers
970 #define SH_HANDLEFUNC_vafmt(paramtypes, params_orig, params_plug, rettype) \
971 SH_SETUPCALLS(rettype, paramtypes, params_orig) \
972 SH_CALL_HOOKS(pre, params_plug) \
973 SH_CALL_ORIG(rettype, paramtypes, params_orig) \
974 SH_CALL_HOOKS(post, params_plug) \
977 #define SH_HANDLEFUNC_void_vafmt(paramtypes, params_orig, params_plug) \
978 SH_SETUPCALLS_void(paramtypes, params_orig) \
979 SH_CALL_HOOKS_void(pre, params_plug) \
980 SH_CALL_ORIG_void(paramtypes, params_orig) \
981 SH_CALL_HOOKS_void(post, params_plug) \
984 //////////////////////////////////////////////////////////////////////////
986 #define MAKE_DELEG(ret_type, params_decl, params_pass) \
987 struct IMyDelegate : ::SourceHook::ISHDelegate { virtual ret_type Call params_decl = 0; }; \
988 struct CMyDelegateImpl : IMyDelegate \
991 CMyDelegateImpl(FD deleg) : m_Deleg(deleg) {} \
992 ret_type Call params_decl { return m_Deleg params_pass; } \
993 void DeleteThis() { delete this; } \
994 bool IsEqual(ISHDelegate *pOtherDeleg) { return m_Deleg == static_cast<CMyDelegateImpl*>(pOtherDeleg)->m_Deleg; } \
997 #define MAKE_DELEG_void(params_decl, params_pass) \
998 struct IMyDelegate : ::SourceHook::ISHDelegate { virtual void Call params_decl = 0; }; \
999 struct CMyDelegateImpl : IMyDelegate \
1002 CMyDelegateImpl(FD deleg) : m_Deleg(deleg) {} \
1003 void Call params_decl { m_Deleg params_pass; } \
1004 void DeleteThis() { delete this; } \
1005 bool IsEqual(ISHDelegate *pOtherDeleg) { return m_Deleg == static_cast<CMyDelegateImpl*>(pOtherDeleg)->m_Deleg; } \
1008 // GetPassInfo -> easier access. __SH_GPI generates a SourceHook::PassInfo instance.
1009 #define __SH_GPI(tt) { sizeof(tt), ::SourceHook::GetPassInfo< tt >::type, ::SourceHook::GetPassInfo< tt >::flags }
1010 // Extra pass info V2
1011 #define __SH_EPI { 0, 0, 0, 0 }
1013 #define __SH_VAFMT_SEQ(fmt, buf) \
1014 char buf[::SourceHook::STRBUF_LEN]; \
1016 va_start(ap, fmt); \
1017 vsnprintf(buf, sizeof(buf) - 1, fmt, ap); \
1018 buf[sizeof(buf) - 1] = 0; \
1022 // ********* Support for $1 arguments *********
1023 #define SH_DECL_HOOK$1(ifacetype, ifacefunc, attr, overload, rettype@[$2,1,$1:, param$2@]) \
1024 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(@[$2,1,$1|, :param$2@]) attr> \
1025 (&ifacetype::ifacefunc))) \
1026 typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> FD; \
1027 MAKE_DELEG(rettype, (@[$2,1,$1|, :param$2 p$2@]), (@[$2,1,$1|, :p$2@])); \
1028 virtual rettype Func(@[$2,1,$1|, :param$2 p$2@]) \
1029 { SH_HANDLEFUNC((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@]), rettype); } \
1030 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1031 (static_cast<rettype (ifacetype::*)(@[$2,1,$1|, :param$2@]) attr>(&ifacetype::ifacefunc))) \
1033 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \
1034 const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \
1035 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { $1, __SH_GPI(rettype), \
1036 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0, __SH_EPI, __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload };
1038 #define SH_DECL_EXTERN$1(ifacetype, ifacefunc, attr, overload, rettype@[$2,1,$1:, param$2@]) \
1039 int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
1040 fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> handler); \
1041 bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \
1042 fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> handler);
1044 #define SH_DECL_HOOK$1_void(ifacetype, ifacefunc, attr, overload@[$2,1,$1:, param$2@]) \
1045 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(@[$2,1,$1|, :param$2@]) attr> \
1046 (&ifacetype::ifacefunc))) \
1047 typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> FD; \
1048 MAKE_DELEG_void((@[$2,1,$1|, :param$2 p$2@]), (@[$2,1,$1|, :p$2@])); \
1049 virtual void Func(@[$2,1,$1|, :param$2 p$2@]) \
1050 { SH_HANDLEFUNC_void((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@])); } \
1051 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1052 (static_cast<void (ifacetype::*)(@[$2,1,$1|, :param$2@]) attr>(&ifacetype::ifacefunc))) \
1054 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {1, 0, 0}@[$2,1,$1:,__SH_GPI(param$2)@] }; \
1055 const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \
1056 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { $1, { 0, 0, 0 }, \
1057 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0, __SH_EPI, __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload };
1059 #define SH_DECL_EXTERN$1_void(ifacetype, ifacefunc, attr, overload@[$2,1,$1:, param$2@]) \
1060 int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
1061 fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> handler); \
1062 bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \
1063 fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> handler);
1065 #define SH_DECL_HOOK$1_vafmt(ifacetype, ifacefunc, attr, overload, rettype@[$2,1,$1:, param$2@]) \
1066 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, ...) attr> \
1067 (&ifacetype::ifacefunc))) \
1068 typedef fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, rettype> FD; \
1069 MAKE_DELEG(rettype, (@[$2,1,$1|, :param$2 p$2@]@[$1!=0:, @]const char *px), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]px)); \
1070 virtual rettype Func(@[$2,1,$1|, :param$2 p$2@] @[$1!=0:, @]const char *fmt, ...) \
1072 __SH_VAFMT_SEQ(fmt, buf); \
1073 SH_HANDLEFUNC_vafmt((@[$2,1,$1:param$2, @]const char *, ...), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]"%s", buf), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]buf), rettype); \
1075 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1076 (static_cast<rettype (ifacetype::*)(@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, ...) attr>(&ifacetype::ifacefunc))) \
1078 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \
1079 const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \
1080 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { $1, __SH_GPI(rettype), \
1081 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0, __SH_EPI, __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload };
1083 #define SH_DECL_EXTERN$1_vafmt(ifacetype, ifacefunc, attr, overload, rettype@[$2,1,$1:, param$2@]) \
1084 int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
1085 fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, rettype> handler); \
1086 bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \
1087 fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, rettype> handler);
1089 #define SH_DECL_HOOK$1_void_vafmt(ifacetype, ifacefunc, attr, overload@[$2,1,$1:, param$2@]) \
1090 SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, ...) attr> \
1091 (&ifacetype::ifacefunc))) \
1092 typedef fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *> FD; \
1093 MAKE_DELEG_void((@[$2,1,$1|, :param$2 p$2@]@[$1!=0:, @]const char *px), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]px)); \
1094 virtual void Func(@[$2,1,$1|, :param$2 p$2@]@[$1!=0:, @]const char *fmt, ...) \
1096 __SH_VAFMT_SEQ(fmt, buf); \
1097 SH_HANDLEFUNC_void_vafmt((@[$2,1,$1:param$2, @]const char *, ...), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]"%s", buf), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]buf)); \
1099 SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
1100 (static_cast<void (ifacetype::*)(@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, ...) attr>(&ifacetype::ifacefunc))) \
1102 const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \
1103 const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \
1104 ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { $1, { 0, 0, 0 }, \
1105 __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0, __SH_EPI, __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload };
1107 #define SH_DECL_EXTERN$1_void_vafmt(ifacetype, ifacefunc, attr, overload@[$2,1,$1:, param$2@]) \
1108 int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
1109 fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *> handler); \
1110 bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \
1111 fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *> handler);
1113 #define SH_DECL_MANUALHOOK$1(hookname, vtblidx, vtbloffs, thisptroffs, rettype@[$2,1,$1:, param$2@]) \
1114 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1115 typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> FD; \
1116 MAKE_DELEG(rettype, (@[$2,1,$1|, :param$2 p$2@]), (@[$2,1,$1|, :p$2@])); \
1117 virtual rettype Func(@[$2,1,$1|, :param$2 p$2@]) \
1118 { SH_HANDLEFUNC((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@]), rettype); } \
1119 typedef rettype(::SourceHook::EmptyClass::*ECMFP)(@[$2,1,$1|, :param$2@]); \
1120 typedef SourceHook::ExecutableClass$1< ::SourceHook::EmptyClass, ECMFP, rettype@[$2,1,$1:, param$2@] > CallEC; \
1121 typedef rettype RetType; \
1122 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1124 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \
1125 const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2M_##hookname[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \
1126 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { $1, __SH_GPI(rettype), \
1127 __SourceHook_ParamInfosM_##hookname, 0, __SH_EPI, __SourceHook_ParamInfos2M_##hookname }; \
1128 void __SoureceHook_FHM_SetOverrideResult##hookname(::SourceHook::ISourceHook *shptr, rettype value) \
1130 ::SourceHook::SetOverrideResult<SH_MFHCls(hookname)::RetType>(shptr, value); \
1133 #define SH_DECL_MANUALEXTERN$1(hookname, rettype@[$2,1,$1:, param$2@]) \
1134 int __SourceHook_FHMAdd##hookname(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
1135 fastdelegate::FastDelegate$1<@[$2,1,$1:param$2, @]rettype> handler); \
1136 bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \
1137 fastdelegate::FastDelegate$1<@[$2,1,$1:param$2, @]rettype> handler); \
1138 rettype(::SourceHook::EmptyClass::* __SoureceHook_FHM_GetRecallMFP##hookname(::SourceHook::EmptyClass *thisptr) )(@[$2,1,$1|, :param$2@]); \
1139 SourceHook::ExecutableClass$1<SourceHook::EmptyClass, rettype(::SourceHook::EmptyClass::*)(@[$2,1,$1|, :param$2@]), rettype@[$2,1,$1:, param$2@]> __SoureceHook_FHM_SHCall##hookname(void *ptr); \
1140 void __SoureceHook_FHM_SetOverrideResult##hookname(::SourceHook::ISourceHook *shptr, rettype res); \
1141 void __SourceHook_FHM_Reconfigure##hookname(int pvtblindex, int pvtbloffs, int pthisptroffs);
1143 #define SH_DECL_MANUALHOOK$1_vafmt(hookname, vtblidx, vtbloffs, thisptroffs, rettype@[$2,1,$1:, param$2@]) \
1144 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1145 typedef fastdelegate::FastDelegate@($1+1)<@[$2,1,$1:param$2, @]const char *, rettype> FD; \
1146 MAKE_DELEG(rettype, (@[$2,1,$1:param$2 p$2, @]const char *px), (@[$2,1,$1:p$2, @]px)); \
1147 virtual rettype Func(@[$2,1,$1:param$2 p$2, @]const char *fmt, ...) \
1149 __SH_VAFMT_SEQ(fmt, buf); \
1150 SH_HANDLEFUNC_vafmt((@[$2,1,$1:param$2, @]const char *, ...), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]"%s", buf), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]buf), rettype); \
1152 typedef rettype(::SourceHook::EmptyClass::*ECMFP)(@[$2,1,$1:param$2, @]const char *, ...); \
1153 typedef SourceHook::ExecutableClass@($1+1)< ::SourceHook::EmptyClass, ECMFP, rettype@[$2,1,$1:, param$2@], const char * > CallEC; \
1154 typedef rettype RetType; \
1155 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1157 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \
1158 const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2M_##hookname[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \
1159 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { $1, __SH_GPI(rettype), \
1160 __SourceHook_ParamInfosM_##hookname, 0, __SH_EPI, __SourceHook_ParamInfos2M_##hookname }; \
1161 void __SoureceHook_FHM_SetOverrideResult##hookname(::SourceHook::ISourceHook *shptr, rettype value) \
1163 ::SourceHook::SetOverrideResult<SH_MFHCls(hookname)::RetType>(shptr, value); \
1166 #define SH_DECL_MANUALEXTERN$1_vafmt(hookname, rettype@[$2,1,$1:, param$2@]) \
1167 int __SourceHook_FHMAdd##hookname(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
1168 fastdelegate::FastDelegate@($1+1)<@[$2,1,$1:param$2, @]const char *, rettype> handler); \
1169 bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \
1170 fastdelegate::FastDelegate@($1+1)<@[$2,1,$1:param$2, @]const char *, rettype> handler); \
1171 rettype(::SourceHook::EmptyClass::* __SoureceHook_FHM_GetRecallMFP##hookname(::SourceHook::EmptyClass *thisptr) )(@[$2,1,$1:param$2, @]const char *, ...); \
1172 SourceHook::ExecutableClass@($1+1)<SourceHook::EmptyClass, rettype(::SourceHook::EmptyClass::*)(@[$2,1,$1:param$2, @]const char *, ...), rettype@[$2,1,$1:, param$2@], const char*> __SoureceHook_FHM_SHCall##hookname(void *ptr); \
1173 void __SoureceHook_FHM_SetOverrideResult##hookname(::SourceHook::ISourceHook *shptr, rettype res); \
1174 void __SourceHook_FHM_Reconfigure##hookname(int pvtblindex, int pvtbloffs, int pthisptroffs);
1176 #define SH_DECL_MANUALHOOK$1_void(hookname, vtblidx, vtbloffs, thisptroffs@[$2,1,$1:, param$2@]) \
1177 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1178 typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> FD; \
1179 MAKE_DELEG_void((@[$2,1,$1|, :param$2 p$2@]), (@[$2,1,$1|, :p$2@])); \
1180 virtual void Func(@[$2,1,$1|, :param$2 p$2@]) \
1181 { SH_HANDLEFUNC_void((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@])); } \
1182 typedef void(::SourceHook::EmptyClass::*ECMFP)(@[$2,1,$1|, :param$2@]); \
1183 typedef SourceHook::ExecutableClass$1<SourceHook::EmptyClass, ECMFP, void@[$2,1,$1:, param$2@]> CallEC; \
1184 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1186 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \
1187 const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2M_##hookname[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \
1188 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { $1, { 0, 0, 0 }, \
1189 __SourceHook_ParamInfosM_##hookname , 0, __SH_EPI, __SourceHook_ParamInfos2M_##hookname };
1191 #define SH_DECL_MANUALEXTERN$1_void(hookname@[$2,1,$1:, param$2@]) \
1192 int __SourceHook_FHMAdd##hookname(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
1193 fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> handler); \
1194 bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \
1195 fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> handler); \
1196 void(::SourceHook::EmptyClass::* __SoureceHook_FHM_GetRecallMFP##hookname(::SourceHook::EmptyClass *thisptr) )(@[$2,1,$1|, :param$2@]); \
1197 SourceHook::ExecutableClass$1<SourceHook::EmptyClass, void(::SourceHook::EmptyClass::*)(@[$2,1,$1|, :param$2@]), void@[$2,1,$1:, param$2@]> __SoureceHook_FHM_SHCall##hookname(void *ptr); \
1198 void __SourceHook_FHM_Reconfigure##hookname(int pvtblindex, int pvtbloffs, int pthisptroffs);
1200 #define SH_DECL_MANUALHOOK$1_void_vafmt(hookname, vtblidx, vtbloffs, thisptroffs@[$2,1,$1:, param$2@]) \
1201 SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1202 typedef fastdelegate::FastDelegate@($1+1)<@[$2,1,$1:param$2, @]const char *> FD; \
1203 MAKE_DELEG_void((@[$2,1,$1:param$2 p$2, @]const char *px), (@[$2,1,$1:p$2, @]px)); \
1204 virtual void Func(@[$2,1,$1:param$2 p$2, @]const char *fmt, ...) \
1206 __SH_VAFMT_SEQ(fmt, buf); \
1207 SH_HANDLEFUNC_void_vafmt((@[$2,1,$1:param$2, @]const char *, ...), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]"%s", buf), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]buf)); \
1209 typedef void(::SourceHook::EmptyClass::*ECMFP)(@[$2,1,$1:param$2, @]const char *, ...); \
1210 typedef SourceHook::ExecutableClass@($1+1)< ::SourceHook::EmptyClass, ECMFP, void@[$2,1,$1:, param$2@], const char * > CallEC; \
1211 SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
1213 const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \
1214 const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2M_##hookname[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \
1215 ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { $1, { 0, 0, 0 }, \
1216 __SourceHook_ParamInfosM_##hookname , 0, __SH_EPI, __SourceHook_ParamInfos2M_##hookname };
1218 #define SH_DECL_MANUALEXTERN$1_void_vafmt(hookname@[$2,1,$1:, param$2@]) \
1219 int __SourceHook_FHMAdd##hookname(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \
1220 fastdelegate::FastDelegate@($1+1)<@[$2,1,$1:param$2, @]const char *> handler); \
1221 bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \
1222 fastdelegate::FastDelegate@($1+1)<@[$2,1,$1:param$2, @]const char *> handler); \
1223 void(::SourceHook::EmptyClass::* __SoureceHook_FHM_GetRecallMFP##hookname(::SourceHook::EmptyClass *thisptr) )(@[$2,1,$1:param$2, @]const char *, ...); \
1224 SourceHook::ExecutableClass@($1+1)<SourceHook::EmptyClass, void(::SourceHook::EmptyClass::*)(@[$2,1,$1:param$2, @]const char *, ...), void@[$2,1,$1:, param$2@], const char*> __SoureceHook_FHM_SHCall##hookname(void *ptr); \
1225 void __SourceHook_FHM_Reconfigure##hookname(int pvtblindex, int pvtbloffs, int pthisptroffs);
1229 //////////////////////////////////////////////////////////////////////////
1232 #define SH_MAKE_EXECUTABLECLASS_OB(call, prms) \
1234 using namespace ::SourceHook; \
1236 m_pSH->SetIgnoreHooks(m_VfnPtr); \
1237 RetType tmpret = (m_ThisPtr->*m_MFP)call; \
1238 m_pSH->ResetIgnoreHooks(m_VfnPtr); \
1242 #define SH_MAKE_EXECUTABLECLASS_OB_void(call, prms) \
1244 using namespace ::SourceHook; \
1246 m_pSH->SetIgnoreHooks(m_VfnPtr); \
1247 (m_ThisPtr->*m_MFP)call; \
1248 m_pSH->ResetIgnoreHooks(m_VfnPtr); \
1251 namespace SourceHook
1254 // Support for $1 arguments
1255 template<class ObjType, class MFPType, class RetType@[$2,1,$1:, class Param$2@]> class ExecutableClass$1
1262 ExecutableClass$1(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
1263 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
1265 RetType operator()(@[$2,1,$1|, :Param$2 p$2@]) const
1266 SH_MAKE_EXECUTABLECLASS_OB((@[$2,1,$1|, :p$2@]), (@[$2,1,$1|, :Param$2@]))
1269 template <@[$3,$1+1,$2|, :class Param$3@]> RetType operator()(@[$3,1,$2|, :Param$3 p$3@]) const
1270 SH_MAKE_EXECUTABLECLASS_OB((@[$3,1,$2|, :p$3@]), (@[$3,1,$2|, :Param$3@]))
1274 template<class ObjType, class MFPType@[$2,1,$1:, class Param$2@]> class ExecutableClass$1<ObjType, MFPType, void@[$2,1,$1:, Param$2@]>
1281 ExecutableClass$1(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp),
1282 m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { }
1284 void operator()(@[$2,1,$1|, :Param$2 p$2@]) const
1285 SH_MAKE_EXECUTABLECLASS_OB_void((@[$2,1,$1|, :p$2@]), (@[$2,1,$1|, :Param$2@]))
1288 template <@[$3,$1+1,$2|, :class Param$3@]> void operator()(@[$3,1,$2|, :Param$3 p$3@]) const
1289 SH_MAKE_EXECUTABLECLASS_OB_void((@[$3,1,$2|, :p$3@]), (@[$3,1,$2|, :Param$3@]))
1296 #define SH__CALL_GET_VFNPTR_NORMAL \
1297 using namespace ::SourceHook; \
1298 MemFuncInfo mfi = {true, -1, 0, 0}; \
1299 GetFuncInfo(ptr, mfp, mfi); \
1300 void *vfnptr = reinterpret_cast<void*>( \
1301 *reinterpret_cast<void***>(reinterpret_cast<char*>(ptr) + mfi.thisptroffs + mfi.vtbloffs) + mfi.vtblindex);
1303 #define SH__CALL_GET_VFNPTR_MANUAL \
1304 using namespace ::SourceHook; \
1305 void *vfnptr = reinterpret_cast<void*>( \
1306 *reinterpret_cast<void***>( (reinterpret_cast<char*>(ptr) + thisptroffs + vtbloffs) ) + vtblidx); \
1308 *reinterpret_cast<void**>(&mfp) = *reinterpret_cast<void**>(vfnptr);
1310 // SH_CALL needs to deduce the return type -> it uses templates and function overloading
1311 // That's why SH_CALL takes two parameters: "mfp2" of type RetType(X::*mfp)(params), and "mfp" of type MFP
1312 // The only purpose of the mfp2 parameter is to extract the return type
1315 // Support for $1 arguments
1316 template <class X, class Y, class MFP, class RetType@[$2,1,$1:, class Param$2@]>
1317 SourceHook::ExecutableClass$1<Y, MFP, RetType@[$2,1,$1:, Param$2@]>
1318 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]), SourceHook::ISourceHook *shptr)
1320 SH__CALL_GET_VFNPTR_NORMAL
1321 return SourceHook::ExecutableClass$1<Y, MFP, RetType@[$2,1,$1:, Param$2@]>(ptr, mfp, vfnptr, shptr);
1324 template <class X, class Y, class MFP, class RetType@[$2,1,$1:, class Param$2@]>
1325 SourceHook::ExecutableClass$1<Y, MFP, RetType@[$2,1,$1:, Param$2@]>
1326 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@])const, SourceHook::ISourceHook *shptr)
1328 SH__CALL_GET_VFNPTR_NORMAL
1329 return SourceHook::ExecutableClass$1<Y, MFP, RetType@[$2,1,$1:, Param$2@]>(ptr, mfp, vfnptr, shptr);
1332 template <class X, class Y, class MFP, class RetType@[$2,1,$1:, class Param$2@]>
1333 SourceHook::ExecutableClass$1<SourceHook::EmptyClass, MFP, RetType@[$2,1,$1:, Param$2@]>
1334 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr)
1336 SH__CALL_GET_VFNPTR_MANUAL
1337 return SourceHook::ExecutableClass$1<EmptyClass, MFP, RetType@[$2,1,$1:, Param$2@]>(
1338 reinterpret_cast<SourceHook::EmptyClass*>(ptr), mfp, vfnptr, shptr);
1342 #if SH_COMP != SH_COMP_MSVC || _MSC_VER > 1300
1343 // GCC & MSVC 7.1 need this, MSVC 7.0 doesn't like it
1346 // Support for $1 arguments
1347 template <class X, class Y, class MFP, class RetType@[$2,1,$1:, class Param$2@]>
1348 SourceHook::ExecutableClass$1<Y, MFP, RetType@[$2,1,$1:, Param$2@]>
1349 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]@[$1!=0:, @]...), SourceHook::ISourceHook *shptr)
1351 SH__CALL_GET_VFNPTR_NORMAL
1352 return SourceHook::ExecutableClass$1<Y, MFP, RetType@[$2,1,$1:, Param$2@]>(ptr, mfp, vfnptr, shptr);
1355 template <class X, class Y, class MFP, class RetType@[$2,1,$1:, class Param$2@]>
1356 SourceHook::ExecutableClass$1<Y, MFP, RetType@[$2,1,$1:, Param$2@]>
1357 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]@[$1!=0:, @]...)const, SourceHook::ISourceHook *shptr)
1359 SH__CALL_GET_VFNPTR_NORMAL
1360 return SourceHook::ExecutableClass$1<Y, MFP, RetType@[$2,1,$1:, Param$2@]>(ptr, mfp, vfnptr, shptr);
1367 #define SH_CALL(ptr, mfp) SH_CALL2((ptr), (mfp), (mfp), SH_GLOB_SHPTR)
1368 #define SH_MCALL2(ptr, mfp, vtblidx, vtbloffs, thisptroffs) SH_MCALL3((ptr), (mfp), (mfp), (vtblidx), (vtbloffs), (thisptroffs), SH_GLOB_SHPTR)
1369 #define SH_MCALL(ptr, mhookname) __SoureceHook_FHM_SHCall##mhookname(ptr)
1371 #undef SH_MAKE_EXECUTABLECLASS_OB
1372 #undef SH_MAKE_EXECUTABLECLASS_OB_void
1374 //////////////////////////////////////////////////////////////////////////
1375 // SetOverrideRet and RecallGetIface for recalls
1376 // These take a ISourceHook pointer instead of using SH_GLOB_SHPTR directly
1377 // The reason is that the user may want to redefine SH_GLOB_SHPTR - then the macros
1378 // (META_RETURN_VALUE_NEWPARAMS) should obey the new pointer.
1380 namespace SourceHook
1382 template <class RetType>
1383 void SetOverrideResult(ISourceHook *shptr, const RetType res)
1385 *reinterpret_cast<RetType*>(shptr->GetOverrideRetPtr()) = res;
1388 // SetOverrideResult used to be implemented like this:
1389 // SetOverrideResult(shptr, memfuncptr, return);
1390 // normally the compiler can deduce the return type from memfuncptr, but (at least msvc8) failed when it was a reference
1391 // (it thought it was ambigous - the ref and non-ref type)
1392 // so now SetOverrideResult(memfuncptr) deduces the ret type, and returns a functor which does the work
1393 // new syntax: SetOverrideResult(memfuncptr)(shptr, return)
1394 // This also allows us to create a special version for references which respects ReferenceCarrier.
1396 template <class T> struct OverrideFunctor
1398 void operator()(ISourceHook *shptr, T res)
1400 *reinterpret_cast<T*>(shptr->GetOverrideRetPtr()) = res;
1403 template <class T> struct OverrideFunctor<T&>
1405 void operator()(ISourceHook *shptr, T &res)
1407 // overrideretptr points to ReferenceCarrier<T&>
1408 *reinterpret_cast<typename ReferenceCarrier<T&>::type *>(shptr->GetOverrideRetPtr()) = res;
1412 template <class Iface, class RetType@[$2,1,$1:, class Param$2@]>
1413 OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(@[$2,1,$1|, :Param$2@]))
1415 return OverrideFunctor<RetType>();
1418 template <class Iface, class RetType@[$2,1,$1:, class Param$2@]>
1419 Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(@[$2,1,$1|, :Param$2@]))
1421 return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
1427 // The pope is dead. -> :(