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