dvander@541: /* ======== SourceHook ======== dvander@659: * Copyright (C) 2004-2007 Metamod:Source Development Team dvander@541: * No warranties of any kind dvander@541: * dvander@541: * License: zlib/libpng dvander@541: * dvander@541: * Author(s): Pavol "PM OnoTo" Marko dvander@541: * ============================ dvander@541: */ dvander@541: dvander@541: /** dvander@541: * @file sourcehook.h dvander@541: * @brief Contains the public SourceHook API dvander@541: */ dvander@541: dvander@541: #ifndef __SOURCEHOOK_H__ dvander@541: #define __SOURCEHOOK_H__ dvander@541: dvander@541: // Interface revisions: dvander@541: // 1 - Initial revision dvander@541: // 2 - Changed to virtual functions for iterators and all queries dvander@541: // 3 - Added "hook loop status variable" dvander@541: // 4 - Reentrant dvander@541: #define SH_IFACE_VERSION 4 dvander@659: dvander@659: // Impl versions: dvander@659: // ??? dvander@659: // 4 - addition of hook ids and vp hooks (with them, AddHookNew and RemoveHookNew) dvander@659: // This is not a SH_IFACE_VERSION change so that old plugins continue working! dvander@659: // 5 - addition of direct vp hooks (new hook mode; from now on AddHookNew checks for dvander@659: // invalid hookmode -> impl version won't have to change because of things like this) dvander@659: #define SH_IMPL_VERSION 5 dvander@541: dvander@541: // Hookman version: dvander@541: // 1 - Support for recalls, performance optimisations dvander@541: #define SH_HOOKMAN_VERSION 1 dvander@541: dvander@541: // The value of SH_GLOB_SHPTR has to be a pointer to SourceHook::ISourceHook dvander@541: // It's used in various macros dvander@541: #ifndef SH_GLOB_SHPTR dvander@541: #define SH_GLOB_SHPTR g_SHPtr dvander@541: #endif dvander@541: dvander@541: // Used to identify the current plugin dvander@541: #ifndef SH_GLOB_PLUGPTR dvander@541: #define SH_GLOB_PLUGPTR g_PLID dvander@541: #endif dvander@541: dvander@541: #ifdef SH_DEBUG dvander@541: # include dvander@541: # include dvander@541: dvander@541: # define SH_ASSERT(x, info) \ dvander@541: do { \ dvander@541: if (!(x)) \ dvander@541: { \ dvander@541: printf("SOURCEHOOK DEBUG ASSERTION FAILED: %s:%u(%s): %s: ", __FILE__, __LINE__, __FUNCTION__, #x); \ dvander@541: printf info; \ dvander@541: putchar('\n'); \ dvander@541: abort(); \ dvander@541: } \ dvander@541: } while(0) dvander@541: dvander@541: #else dvander@541: # define SH_ASSERT(x, info) dvander@541: #endif dvander@541: dvander@541: // System dvander@541: #define SH_SYS_WIN32 1 dvander@541: #define SH_SYS_LINUX 2 dvander@541: dvander@541: #ifdef _WIN32 dvander@541: # define SH_SYS SH_SYS_WIN32 dvander@541: #elif defined __linux__ dvander@541: # define SH_SYS SH_SYS_LINUX dvander@541: #else dvander@541: # error Unsupported system dvander@541: #endif dvander@541: dvander@541: // Compiler dvander@541: #define SH_COMP_GCC 1 dvander@541: #define SH_COMP_MSVC 2 dvander@541: dvander@541: #ifdef _MSC_VER dvander@541: # define SH_COMP SH_COMP_MSVC dvander@541: #elif defined __GNUC__ dvander@541: # define SH_COMP SH_COMP_GCC dvander@541: #else dvander@541: # error Unsupported compiler dvander@541: #endif dvander@541: ds@680: #if SH_COMP==SH_COMP_MSVC && _MSC_VER < 1500 dvander@541: # define vsnprintf _vsnprintf dvander@541: #endif dvander@541: dvander@541: #if SH_SYS != SH_SYS_WIN32 dvander@541: # include dvander@541: #endif dvander@541: dvander@541: #define SH_PTRSIZE sizeof(void*) dvander@541: dvander@541: #include "FastDelegate.h" dvander@541: #include "sh_memfuncinfo.h" dvander@541: dvander@541: // Good old metamod! dvander@541: dvander@541: // Flags returned by a plugin's api function. dvander@541: // NOTE: order is crucial, as greater/less comparisons are made. dvander@541: enum META_RES dvander@541: { dvander@541: MRES_IGNORED=0, // plugin didn't take any action dvander@541: MRES_HANDLED, // plugin did something, but real function should still be called dvander@541: MRES_OVERRIDE, // call real function, but use my return value dvander@541: MRES_SUPERCEDE // skip real function; use my return value dvander@541: }; dvander@541: dvander@541: dvander@541: namespace SourceHook dvander@541: { dvander@541: /** dvander@541: * @brief Specifies the size (in bytes) for the internal buffer of vafmt(printf-like) function handlers dvander@541: */ dvander@541: const int STRBUF_LEN=4096; dvander@541: dvander@541: /** dvander@541: * @brief An empty class. No inheritance used. Used for original-function-call hacks dvander@541: */ dvander@541: class EmptyClass dvander@541: { dvander@541: }; dvander@541: dvander@541: /** dvander@541: * @brief Implicit cast. dvander@541: */ dvander@541: template dvander@541: inline Out implicit_cast(In input) dvander@541: { dvander@541: return input; dvander@541: } dvander@541: dvander@541: /** dvander@541: * @brief A plugin typedef dvander@541: * dvander@541: * SourceHook doesn't really care what this is. As long as the ==, != and = operators work on it and every dvander@541: * plugin has a unique identifier, everything is ok. dvander@541: * It should also be possible to set it to 0. dvander@541: */ dvander@541: typedef int Plugin; dvander@541: dvander@541: struct ProtoInfo dvander@541: { dvander@541: ProtoInfo(int rtsz, int nop, const int *p) : beginningNull(0), retTypeSize(rtsz), numOfParams(nop), params(p) dvander@541: { dvander@541: } dvander@541: int beginningNull; //!< To distinguish from old protos (which never begin with 0) dvander@541: int retTypeSize; //!< 0 if void dvander@541: int numOfParams; //!< number of parameters dvander@541: const int *params; //!< params[0]=0 (or -1 for vararg), params[1]=size of first param, ... dvander@541: }; dvander@541: dvander@541: /** dvander@541: * @brief Specifies the actions for hook managers dvander@541: */ dvander@541: enum HookManagerAction dvander@541: { dvander@541: HA_GetInfo = 0, //!< Store info about the hook manager dvander@541: HA_Register, //!< Save the IHookManagerInfo pointer for future reference dvander@541: HA_Unregister //!< Clear the saved pointer dvander@541: }; dvander@541: dvander@541: struct IHookManagerInfo; dvander@541: dvander@541: /** dvander@541: * @brief Pointer to hook manager interface function dvander@541: * dvander@541: * A "hook manager" is a the only thing that knows the actual protoype of the function at compile time. dvander@541: * dvander@541: * @param ha What the hook manager should do dvander@541: * @param hi A pointer to IHookManagerInfo dvander@541: */ dvander@541: typedef int (*HookManagerPubFunc)(HookManagerAction ha, IHookManagerInfo *hi); dvander@541: dvander@541: class ISHDelegate dvander@541: { dvander@541: public: dvander@541: virtual void DeleteThis() = 0; // Ugly, I know dvander@541: virtual bool IsEqual(ISHDelegate *other) = 0; dvander@541: }; dvander@541: dvander@541: template class CSHDelegate : public ISHDelegate dvander@541: { dvander@541: T m_Deleg; dvander@541: public: dvander@541: CSHDelegate(T deleg) : m_Deleg(deleg) dvander@541: { dvander@541: } dvander@541: dvander@541: CSHDelegate(const CSHDelegate &other) : m_Deleg(other.m_Deleg) dvander@541: { dvander@541: } dvander@541: dvander@541: void DeleteThis() dvander@541: { dvander@541: delete this; dvander@541: } dvander@541: dvander@541: bool IsEqual(ISHDelegate *other) dvander@541: { dvander@541: return static_cast* >(other)->GetDeleg() == GetDeleg(); dvander@541: } dvander@541: dvander@541: T &GetDeleg() dvander@541: { dvander@541: return m_Deleg; dvander@541: } dvander@541: }; dvander@541: dvander@541: struct IHookList dvander@541: { dvander@541: struct IIter dvander@541: { dvander@541: virtual bool End() = 0; dvander@541: virtual void Next() = 0; dvander@541: virtual ISHDelegate *Handler() = 0; dvander@541: virtual int ThisPtrOffs() = 0; dvander@541: }; dvander@541: virtual IIter *GetIter() = 0; dvander@541: virtual void ReleaseIter(IIter *pIter) = 0; dvander@541: }; dvander@541: dvander@541: struct IIface dvander@541: { dvander@541: virtual void *GetPtr() = 0; dvander@541: virtual IHookList *GetPreHooks() = 0; dvander@541: virtual IHookList *GetPostHooks() = 0; dvander@541: }; dvander@541: dvander@541: struct IVfnPtr dvander@541: { dvander@541: virtual void *GetVfnPtr() = 0; dvander@541: virtual void *GetOrigEntry() = 0; dvander@541: dvander@541: virtual IIface *FindIface(void *ptr) = 0; dvander@541: }; dvander@541: dvander@541: struct IHookManagerInfo dvander@541: { dvander@541: virtual IVfnPtr *FindVfnPtr(void *vfnptr) = 0; dvander@541: dvander@541: virtual void SetInfo(int vtbloffs, int vtblidx, const char *proto) = 0; dvander@541: virtual void SetHookfuncVfnptr(void *hookfunc_vfnptr) = 0; dvander@541: dvander@541: // Added 23.12.2005 (yup! I'm coding RIGHT BEFORE CHRISTMAS!) dvander@541: // If the hookman doesn't set this, it defaults 0 dvander@541: // SourceHook prefers hookmans with higher version numbers dvander@541: virtual void SetVersion(int version) = 0; dvander@541: }; dvander@541: dvander@541: class AutoHookIter dvander@541: { dvander@541: IHookList *m_pList; dvander@541: IHookList::IIter *m_pIter; dvander@541: public: dvander@541: AutoHookIter(IHookList *pList) dvander@541: : m_pList(pList), m_pIter(pList->GetIter()) dvander@541: { dvander@541: } dvander@541: dvander@541: ~AutoHookIter() dvander@541: { dvander@541: if (m_pList) dvander@541: m_pList->ReleaseIter(m_pIter); dvander@541: } dvander@541: dvander@541: bool End() dvander@541: { dvander@541: return m_pIter->End(); dvander@541: } dvander@541: dvander@541: void Next() dvander@541: { dvander@541: m_pIter->Next(); dvander@541: } dvander@541: dvander@541: ISHDelegate *Handler() dvander@541: { dvander@541: return m_pIter->Handler(); dvander@541: } dvander@541: dvander@541: int ThisPtrOffs() dvander@541: { dvander@541: return m_pIter->ThisPtrOffs(); dvander@541: } dvander@541: dvander@541: void SetToZero() dvander@541: { dvander@541: m_pList = 0; dvander@541: } dvander@541: }; dvander@541: dvander@659: template struct DeprecatedCallClass dvander@541: { dvander@541: virtual B *GetThisPtr() = 0; dvander@541: virtual void *GetOrigFunc(int vtbloffs, int vtblidx) = 0; dvander@541: }; dvander@541: dvander@541: // 09.08.2008 (6 AM, I just woke up, the others are still sleeping so i finally can use this notebook !!) dvander@541: // - Today is an important day. dvander@541: // I'm adding support for functions which return references. dvander@541: dvander@541: // How it works: dvander@541: // SH_SETUPCALLS doesn't use plain rettype to store the temporary return values (plugin ret, orig ret, dvander@541: // override ret) anymore; instead, it uses SourceHook::ReferenceCarrier::type dvander@541: // this is typedefed to the original rettype normally, but if the rettype is a reference, it's a special class dvander@541: // which stores the reference as a pointer, and implements constructors, operator= and a conversion operator. dvander@541: // special cases were needed for getoverrideret / getorigret; these are implemented through the dvander@541: // SourceHook::MacroRefHelpers structs. dvander@541: // Furthermore, SetOverrideRet had to be changed a bit; see SourceHook::OverrideFunctor somewhere down in this file. dvander@541: template struct ReferenceCarrier dvander@541: { dvander@541: typedef T type; dvander@541: }; dvander@541: dvander@541: template struct ReferenceCarrier dvander@541: { dvander@541: class type dvander@541: { dvander@541: T *m_StoredRef; dvander@541: public: dvander@541: type() : m_StoredRef(NULL) dvander@541: { dvander@541: } dvander@541: type(T& ref) : m_StoredRef(&ref) dvander@541: { dvander@541: } dvander@541: dvander@541: T& operator= (T& ref) dvander@541: { dvander@541: m_StoredRef = &ref; dvander@541: return ref; dvander@541: } dvander@541: dvander@541: operator T& () const dvander@541: { dvander@541: return *m_StoredRef; dvander@541: } dvander@541: }; dvander@541: }; dvander@541: dvander@541: /** dvander@541: * @brief The main SourceHook interface dvander@541: */ dvander@541: class ISourceHook dvander@541: { dvander@541: public: dvander@541: /** dvander@541: * @brief Return interface version dvander@541: */ dvander@541: virtual int GetIfaceVersion() = 0; dvander@541: dvander@541: /** dvander@541: * @brief Return implementation version dvander@541: */ dvander@541: virtual int GetImplVersion() = 0; dvander@541: dvander@541: /** dvander@541: * @brief Add a hook. dvander@541: * dvander@541: * @return True if the function succeeded, false otherwise dvander@541: * dvander@541: * @param plug The unique identifier of the plugin that calls this function dvander@541: * @param iface The interface pointer dvander@541: * @param ifacesize The size of the class iface points to dvander@541: * @param myHookMan A hook manager function that should be capable of handling the function dvander@541: * @param handler A pointer to a FastDelegate containing the hook handler dvander@541: * @param post Set to true if you want a post handler dvander@541: */ dvander@541: virtual bool AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, dvander@541: ISHDelegate *handler, bool post) = 0; dvander@541: dvander@541: /** dvander@541: * @brief Removes a hook. dvander@541: * dvander@541: * @return True if the function succeeded, false otherwise dvander@541: * dvander@541: * @param plug The unique identifier of the plugin that calls this function dvander@541: * @param iface The interface pointer dvander@541: * @param myHookMan A hook manager function that should be capable of handling the function dvander@541: * @param handler A pointer to a FastDelegate containing the hook handler dvander@541: * @param post Set to true if you want a post handler dvander@541: */ dvander@541: virtual bool RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, dvander@541: ISHDelegate *handler, bool post) = 0; dvander@541: dvander@541: /** dvander@541: * @brief Checks whether a plugin has (a) hook manager(s) that is/are currently used by other plugins dvander@541: * dvander@541: * @param plug The unique identifier of the plugin in question dvander@541: */ dvander@541: virtual bool IsPluginInUse(Plugin plug) = 0; dvander@541: dvander@541: /** dvander@541: * @brief Return a pointer to a callclass. Generate a new one if required. dvander@541: * dvander@541: * @param iface The interface pointer dvander@541: * @param size Size of the class instance dvander@541: */ dvander@659: virtual DeprecatedCallClass *GetCallClass(void *iface, size_t size) = 0; dvander@541: dvander@541: /** dvander@541: * @brief Release a callclass dvander@541: * dvander@541: * @param ptr Pointer to the callclass dvander@541: */ dvander@659: virtual void ReleaseCallClass(DeprecatedCallClass *ptr) = 0; dvander@541: dvander@541: virtual void SetRes(META_RES res) = 0; //!< Sets the meta result dvander@541: virtual META_RES GetPrevRes() = 0; //!< Gets the meta result of the dvander@541: //!< previously calledhandler dvander@541: virtual META_RES GetStatus() = 0; //!< Gets the highest meta result dvander@541: virtual const void *GetOrigRet() = 0; //!< Gets the original result. dvander@541: //!< If not in post function, undefined dvander@541: virtual const void *GetOverrideRet() = 0; //!< Gets the override result. dvander@541: //!< If none is specified, NULL dvander@541: virtual void *GetIfacePtr() = 0; //!< Gets the interface pointer dvander@541: ////////////////////////////////////////////////////////////////////////// dvander@541: // For hook managers dvander@541: virtual void HookLoopBegin(IIface *pIface) = 0; //!< Should be called when a hook loop begins dvander@541: virtual void HookLoopEnd() = 0; //!< Should be called when a hook loop exits dvander@541: virtual void SetCurResPtr(META_RES *mres) = 0; //!< Sets pointer to the current meta result dvander@541: virtual void SetPrevResPtr(META_RES *mres) = 0; //!< Sets pointer to previous meta result dvander@541: virtual void SetStatusPtr(META_RES *mres) = 0; //!< Sets pointer to the status variable dvander@541: virtual void SetIfacePtrPtr(void **pp) = 0; //!< Sets pointer to the interface this pointer dvander@541: virtual void SetOrigRetPtr(const void *ptr) = 0; //!< Sets the original return pointer dvander@541: virtual void SetOverrideRetPtr(void *ptr) = 0; //!< Sets the override result pointer dvander@541: virtual bool ShouldContinue() = 0; //!< Returns false if the hook loop should exit dvander@541: dvander@541: /** dvander@541: * @brief Remove a hook manager. Auto-removes all hooks attached to it from plugin plug. dvander@541: * dvander@541: * @param plug The owner of the hook manager dvander@541: * @param pubFunc The hook manager's info function dvander@541: */ dvander@541: virtual void RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc) = 0; dvander@541: dvander@541: virtual void DoRecall() = 0; //!< Initiates a recall sequence dvander@541: /* dvander@541: HOW RECALLS WORK: dvander@541: dvander@541: The problem: dvander@541: Users want the ability to change parameters of the called function dvander@541: from inside their handler. dvander@541: The solution: dvander@541: 1) Mark as "recall" dvander@541: 2) Recall the function dvander@541: 3) => SH's hook func gets called: dvander@541: 4) The first iterator points at the first hook the last hookfunc didn't execute yet dvander@541: 5) does all iteration and returns normally dvander@541: 6) The user's handler returns immediately dvander@541: 7) The hook func returns immediately as well dvander@541: dvander@541: Also note that the recalled hookfunc starts with the status the recalling hookfunc dvander@541: ended with. The last handler (doing the recall) is also able to specify its own dvander@541: META_RES. dvander@541: */ dvander@541: dvander@541: virtual void *GetOverrideRetPtr() = 0; //!< Returns the pointer set by SetOverrideRetPtr dvander@541: dvander@541: /** dvander@541: * @brief Set up the hook loop. Equivalent to calling: dvander@541: * SetStatusPtr, SetPrevResPtr, SetCurResPtr, SetIfacePtrPtr, SetOrigRetPtr, Get/SetOverrideRetPtr dvander@541: * dvander@541: * @param statusPtr pointer to status variable dvander@541: * @param prevResPtr pointer to previous result variable dvander@541: * @param curResPtr pointer to current result variable dvander@541: * @param ifacePtrPtr pointer to interface this pointer variable dvander@541: * @param origRetPr pointer to original return value variable. NULL for void funcs dvander@541: * @param overrideRetPtr pointer to override return value variable. NULL for void funcs dvander@541: * dvander@541: * @return Override Return Pointer the hookfunc should use (may differ from overrideRetPtr dvander@541: * when the hook func is being called as part of a recall dvander@541: */ dvander@541: virtual void *SetupHookLoop(META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr, dvander@541: void **ifacePtrPtr, const void *origRetPtr, void *overrideRetPtr) = 0; dvander@541: dvander@659: /** dvander@659: * @brief Modes for the new AddHook dvander@659: */ dvander@659: enum AddHookMode dvander@659: { dvander@659: Hook_Normal, dvander@659: Hook_VP, dvander@659: Hook_DVP dvander@659: }; dvander@659: dvander@659: /** dvander@659: * @brief Add a (VP) hook. dvander@659: * dvander@659: * @return non-zero hook id on success, 0 otherwise dvander@659: * dvander@659: * @param plug The unique identifier of the plugin that calls this function dvander@659: * @param mode Can be either Hook_Normal or Hook_VP (vtable-wide hook) dvander@659: * @param iface The interface pointer dvander@659: * @param ifacesize The size of the class iface points to dvander@659: * @param myHookMan A hook manager function that should be capable of handling the function dvander@659: * @param handler A pointer to a FastDelegate containing the hook handler dvander@659: * @param post Set to true if you want a post handler dvander@659: */ dvander@659: virtual int AddHookNew(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, dvander@659: ISHDelegate *handler, bool post) = 0; dvander@659: dvander@659: /** dvander@659: * @brief Remove a VP hook by ID. dvander@659: * dvander@659: * @return true on success, false otherwise dvander@659: * dvander@659: * @param plug The unique identifier of the plugin that calls this function dvander@659: * @param hookid The hook id (returned by AddHookNew) dvander@659: */ dvander@659: virtual bool RemoveHookByID(Plugin plug, int hookid) = 0; dvander@659: dvander@659: /** dvander@659: * @brief Makes sure that hooks are going to be ignored on the next call of vfnptr dvander@659: * dvander@659: * @param plug The unique identifier of the plugin that calls this function dvander@659: * @param vfnptr The virtual function pointer of the function in question dvander@659: */ dvander@659: virtual void SetIgnoreHooks(Plugin plug, void *vfnptr) = 0; dvander@659: dvander@659: /** dvander@659: * @brief Reverses SetIgnoreHooks' effect dvander@659: * dvander@659: * @param plug The unique identifier of the plugin that calls this function dvander@659: * @param vfnptr The virtual function pointer of the function in question dvander@659: */ dvander@659: virtual void ResetIgnoreHooks(Plugin plug, void *vfnptr) = 0; dvander@659: dvander@659: /** dvander@659: * @brief Finds the original entry of a virtual function pointer dvander@659: * dvander@659: * @param vfnptr The virtual function pointer dvander@659: * @return The original entry if the virtual function pointer has been patched; NULL otherwise. dvander@659: */ dvander@659: virtual void *GetOrigVfnPtrEntry(void *vfnptr) = 0; dvander@541: }; dvander@541: dvander@541: // For META_RESULT_ORIG_RET and META_RESULT_OVERRIDE_RET: dvander@541: // These have to be able to return references. If T is a reference, the pointers returned dvander@541: // from the SH_GLOB_SHPTR are pointers to instances of ReferenceCarrier::type. dvander@541: template struct MacroRefHelpers dvander@541: { dvander@541: inline static const T* GetOrigRet(ISourceHook *shptr) dvander@541: { dvander@541: return reinterpret_cast(shptr->GetOrigRet()); dvander@541: } dvander@541: inline static const T* GetOverrideRet(ISourceHook *shptr) dvander@541: { dvander@541: return reinterpret_cast(shptr->GetOverrideRet()); dvander@541: } dvander@541: }; dvander@541: dvander@541: template struct MacroRefHelpers dvander@541: { dvander@541: inline static T* GetOrigRet(ISourceHook *shptr) dvander@541: { dvander@541: T &ref = *reinterpret_cast::type *>(shptr->GetOrigRet()); dvander@541: return &ref; dvander@541: } dvander@541: inline static T* GetOverrideRet(ISourceHook *shptr) dvander@541: { dvander@541: T &ref = *reinterpret_cast::type *>(shptr->GetOverrideRet()); dvander@541: return &ref; dvander@541: } dvander@541: }; dvander@659: dvander@659: // For source-level compatibility dvander@659: template struct CallClass dvander@659: { dvander@659: T *ptr; dvander@659: dvander@659: CallClass(T *p) : ptr(p) dvander@659: { dvander@659: } dvander@659: dvander@659: operator T*() dvander@659: { dvander@659: return ptr; dvander@659: } dvander@659: }; dvander@659: dvander@659: typedef CallClass GenericCallClass; dvander@659: typedef CallClass ManualCallClass; dvander@659: dvander@659: template dvander@659: CallClass *GetCallClass(T *p) dvander@659: { dvander@659: return new CallClass(p); dvander@659: } dvander@659: dvander@659: template dvander@659: void ReleaseCallClass(CallClass *p) dvander@659: { dvander@659: delete p; dvander@659: } dvander@659: dvander@659: template dvander@659: void *GetOrigVfnPtrEntry(X *pInstance, MFP mfp, ISourceHook *pSH) dvander@659: { dvander@659: SourceHook::MemFuncInfo info = {true, -1, 0, 0}; dvander@659: SourceHook::GetFuncInfo(pInstance, mfp, info); dvander@659: dvander@659: void *vfnptr = reinterpret_cast( dvander@659: *reinterpret_cast(reinterpret_cast(pInstance) + info.thisptroffs + info.vtbloffs) + info.vtblindex); dvander@659: dvander@659: void *origentry = pSH->GetOrigVfnPtrEntry(vfnptr); dvander@659: dvander@659: return origentry ? origentry : *reinterpret_cast(vfnptr); dvander@659: } dvander@541: } dvander@541: dvander@541: /************************************************************************/ dvander@541: /* High level interface */ dvander@541: /************************************************************************/ dvander@541: #define META_RESULT_STATUS SH_GLOB_SHPTR->GetStatus() dvander@541: #define META_RESULT_PREVIOUS SH_GLOB_SHPTR->GetPrevRes() dvander@541: #define META_RESULT_ORIG_RET(type) *SourceHook::MacroRefHelpers::GetOrigRet(SH_GLOB_SHPTR) dvander@541: #define META_RESULT_OVERRIDE_RET(type) *SourceHook::MacroRefHelpers::GetOverrideRet(SH_GLOB_SHPTR) dvander@541: #define META_IFACEPTR(type) reinterpret_cast(SH_GLOB_SHPTR->GetIfacePtr()) dvander@541: dvander@541: #define SET_META_RESULT(result) SH_GLOB_SHPTR->SetRes(result) dvander@541: #define RETURN_META(result) do { SET_META_RESULT(result); return; } while(0) dvander@541: #define RETURN_META_VALUE(result, value) do { SET_META_RESULT(result); return (value); } while(0) dvander@541: dvander@541: // If a hook on a function which returns a reference does not want to specify a return value, dvander@541: // it can use this macro. dvander@541: // ONLY USE THIS WITH MRES_IGNORED AND MRES_HANDLED !!! dvander@541: #define RETURN_META_NOREF(result, rettype) do { SET_META_RESULT(result); return reinterpret_cast(*SH_GLOB_SHPTR); } while(0) dvander@541: dvander@541: // only call these from the hook handlers directly! dvander@541: // :TODO: enforce it ? dvander@541: dvander@541: // Why take a memfuncptr instead of iface and func when we have to deduce the iface anyway now? dvander@541: // Well, without it, there'd be no way to specify which overloaded version we want in _VALUE dvander@541: dvander@541: // SourceHook::SetOverrideRet is defined later. dvander@541: #define RETURN_META_NEWPARAMS(result, memfuncptr, newparams) \ dvander@541: do { \ dvander@541: SET_META_RESULT(result); \ dvander@541: SH_GLOB_SHPTR->DoRecall(); \ dvander@541: (SourceHook::RecallGetIface(SH_GLOB_SHPTR, memfuncptr)->*(memfuncptr)) newparams; \ dvander@541: RETURN_META(MRES_SUPERCEDE); \ dvander@541: } while (0) dvander@541: dvander@541: #define RETURN_META_VALUE_NEWPARAMS(result, value, memfuncptr, newparams) \ dvander@541: do { \ dvander@541: SET_META_RESULT(result); \ dvander@541: SH_GLOB_SHPTR->DoRecall(); \ dvander@541: if ((result) >= MRES_OVERRIDE) \ dvander@541: { \ dvander@541: /* meh, set the override result here because we don't get a chance to return */ \ dvander@541: /* before continuing the hook loop through the recall */ \ dvander@541: SourceHook::SetOverrideResult(memfuncptr)(SH_GLOB_SHPTR, value); \ dvander@541: } \ dvander@541: RETURN_META_VALUE(MRES_SUPERCEDE, \ dvander@541: (SourceHook::RecallGetIface(SH_GLOB_SHPTR, memfuncptr)->*(memfuncptr)) newparams); \ dvander@541: } while (0) dvander@541: dvander@541: // :TODO: thisptroffs in MNEWPARAMS ?? dvander@541: dvander@541: #if SH_COMP == SH_COMP_MSVC dvander@541: dvander@541: #define SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname) \ dvander@541: union \ dvander@541: { \ dvander@541: SH_MFHCls(hookname)::ECMFP mfp; \ dvander@541: void *addr; \ dvander@541: } u; \ dvander@541: SourceHook::EmptyClass *thisptr = reinterpret_cast(SH_GLOB_SHPTR->GetIfacePtr()); \ dvander@541: u.addr = (*reinterpret_cast(reinterpret_cast(thisptr) + SH_MFHCls(hookname)::ms_MFI.vtbloffs))[ \ dvander@541: SH_MFHCls(hookname)::ms_MFI.vtblindex]; dvander@541: dvander@541: #elif SH_COMP == SH_COMP_GCC dvander@541: dvander@541: #define SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname) \ dvander@541: union \ dvander@541: { \ dvander@541: SH_MFHCls(hookname)::ECMFP mfp; \ dvander@541: struct \ dvander@541: { \ dvander@541: void *addr; \ dvander@541: intptr_t adjustor; \ dvander@541: } s; \ dvander@541: } u; \ dvander@541: SourceHook::EmptyClass *thisptr = reinterpret_cast(SH_GLOB_SHPTR->GetIfacePtr()); \ dvander@541: u.s.addr = (*reinterpret_cast(reinterpret_cast(thisptr) + SH_MFHCls(hookname)::ms_MFI.vtbloffs))[ \ dvander@541: SH_MFHCls(hookname)::ms_MFI.vtblindex]; \ dvander@541: u.s.adjustor = 0; dvander@541: dvander@541: #endif dvander@541: dvander@541: #define RETURN_META_MNEWPARAMS(result, hookname, newparams) \ dvander@541: do { \ dvander@541: SET_META_RESULT(result); \ dvander@541: SH_GLOB_SHPTR->DoRecall(); \ dvander@541: SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname); \ dvander@541: (thisptr->*(u.mfp)) newparams; \ dvander@541: RETURN_META(MRES_SUPERCEDE); \ dvander@541: } while (0) dvander@541: dvander@541: #define RETURN_META_VALUE_MNEWPARAMS(result, value, hookname, newparams) \ dvander@541: do { \ dvander@541: SET_META_RESULT(result); \ dvander@541: SH_GLOB_SHPTR->DoRecall(); \ dvander@541: if ((result) >= MRES_OVERRIDE) \ dvander@541: { \ dvander@541: /* see RETURN_META_VALUE_NEWPARAMS */ \ dvander@541: SourceHook::SetOverrideResult(SH_GLOB_SHPTR, value); \ dvander@541: } \ dvander@541: SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname); \ dvander@541: RETURN_META_VALUE(MRES_SUPERCEDE, (thisptr->*(u.mfp)) newparams); \ dvander@541: } while (0) dvander@541: dvander@541: #define SH_MANUALHOOK_RECONFIGURE(hookname, pvtblindex, pvtbloffs, pthisptroffs) \ dvander@541: do { \ dvander@541: SH_GLOB_SHPTR->RemoveHookManager(SH_GLOB_PLUGPTR, SH_MFHCls(hookname)::HookManPubFunc); \ dvander@541: SH_MFHCls(hookname)::ms_MFI.thisptroffs = pthisptroffs; \ dvander@541: SH_MFHCls(hookname)::ms_MFI.vtblindex = pvtblindex; \ dvander@541: SH_MFHCls(hookname)::ms_MFI.vtbloffs = pvtbloffs; \ dvander@541: } while (0) dvander@541: dvander@659: dvander@659: #define SH_GET_ORIG_VFNPTR_ENTRY(inst, mfp) (SourceHook::GetOrigVfnPtrEntry(inst, mfp, SH_GLOB_SHPTR)) dvander@659: dvander@659: // For source-level compatibility dvander@659: dvander@659: #define SH_GET_CALLCLASS(ptr) SourceHook::GetCallClass(ptr) dvander@659: #define SH_GET_MCALLCLASS(ptr, size) SourceHook::GetCallClass(reinterpret_cast(ptr)) dvander@659: #define SH_RELEASE_CALLCLASS(ptr) SourceHook::ReleaseCallClass(ptr) dvander@659: dvander@659: // New ADD / REMOVE macros. dvander@659: #define SH_STATIC(func) fastdelegate::MakeDelegate(func) dvander@659: #define SH_MEMBER(inst, func) fastdelegate::MakeDelegate(inst, func) dvander@541: dvander@541: #define SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \ dvander@541: __SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast(ifaceptr), \ dvander@541: post, handler) dvander@541: dvander@541: #define SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \ dvander@541: __SourceHook_FHRemove##ifacetype##ifacefunc((void*)SourceHook::implicit_cast(ifaceptr), \ dvander@659: post, handler) dvander@541: dvander@541: #define SH_ADD_MANUALHOOK(hookname, ifaceptr, handler, post) \ dvander@541: __SourceHook_FHMAdd##hookname(reinterpret_cast(ifaceptr), post, handler) dvander@541: dvander@541: #define SH_REMOVE_MANUALHOOK(hookname, ifaceptr, handler, post) \ dvander@659: __SourceHook_FHMRemove##hookname(reinterpret_cast(ifaceptr), post, handler) dvander@659: dvander@659: #define SH_ADD_VPHOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \ dvander@659: __SourceHook_FHVPAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast(ifaceptr), \ dvander@659: post, handler, false) dvander@659: dvander@659: #define SH_ADD_DVPHOOK(ifacetype, ifacefunc, vtableptr, handler, post) \ dvander@659: __SourceHook_FHVPAdd##ifacetype##ifacefunc(reinterpret_cast(vtableptr), \ dvander@659: post, handler, true) dvander@659: dvander@659: #define SH_ADD_MANUALVPHOOK(hookname, ifaceptr, handler, post) \ dvander@659: __SourceHook_FHMVPAdd##hookname(reinterpret_cast(ifaceptr), post, handler, false) dvander@659: dvander@659: #define SH_ADD_MANUALDVPHOOK(hookname, vtableptr, handler, post) \ dvander@659: __SourceHook_FHMVPAdd##hookname(reinterpret_cast(vtableptr), post, handler, true) dvander@659: dvander@659: #define SH_REMOVE_HOOK_ID(hookid) \ dvander@659: (SH_GLOB_SHPTR->RemoveHookByID(SH_GLOB_PLUGPTR, hookid)) dvander@659: dvander@659: // Old macros dvander@659: // !! These are now deprecated. Instead, use one of these: dvander@659: // SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post) dvander@659: // SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post) dvander@659: dvander@659: #define SH_ADD_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \ dvander@659: SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post) dvander@659: #define SH_ADD_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \ dvander@659: SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post) dvander@659: dvander@659: // SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post) dvander@659: // SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post) dvander@659: dvander@659: #define SH_REMOVE_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \ dvander@659: SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post) dvander@659: #define SH_REMOVE_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \ dvander@659: SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post) dvander@659: dvander@659: // SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post) dvander@659: // SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post) dvander@659: dvander@659: #define SH_ADD_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \ dvander@659: SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post) dvander@659: #define SH_ADD_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \ dvander@659: SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post) dvander@659: dvander@659: // SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post) dvander@659: // SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post) dvander@659: dvander@541: #define SH_REMOVE_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \ dvander@659: SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post) dvander@541: #define SH_REMOVE_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \ dvander@659: SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post) dvander@541: dvander@541: #define SH_NOATTRIB dvander@541: dvander@541: dvander@541: dvander@541: dvander@541: #if SH_COMP == SH_COMP_MSVC dvander@541: # define SH_SETUP_MFP(mfp) \ dvander@541: reinterpret_cast(&mfp)[0] = vfnptr_origentry; dvander@541: #elif SH_COMP == SH_COMP_GCC dvander@541: # define SH_SETUP_MFP(mfp) \ dvander@541: reinterpret_cast(&mfp)[0] = vfnptr_origentry; \ dvander@541: reinterpret_cast(&mfp)[1] = 0; dvander@541: #else dvander@541: # error Not supported yet. dvander@541: #endif dvander@541: dvander@541: ////////////////////////////////////////////////////////////////////////// dvander@541: #define SH_FHCls(ift, iff, ov) __SourceHook_FHCls_##ift##iff##ov dvander@541: #define SH_MFHCls(hookname) __SourceHook_MFHCls_##hookname dvander@541: dvander@541: #define SHINT_MAKE_HOOKMANPUBFUNC(ifacetype, ifacefunc, overload, funcptr) \ dvander@541: SH_FHCls(ifacetype,ifacefunc,overload)() \ dvander@541: { \ dvander@541: GetFuncInfo(funcptr, ms_MFI); \ dvander@541: } \ dvander@541: \ dvander@541: static int HookManPubFunc(::SourceHook::HookManagerAction action, ::SourceHook::IHookManagerInfo *param) \ dvander@541: { \ dvander@541: using namespace ::SourceHook; \ dvander@541: GetFuncInfo(funcptr, ms_MFI); \ dvander@541: /* Verify interface version */ \ dvander@541: if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \ dvander@541: return 1; \ dvander@659: if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \ dvander@659: return 1; \ dvander@541: \ dvander@541: if (action == HA_GetInfo) \ dvander@541: { \ dvander@541: param->SetVersion(SH_HOOKMAN_VERSION); \ dvander@541: param->SetInfo(ms_MFI.vtbloffs, ms_MFI.vtblindex, \ dvander@541: reinterpret_cast(&ms_Proto)); \ dvander@541: \ dvander@541: MemFuncInfo mfi = {true, -1, 0, 0}; \ dvander@541: GetFuncInfo(&SH_FHCls(ifacetype,ifacefunc,overload)::Func, mfi); \ dvander@541: param->SetHookfuncVfnptr( \ dvander@541: reinterpret_cast(reinterpret_cast(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex]); \ dvander@541: return 0; \ dvander@541: } \ dvander@541: else if (action == HA_Register) \ dvander@541: { \ dvander@541: ms_HI = param; \ dvander@541: return 0; \ dvander@541: } \ dvander@541: else if (action == HA_Unregister) \ dvander@541: { \ dvander@541: ms_HI = NULL; \ dvander@541: return 0; \ dvander@541: } \ dvander@541: else \ dvander@541: return 1; \ dvander@541: } dvander@541: dvander@541: // It has to be possible to use the macros in namespaces dvander@541: // -> So we need to access and extend the global SourceHook namespace dvander@541: // We use a namespace alias for this dvander@541: #define SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, funcptr) \ dvander@541: struct SH_FHCls(ifacetype,ifacefunc,overload) \ dvander@541: { \ dvander@541: static SH_FHCls(ifacetype,ifacefunc,overload) ms_Inst; \ dvander@541: static ::SourceHook::MemFuncInfo ms_MFI; \ dvander@541: static ::SourceHook::IHookManagerInfo *ms_HI; \ dvander@541: static ::SourceHook::ProtoInfo ms_Proto; \ dvander@541: SHINT_MAKE_HOOKMANPUBFUNC(ifacetype, ifacefunc, overload, funcptr) dvander@541: dvander@541: #define SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, funcptr) \ dvander@541: }; \ dvander@541: SH_FHCls(ifacetype,ifacefunc,overload) SH_FHCls(ifacetype,ifacefunc,overload)::ms_Inst; \ dvander@541: ::SourceHook::MemFuncInfo SH_FHCls(ifacetype,ifacefunc,overload)::ms_MFI; \ dvander@541: ::SourceHook::IHookManagerInfo *SH_FHCls(ifacetype,ifacefunc,overload)::ms_HI; \ dvander@659: int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, bool post, \ dvander@541: SH_FHCls(ifacetype,ifacefunc,overload)::FD handler) \ dvander@541: { \ dvander@541: using namespace ::SourceHook; \ dvander@541: MemFuncInfo mfi = {true, -1, 0, 0}; \ dvander@541: GetFuncInfo(funcptr, mfi); \ dvander@541: if (mfi.thisptroffs < 0 || !mfi.isVirtual) \ dvander@541: return false; /* No non-virtual functions / virtual inheritance supported */ \ dvander@541: \ dvander@659: return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, ::SourceHook::ISourceHook::Hook_Normal, iface, mfi.thisptroffs, \ dvander@541: SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, \ dvander@541: new CSHDelegate(handler), post); \ dvander@541: } \ dvander@659: int __SourceHook_FHVPAdd##ifacetype##ifacefunc(void *iface, bool post, \ dvander@659: SH_FHCls(ifacetype,ifacefunc,overload)::FD handler, bool direct) \ dvander@659: { \ dvander@659: using namespace ::SourceHook; \ dvander@659: MemFuncInfo mfi = {true, -1, 0, 0}; \ dvander@659: GetFuncInfo(funcptr, mfi); \ dvander@659: if (mfi.thisptroffs < 0 || !mfi.isVirtual) \ dvander@659: return false; /* No non-virtual functions / virtual inheritance supported */ \ dvander@659: \ dvander@659: return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, \ dvander@659: direct ? ::SourceHook::ISourceHook::Hook_DVP : ::SourceHook::ISourceHook::Hook_VP, \ dvander@659: iface, mfi.thisptroffs, SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, \ dvander@659: new CSHDelegate(handler), post); \ dvander@659: } \ dvander@541: bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \ dvander@541: SH_FHCls(ifacetype,ifacefunc,overload)::FD handler) \ dvander@541: { \ dvander@541: using namespace ::SourceHook; \ dvander@541: MemFuncInfo mfi = {true, -1, 0, 0}; \ dvander@541: GetFuncInfo(funcptr, mfi); \ dvander@541: if (mfi.thisptroffs < 0) \ dvander@541: return false; /* No virtual inheritance supported */ \ dvander@541: \ dvander@541: CSHDelegate tmp(handler); \ dvander@541: return SH_GLOB_SHPTR->RemoveHook(SH_GLOB_PLUGPTR, iface, mfi.thisptroffs, \ dvander@541: SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, &tmp, post); \ dvander@541: } \ dvander@541: dvander@541: #define SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, pvtbloffs, pvtblidx, pthisptroffs) \ dvander@541: struct SH_MFHCls(hookname) \ dvander@541: { \ dvander@541: static SH_MFHCls(hookname) ms_Inst; \ dvander@541: static ::SourceHook::MemFuncInfo ms_MFI; \ dvander@541: static ::SourceHook::IHookManagerInfo *ms_HI; \ dvander@541: static ::SourceHook::ProtoInfo ms_Proto; \ dvander@541: \ dvander@541: SH_MFHCls(hookname)() \ dvander@541: { \ dvander@541: ms_MFI.isVirtual = true; \ dvander@541: ms_MFI.thisptroffs = pthisptroffs; \ dvander@541: ms_MFI.vtblindex = pvtblidx; \ dvander@541: ms_MFI.vtbloffs = pvtbloffs; \ dvander@541: } \ dvander@541: static int HookManPubFunc(::SourceHook::HookManagerAction action, ::SourceHook::IHookManagerInfo *param) \ dvander@541: { \ dvander@541: using namespace ::SourceHook; \ dvander@541: /* we don't set ms_MFI here because manual hookmans can be reconfigured */ \ dvander@541: /* :FIXME: possible problem: someone adding a hook from a constructor of a global entity */ \ dvander@541: /* which is construced before SH_MFHCls(hookname)() gets called? */ \ dvander@541: /* Verify interface version */ \ dvander@541: if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \ dvander@541: return 1; \ dvander@659: if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \ dvander@659: return 1; \ dvander@541: \ dvander@541: if (action == HA_GetInfo) \ dvander@541: { \ dvander@541: param->SetVersion(SH_HOOKMAN_VERSION); \ dvander@541: param->SetInfo(ms_MFI.vtbloffs, ms_MFI.vtblindex, \ dvander@541: reinterpret_cast(&ms_Proto)); \ dvander@541: \ dvander@541: MemFuncInfo mfi = {true, -1, 0, 0}; \ dvander@541: GetFuncInfo(&SH_MFHCls(hookname)::Func, mfi); \ dvander@541: param->SetHookfuncVfnptr( \ dvander@541: reinterpret_cast(reinterpret_cast(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex]); \ dvander@541: return 0; \ dvander@541: } \ dvander@541: else if (action == HA_Register) \ dvander@541: { \ dvander@541: ms_HI = param; \ dvander@541: return 0; \ dvander@541: } \ dvander@541: else if (action == HA_Unregister) \ dvander@541: { \ dvander@541: ms_HI = NULL; \ dvander@541: return 0; \ dvander@541: } \ dvander@541: else \ dvander@541: return 1; \ dvander@541: } dvander@541: dvander@541: #define SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, pvtbloffs, pvtblidx, pthisptroffs) \ dvander@541: }; \ dvander@541: SH_MFHCls(hookname) SH_MFHCls(hookname)::ms_Inst; \ dvander@541: ::SourceHook::MemFuncInfo SH_MFHCls(hookname)::ms_MFI; \ dvander@541: ::SourceHook::IHookManagerInfo *SH_MFHCls(hookname)::ms_HI; \ dvander@659: int __SourceHook_FHMAdd##hookname(void *iface, bool post, \ dvander@541: SH_MFHCls(hookname)::FD handler) \ dvander@541: { \ dvander@659: return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, ::SourceHook::ISourceHook::Hook_Normal, iface, pthisptroffs, \ dvander@541: SH_MFHCls(hookname)::HookManPubFunc, \ dvander@541: new ::SourceHook::CSHDelegate(handler), post); \ dvander@541: } \ dvander@659: int __SourceHook_FHMVPAdd##hookname(void *iface, bool post, \ dvander@659: SH_MFHCls(hookname)::FD handler, bool direct) \ dvander@659: { \ dvander@659: return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, \ dvander@659: direct ? ::SourceHook::ISourceHook::Hook_DVP : ::SourceHook::ISourceHook::Hook_VP, \ dvander@659: iface, pthisptroffs, SH_MFHCls(hookname)::HookManPubFunc, \ dvander@659: new ::SourceHook::CSHDelegate(handler), post); \ dvander@659: } \ dvander@541: bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \ dvander@541: SH_MFHCls(hookname)::FD handler) \ dvander@541: { \ dvander@541: ::SourceHook::CSHDelegate tmp(handler); \ dvander@541: return SH_GLOB_SHPTR->RemoveHook(SH_GLOB_PLUGPTR, iface, pthisptroffs, \ dvander@541: SH_MFHCls(hookname)::HookManPubFunc, &tmp, post); \ dvander@541: } \ dvander@541: dvander@541: dvander@541: #define SH_SETUPCALLS(rettype, paramtypes, params) \ dvander@541: /* 1) Find the vfnptr */ \ dvander@541: using namespace ::SourceHook; \ dvander@541: void *ourvfnptr = reinterpret_cast( \ dvander@541: *reinterpret_cast(reinterpret_cast(this) + ms_MFI.vtbloffs) + ms_MFI.vtblindex); \ dvander@541: IVfnPtr *vfnptr = ms_HI->FindVfnPtr(ourvfnptr); \ dvander@541: SH_ASSERT(vfnptr, ("Called with vfnptr 0x%p which couldn't be found in the list", ourvfnptr)); \ dvander@541: \ dvander@541: void *vfnptr_origentry = vfnptr->GetOrigEntry(); \ dvander@541: /* ... and the iface */ \ dvander@541: IIface *ifinfo = vfnptr->FindIface(reinterpret_cast(this)); \ dvander@541: if (!ifinfo) \ dvander@541: { \ dvander@541: /* The iface info was not found. Redirect the call to the original function. */ \ dvander@541: rettype (EmptyClass::*mfp)paramtypes; \ dvander@541: SH_SETUP_MFP(mfp); \ dvander@541: return (reinterpret_cast(this)->*mfp)params; \ dvander@541: } \ dvander@541: /* 2) Declare some vars and set it up */ \ dvander@541: SH_GLOB_SHPTR->HookLoopBegin(ifinfo); \ dvander@541: IHookList *prelist = ifinfo->GetPreHooks(); \ dvander@541: IHookList *postlist = ifinfo->GetPostHooks(); \ dvander@541: META_RES status = MRES_IGNORED; \ dvander@541: META_RES prev_res; \ dvander@541: META_RES cur_res; \ dvander@541: typedef ReferenceCarrier::type my_rettype; \ dvander@541: my_rettype orig_ret; \ dvander@541: my_rettype override_ret; \ dvander@541: my_rettype plugin_ret; \ dvander@541: void* ifptr; \ dvander@541: my_rettype *pOverrideRet = reinterpret_cast(SH_GLOB_SHPTR->SetupHookLoop( \ dvander@541: &status, &prev_res, &cur_res, &ifptr, &orig_ret, &override_ret)); dvander@541: dvander@541: #define SH_CALL_HOOKS(post, params) \ dvander@541: if (SH_GLOB_SHPTR->ShouldContinue()) \ dvander@541: { \ dvander@541: prev_res = MRES_IGNORED; \ dvander@541: for (AutoHookIter iter(post##list); !iter.End(); iter.Next()) \ dvander@541: { \ dvander@541: cur_res = MRES_IGNORED; \ dvander@541: ifptr = reinterpret_cast(reinterpret_cast(this) - iter.ThisPtrOffs()); \ dvander@541: plugin_ret = reinterpret_cast*>(iter.Handler())->GetDeleg() params; \ dvander@541: prev_res = cur_res; \ dvander@541: if (cur_res > status) \ dvander@541: status = cur_res; \ dvander@541: if (cur_res >= MRES_OVERRIDE) \ dvander@541: *pOverrideRet = plugin_ret; \ dvander@541: if (!SH_GLOB_SHPTR->ShouldContinue()) \ dvander@541: { \ dvander@541: iter.SetToZero(); \ dvander@541: break; \ dvander@541: } \ dvander@541: } \ dvander@541: } dvander@541: dvander@541: #define SH_CALL_ORIG(rettype, paramtypes, params) \ dvander@541: if (status != MRES_SUPERCEDE) \ dvander@541: { \ dvander@541: rettype (EmptyClass::*mfp)paramtypes; \ dvander@541: SH_SETUP_MFP(mfp); \ dvander@541: orig_ret = (reinterpret_cast(this)->*mfp)params; \ dvander@541: } \ dvander@541: else \ dvander@541: orig_ret = override_ret; \ dvander@541: dvander@541: #define SH_RETURN() \ dvander@541: SH_GLOB_SHPTR->HookLoopEnd(); \ dvander@541: return status >= MRES_OVERRIDE ? *pOverrideRet : orig_ret; dvander@541: dvander@541: #define SH_HANDLEFUNC(paramtypes, params, rettype) \ dvander@541: SH_SETUPCALLS(rettype, paramtypes, params) \ dvander@541: SH_CALL_HOOKS(pre, params) \ dvander@541: SH_CALL_ORIG(rettype, paramtypes, params) \ dvander@541: SH_CALL_HOOKS(post, params) \ dvander@541: SH_RETURN() dvander@541: dvander@541: ////////////////////////////////////////////////////////////////////////// dvander@541: #define SH_SETUPCALLS_void(paramtypes, params) \ dvander@541: /* 1) Find the vfnptr */ \ dvander@541: using namespace ::SourceHook; \ dvander@541: void *ourvfnptr = reinterpret_cast( \ dvander@541: *reinterpret_cast(reinterpret_cast(this) + ms_MFI.vtbloffs) + ms_MFI.vtblindex); \ dvander@541: IVfnPtr *vfnptr = ms_HI->FindVfnPtr(ourvfnptr); \ dvander@541: SH_ASSERT(vfnptr, ("Called with vfnptr 0x%p which couldn't be found in the list", ourvfnptr)); \ dvander@541: \ dvander@541: void *vfnptr_origentry = vfnptr->GetOrigEntry(); \ dvander@541: /* ... and the iface */ \ dvander@541: IIface *ifinfo = vfnptr->FindIface(reinterpret_cast(this)); \ dvander@541: if (!ifinfo) \ dvander@541: { \ dvander@541: /* The iface info was not found. Redirect the call to the original function. */ \ dvander@541: void (EmptyClass::*mfp)paramtypes; \ dvander@541: SH_SETUP_MFP(mfp); \ dvander@541: (reinterpret_cast(this)->*mfp)params; \ dvander@541: return; \ dvander@541: } \ dvander@541: /* 2) Declare some vars and set it up */ \ dvander@541: SH_GLOB_SHPTR->HookLoopBegin(ifinfo); \ dvander@541: IHookList *prelist = ifinfo->GetPreHooks(); \ dvander@541: IHookList *postlist = ifinfo->GetPostHooks(); \ dvander@541: META_RES status = MRES_IGNORED; \ dvander@541: META_RES prev_res; \ dvander@541: META_RES cur_res; \ dvander@541: void* ifptr; \ dvander@541: SH_GLOB_SHPTR->SetupHookLoop(&status, &prev_res, &cur_res, &ifptr, NULL, NULL); \ dvander@541: dvander@541: #define SH_CALL_HOOKS_void(post, params) \ dvander@541: if (SH_GLOB_SHPTR->ShouldContinue()) \ dvander@541: { \ dvander@541: prev_res = MRES_IGNORED; \ dvander@541: for (AutoHookIter iter(post##list); !iter.End(); iter.Next()) \ dvander@541: { \ dvander@541: cur_res = MRES_IGNORED; \ dvander@541: ifptr = reinterpret_cast(reinterpret_cast(this) - iter.ThisPtrOffs()); \ dvander@541: reinterpret_cast*>(iter.Handler())->GetDeleg() params; \ dvander@541: prev_res = cur_res; \ dvander@541: if (cur_res > status) \ dvander@541: status = cur_res; \ dvander@541: if (!SH_GLOB_SHPTR->ShouldContinue()) \ dvander@541: { \ dvander@541: iter.SetToZero(); \ dvander@541: break; \ dvander@541: } \ dvander@541: } \ dvander@541: } dvander@541: dvander@541: #define SH_CALL_ORIG_void(paramtypes, params) \ dvander@541: if (status != MRES_SUPERCEDE) \ dvander@541: { \ dvander@541: void (EmptyClass::*mfp)paramtypes; \ dvander@541: SH_SETUP_MFP(mfp); \ dvander@541: (reinterpret_cast(this)->*mfp)params; \ dvander@541: } dvander@541: dvander@541: #define SH_RETURN_void() \ dvander@541: SH_GLOB_SHPTR->HookLoopEnd(); dvander@541: dvander@541: #define SH_HANDLEFUNC_void(paramtypes, params) \ dvander@541: SH_SETUPCALLS_void(paramtypes, params) \ dvander@541: SH_CALL_HOOKS_void(pre, params) \ dvander@541: SH_CALL_ORIG_void(paramtypes, params) \ dvander@541: SH_CALL_HOOKS_void(post, params) \ dvander@541: SH_RETURN_void() dvander@541: dvander@541: dvander@541: // Special vafmt handlers dvander@541: // :TODO: what dvander@541: #define SH_HANDLEFUNC_vafmt(paramtypes, params_orig, params_plug, rettype) \ dvander@541: SH_SETUPCALLS(rettype, paramtypes, params_orig) \ dvander@541: SH_CALL_HOOKS(pre, params_plug) \ dvander@541: SH_CALL_ORIG(rettype, paramtypes, params_orig) \ dvander@541: SH_CALL_HOOKS(post, params_plug) \ dvander@541: SH_RETURN() dvander@541: dvander@541: #define SH_HANDLEFUNC_void_vafmt(paramtypes, params_orig, params_plug) \ dvander@541: SH_SETUPCALLS_void(paramtypes, params_orig) \ dvander@541: SH_CALL_HOOKS_void(pre, params_plug) \ dvander@541: SH_CALL_ORIG_void(paramtypes, params_orig) \ dvander@541: SH_CALL_HOOKS_void(post, params_plug) \ dvander@541: SH_RETURN_void() dvander@541: dvander@541: ////////////////////////////////////////////////////////////////////////// dvander@541: dvander@541: // :FIXME: dvander@541: // sizeof on references returns the size of the datatype, NOT the pointer size or something dvander@541: // -> one should probably flag references in __SourceHook_ParamSizes_* ! dvander@541: // or simply assume that their size is sizeof(void*)=SH_PTRSIZE... could be doable through a simple template dvander@541: dvander@541: @[$1,0,$a: dvander@541: // ********* Support for $1 arguments ********* dvander@541: #define SH_DECL_HOOK$1(ifacetype, ifacefunc, attr, overload, rettype@[$2,1,$1:, param$2@]) \ dvander@541: SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast \ dvander@541: (&ifacetype::ifacefunc))) \ dvander@541: typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> FD; \ dvander@541: virtual rettype Func(@[$2,1,$1|, :param$2 p$2@]) \ dvander@541: { SH_HANDLEFUNC((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@]), rettype); } \ dvander@541: SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \ dvander@541: (static_cast(&ifacetype::ifacefunc))) \ dvander@541: \ dvander@541: const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0@[$2,1,$1:, sizeof(param$2)@] }; \ dvander@541: ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \ dvander@541: $1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload); dvander@541: dvander@541: #define SH_DECL_HOOK$1_void(ifacetype, ifacefunc, attr, overload@[$2,1,$1:, param$2@]) \ dvander@541: SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast \ dvander@541: (&ifacetype::ifacefunc))) \ dvander@541: typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> FD; \ dvander@541: virtual void Func(@[$2,1,$1|, :param$2 p$2@]) \ dvander@541: { SH_HANDLEFUNC_void((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@])); } \ dvander@541: SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \ dvander@541: (static_cast(&ifacetype::ifacefunc))) \ dvander@541: \ dvander@541: \ dvander@541: const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0@[$2,1,$1:, sizeof(param$2)@] }; \ dvander@541: ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \ dvander@541: $1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload); dvander@541: dvander@541: #define SH_DECL_HOOK$1_vafmt(ifacetype, ifacefunc, attr, overload, rettype@[$2,1,$1:, param$2@]) \ dvander@541: SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast \ dvander@541: (&ifacetype::ifacefunc))) \ dvander@541: typedef fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, rettype> FD; \ dvander@541: virtual rettype Func(@[$2,1,$1|, :param$2 p$2@]@[$1!=0:, @]const char *fmt, ...) \ dvander@541: { \ dvander@541: char buf[::SourceHook::STRBUF_LEN]; \ dvander@541: va_list ap; \ dvander@541: va_start(ap, fmt); \ dvander@541: vsnprintf(buf, sizeof(buf), fmt, ap); \ dvander@541: va_end(ap); \ dvander@541: SH_HANDLEFUNC_vafmt((@[$2,1,$1|, :param$2@]@[$1!=0:, @]...), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]"%s", buf), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]buf), rettype); \ dvander@541: } \ dvander@541: SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \ dvander@541: (static_cast(&ifacetype::ifacefunc))) \ dvander@541: \ dvander@541: const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1@[$2,1,$1:, sizeof(param$2)@] }; \ dvander@541: ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \ dvander@541: $1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload); dvander@541: dvander@541: #define SH_DECL_HOOK$1_void_vafmt(ifacetype, ifacefunc, attr, overload@[$2,1,$1:, param$2@]) \ dvander@541: SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast \ dvander@541: (&ifacetype::ifacefunc))) \ dvander@541: typedef fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *> FD; \ dvander@541: virtual void Func(@[$2,1,$1|, :param$2 p$2@]@[$1!=0:, @]const char *fmt, ...) \ dvander@541: { \ dvander@541: char buf[::SourceHook::STRBUF_LEN]; \ dvander@541: va_list ap; \ dvander@541: va_start(ap, fmt); \ dvander@541: vsnprintf(buf, sizeof(buf), fmt, ap); \ dvander@541: va_end(ap); \ dvander@541: SH_HANDLEFUNC_void_vafmt((@[$2,1,$1|, :param$2@]@[$1!=0:, @]...), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]"%s", buf), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]buf)); \ dvander@541: } \ dvander@541: SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \ dvander@541: (static_cast(&ifacetype::ifacefunc))) \ dvander@541: \ dvander@541: const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1@[$2,1,$1:, sizeof(param$2)@] }; \ dvander@541: ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \ dvander@541: $1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload); dvander@541: dvander@541: #define SH_DECL_MANUALHOOK$1(hookname, vtblidx, vtbloffs, thisptroffs, rettype@[$2,1,$1:, param$2@]) \ dvander@541: SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \ dvander@541: typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> FD; \ dvander@541: virtual rettype Func(@[$2,1,$1|, :param$2 p$2@]) \ dvander@541: { SH_HANDLEFUNC((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@]), rettype); } \ dvander@541: typedef rettype(::SourceHook::EmptyClass::*ECMFP)(@[$2,1,$1|, :param$2@]); \ dvander@541: typedef rettype RetType; \ dvander@541: SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \ dvander@541: \ dvander@541: const int __SourceHook_ParamSizesM_##hookname[] = { 0@[$2,1,$1:, sizeof(param$2)@] }; \ dvander@541: ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(sizeof(rettype), \ dvander@541: $1, __SourceHook_ParamSizesM_##hookname); \ dvander@541: dvander@541: #define SH_DECL_MANUALHOOK$1_void(hookname, vtblidx, vtbloffs, thisptroffs@[$2,1,$1:, param$2@]) \ dvander@541: SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \ dvander@541: typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> FD; \ dvander@541: virtual void Func(@[$2,1,$1|, :param$2 p$2@]) \ dvander@541: { SH_HANDLEFUNC_void((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@])); } \ dvander@541: typedef void(::SourceHook::EmptyClass::*ECMFP)(@[$2,1,$1|, :param$2@]); \ dvander@541: SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \ dvander@541: \ dvander@541: const int __SourceHook_ParamSizesM_##hookname[] = { 0@[$2,1,$1:, sizeof(param$2)@] }; \ dvander@541: ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(0, \ dvander@541: $1, __SourceHook_ParamSizesM_##hookname); \ dvander@541: dvander@541: @] dvander@541: dvander@541: dvander@541: ////////////////////////////////////////////////////////////////////////// dvander@541: // SH_CALL dvander@541: dvander@659: #define SH_MAKE_EXECUTABLECLASS_OB(call, prms) \ dvander@541: { \ dvander@541: using namespace ::SourceHook; \ dvander@541: \ dvander@659: m_pSH->SetIgnoreHooks(m_Plug, m_VfnPtr); \ dvander@659: RetType tmpret = (m_ThisPtr->*m_MFP)call; \ dvander@659: m_pSH->ResetIgnoreHooks(m_Plug, m_VfnPtr); \ dvander@659: return tmpret; \ dvander@541: } dvander@541: dvander@659: #define SH_MAKE_EXECUTABLECLASS_OB_void(call, prms) \ dvander@541: { \ dvander@541: using namespace ::SourceHook; \ dvander@541: \ dvander@659: m_pSH->SetIgnoreHooks(m_Plug, m_VfnPtr); \ dvander@659: (m_ThisPtr->*m_MFP)call; \ dvander@659: m_pSH->ResetIgnoreHooks(m_Plug, m_VfnPtr); \ dvander@541: } dvander@541: dvander@541: namespace SourceHook dvander@541: { dvander@659: // Call Class Wrapper! dvander@659: template struct CCW dvander@541: { dvander@659: typedef T type; dvander@659: dvander@659: // Get Real Pointer! dvander@659: static inline T *GRP(T *p) dvander@659: { dvander@659: return p; dvander@659: } dvander@659: }; dvander@659: dvander@659: template struct CCW< CallClass > dvander@659: { dvander@659: typedef T type; dvander@659: dvander@659: // Get Real Pointer! dvander@659: static inline T *GRP(CallClass *p) dvander@659: { dvander@659: return p->ptr; dvander@659: } dvander@541: }; dvander@541: dvander@659: @[$1,0,$a: dvander@659: // Support for $1 arguments dvander@659: template class ExecutableClass$1 dvander@541: { dvander@659: ObjType *m_ThisPtr; dvander@659: void *m_VfnPtr; dvander@659: MFP m_MFP; dvander@659: ISourceHook *m_pSH; dvander@659: Plugin m_Plug; dvander@541: public: dvander@659: ExecutableClass$1(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp), dvander@659: m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { } dvander@659: dvander@541: RetType operator()(@[$2,1,$1|, :Param$2 p$2@]) const dvander@659: SH_MAKE_EXECUTABLECLASS_OB((@[$2,1,$1|, :p$2@]), (@[$2,1,$1|, :Param$2@])) dvander@659: dvander@541: @[$2,$1+1,$a: dvander@541: template <@[$3,$1+1,$2|, :class Param$3@]> RetType operator()(@[$3,1,$2|, :Param$3 p$3@]) const dvander@659: SH_MAKE_EXECUTABLECLASS_OB((@[$3,1,$2|, :p$3@]), (@[$3,1,$2|, :Param$3@])) dvander@541: @] dvander@541: }; dvander@659: dvander@659: template class ExecutableClass$1 dvander@659: { dvander@659: ObjType *m_ThisPtr; dvander@659: void *m_VfnPtr; dvander@659: MFP m_MFP; dvander@659: ISourceHook *m_pSH; dvander@659: Plugin m_Plug; dvander@659: public: dvander@659: ExecutableClass$1(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp), dvander@659: m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { } dvander@659: dvander@659: void operator()(@[$2,1,$1|, :Param$2 p$2@]) const dvander@659: SH_MAKE_EXECUTABLECLASS_OB_void((@[$2,1,$1|, :p$2@]), (@[$2,1,$1|, :Param$2@])) dvander@659: dvander@659: @[$2,$1+1,$a: dvander@659: template <@[$3,$1+1,$2|, :class Param$3@]> void operator()(@[$3,1,$2|, :Param$3 p$3@]) const dvander@659: SH_MAKE_EXECUTABLECLASS_OB_void((@[$3,1,$2|, :p$3@]), (@[$3,1,$2|, :Param$3@])) dvander@659: @] dvander@659: }; dvander@541: @] dvander@541: dvander@541: } dvander@541: dvander@659: #define SH__CALL_GET_VFNPTR_NORMAL \ dvander@659: using namespace ::SourceHook; \ dvander@659: MemFuncInfo mfi = {true, -1, 0, 0}; \ dvander@659: GetFuncInfo(CCW::GRP(ptr), mfp, mfi); \ dvander@659: void *vfnptr = reinterpret_cast( \ dvander@696: *reinterpret_cast(reinterpret_cast(CCW::GRP(ptr)) + mfi.thisptroffs + mfi.vtbloffs) + mfi.vtblindex); dvander@659: dvander@659: #define SH__CALL_GET_VFNPTR_MANUAL \ dvander@659: using namespace ::SourceHook; \ dvander@659: void *vfnptr = reinterpret_cast( \ dvander@659: *reinterpret_cast( (reinterpret_cast(CCW::GRP(ptr)) + thisptroffs + vtbloffs) ) + vtblidx); \ dvander@659: /* patch mfp */ \ dvander@659: *reinterpret_cast(&mfp) = *reinterpret_cast(vfnptr); dvander@659: dvander@541: // SH_CALL needs to deduce the return type -> it uses templates and function overloading dvander@541: // That's why SH_CALL takes two parameters: "mfp2" of type RetType(X::*mfp)(params), and "mfp" of type MFP dvander@541: // The only purpose of the mfp2 parameter is to extract the return type dvander@541: dvander@541: @[$1,0,$a: dvander@541: // Support for $1 arguments dvander@541: template dvander@659: SourceHook::ExecutableClass$1::type, MFP, RetType@[$2,1,$1:, Param$2@]> dvander@659: SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug) dvander@541: { dvander@659: SH__CALL_GET_VFNPTR_NORMAL dvander@659: return SourceHook::ExecutableClass$1::type, MFP, RetType@[$2,1,$1:, Param$2@]>(CCW::GRP(ptr), dvander@659: mfp, vfnptr, shptr, plug); dvander@541: } dvander@541: dvander@541: template dvander@659: SourceHook::ExecutableClass$1::type, MFP, RetType@[$2,1,$1:, Param$2@]> dvander@659: SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@])const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug) dvander@541: { dvander@659: SH__CALL_GET_VFNPTR_NORMAL dvander@659: return SourceHook::ExecutableClass$1::type, MFP, RetType@[$2,1,$1:, Param$2@]>(CCW::GRP(ptr), dvander@659: mfp, vfnptr, shptr, plug); dvander@541: } dvander@541: dvander@659: template dvander@659: SourceHook::ExecutableClass$1 dvander@659: SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug) dvander@541: { dvander@659: SH__CALL_GET_VFNPTR_MANUAL dvander@659: return SourceHook::ExecutableClass$1( dvander@659: reinterpret_cast(CCW::GRP(ptr)), mfp, vfnptr, shptr, plug); dvander@541: } dvander@541: @] dvander@541: dvander@541: #if SH_COMP != SH_COMP_MSVC || _MSC_VER > 1300 dvander@541: // GCC & MSVC 7.1 need this, MSVC 7.0 doesn't like it dvander@541: dvander@541: @[$1,0,$a: dvander@541: // Support for $1 arguments dvander@541: template dvander@659: SourceHook::ExecutableClass$1::type, MFP, RetType@[$2,1,$1:, Param$2@]> dvander@659: SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]@[$1!=0:, @]...), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug) dvander@541: { dvander@659: SH__CALL_GET_VFNPTR_NORMAL dvander@659: return SourceHook::ExecutableClass$1::type, MFP, RetType@[$2,1,$1:, Param$2@]>(CCW::GRP(ptr), dvander@659: mfp, vfnptr, shptr, plug); dvander@541: } dvander@541: dvander@541: template dvander@659: SourceHook::ExecutableClass$1::type, MFP, RetType@[$2,1,$1:, Param$2@]> dvander@659: SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]@[$1!=0:, @]...)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug) dvander@541: { dvander@659: SH__CALL_GET_VFNPTR_NORMAL dvander@659: return SourceHook::ExecutableClass$1::type, MFP, RetType@[$2,1,$1:, Param$2@]>(CCW::GRP(ptr), dvander@659: mfp, vfnptr, shptr, plug); dvander@541: } dvander@541: dvander@541: @] dvander@541: dvander@541: #endif dvander@541: dvander@659: #define SH_CALL(ptr, mfp) SH_CALL2((ptr), (mfp), (mfp), SH_GLOB_SHPTR, SH_GLOB_PLUGPTR) dvander@659: #define SH_MCALL2(ptr, mfp, vtblidx, vtbloffs, thisptroffs) SH_MCALL3((ptr), (mfp), (mfp), (vtblidx), (vtbloffs), (thisptroffs), SH_GLOB_SHPTR, SH_GLOB_PLUGPTR) dvander@541: #define SH_MCALL(ptr, mhookname) SH_MCALL2((ptr), SH_MFHCls(mhookname)::ECMFP(), SH_MFHCls(mhookname)::ms_MFI.vtblindex, \ dvander@541: SH_MFHCls(mhookname)::ms_MFI.vtbloffs, SH_MFHCls(mhookname)::ms_MFI.thisptroffs) dvander@541: dvander@541: #undef SH_MAKE_EXECUTABLECLASS_OB dvander@541: dvander@541: ////////////////////////////////////////////////////////////////////////// dvander@541: // SetOverrideRet and RecallGetIface for recalls dvander@541: // These take a ISourceHook pointer instead of using SH_GLOB_SHPTR directly dvander@541: // The reason is that the user may want to redefine SH_GLOB_SHPTR - then the macros dvander@541: // (META_RETURN_VALUE_NEWPARAMS) should obey the new pointer. dvander@541: dvander@541: namespace SourceHook dvander@541: { dvander@541: template dvander@541: void SetOverrideResult(ISourceHook *shptr, const RetType res) dvander@541: { dvander@541: *reinterpret_cast(shptr->GetOverrideRetPtr()) = res; dvander@541: } dvander@541: dvander@541: // SetOverrideResult used to be implemented like this: dvander@541: // SetOverrideResult(shptr, memfuncptr, return); dvander@541: // normally the compiler can deduce the return type from memfuncptr, but (at least msvc8) failed when it was a reference dvander@541: // (it thought it was ambigous - the ref and non-ref type) dvander@541: // so now SetOverrideResult(memfuncptr) deduces the ret type, and returns a functor which does the work dvander@541: // new syntax: SetOverrideResult(memfuncptr)(shptr, return) dvander@541: // This also allows us to create a special version for references which respects ReferenceCarrier. dvander@541: dvander@541: template struct OverrideFunctor dvander@541: { dvander@541: void operator()(ISourceHook *shptr, T res) dvander@541: { dvander@541: *reinterpret_cast(shptr->GetOverrideRetPtr()) = res; dvander@541: } dvander@541: }; dvander@541: template struct OverrideFunctor dvander@541: { dvander@541: void operator()(ISourceHook *shptr, T &res) dvander@541: { dvander@541: // overrideretptr points to ReferenceCarrier dvander@541: *reinterpret_cast::type *>(shptr->GetOverrideRetPtr()) = res; dvander@541: } dvander@541: }; dvander@541: @[$1,0,$a: dvander@541: template dvander@541: OverrideFunctor SetOverrideResult(RetType (Iface::*mfp)(@[$2,1,$1|, :Param$2@])) dvander@541: { dvander@541: return OverrideFunctor(); dvander@541: } dvander@541: dvander@541: template dvander@541: Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(@[$2,1,$1|, :Param$2@])) dvander@541: { dvander@541: return reinterpret_cast(shptr->GetIfacePtr()); dvander@541: } dvander@541: @] dvander@541: } dvander@541: dvander@541: #endif dvander@541: // The pope is dead. -> :(