pavolmarko@1: /* ======== SourceHook ======== ds@294: * Copyright (C) 2004-2007 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@384: */ 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@384: // 5 - New "V2" interface pavolmarko@384: #define SH_IFACE_VERSION 5 pavolmarko@324: pavolmarko@324: // Impl versions: pavolmarko@324: // ??? pavolmarko@324: // 4 - addition of hook ids and vp hooks (with them, AddHookNew and RemoveHookNew) pavolmarko@324: // This is not a SH_IFACE_VERSION change so that old plugins continue working! pavolmarko@384: // 5 - implementation of the new "V2" interface pavolmarko@328: #define SH_IMPL_VERSION 5 pavolmarko@58: pavolmarko@163: // Hookman version: pavolmarko@384: // 1 - standard 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@384: #include "sh_memfuncinfo.h" pavolmarko@1: #include "FastDelegate.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@384: pavolmarko@384: template class CallClass : public T pavolmarko@384: { pavolmarko@384: }; pavolmarko@384: typedef void ManualCallClass; pavolmarko@384: pavolmarko@384: /** pavolmarko@384: * @brief Describes the way a parameter/retval is passed. pavolmarko@384: */ pavolmarko@384: struct PassInfo pavolmarko@384: { pavolmarko@384: enum PassType pavolmarko@384: { pavolmarko@384: PassType_Unknown=0, /**< Unknown -- no extra info available */ pavolmarko@384: PassType_Basic, /**< Plain old register data (pointers, integers) */ pavolmarko@384: PassType_Float, /**< Floating point data */ pavolmarko@384: PassType_Object, /**< Object or structure */ pavolmarko@384: }; pavolmarko@384: pavolmarko@384: enum PassFlags pavolmarko@384: { pavolmarko@384: PassFlag_ByVal = (1<<0), /**< Passing by value */ pavolmarko@384: PassFlag_ByRef = (1<<1), /**< Passing by reference */ pavolmarko@384: PassFlag_ODtor = (1<<2), /**< Object has a destructor */ pavolmarko@412: PassFlag_OCtor = (1<<3), /**< Object has a normal non-trivial constructor */ pavolmarko@412: PassFlag_AssignOp = (1<<4), /**< Object has a non-trivial assignment operator */ pavolmarko@436: PassFlag_CCtor = (1<<5), /**< Object has a copy constructor (which takes const Object& as only parameter) */ pavolmarko@436: pavolmarko@436: // The following two flags are only relevant for byval return types. pavolmarko@436: // SH tries to auto-detect these pavolmarko@436: // If you want to override SH's auto-detection, pass them in yourself pavolmarko@436: PassFlag_RetMem = (1<<6), /**< Object is returned in memory (through hidden first param */ pavolmarko@436: PassFlag_RetReg = (1<<7) /**< Object is returned in EAX(:EDX) */ pavolmarko@384: }; pavolmarko@384: pavolmarko@384: size_t size; //!< Size of the data being passed pavolmarko@384: pavolmarko@384: // Extra info: pavolmarko@384: // (might be used in future versions for automatic hookfunc generation) pavolmarko@384: int type; //!< PassType value pavolmarko@384: unsigned int flags; //!< Pass/return flags pavolmarko@412: pavolmarko@412: struct V2Info pavolmarko@412: { pavolmarko@418: void *pNormalCtor; pavolmarko@412: void *pCopyCtor; pavolmarko@418: void *pDtor; pavolmarko@412: void *pAssignOperator; pavolmarko@412: }; pavolmarko@384: }; pavolmarko@384: pavolmarko@157: struct ProtoInfo pavolmarko@157: { pavolmarko@384: enum CallConvention pavolmarko@157: { pavolmarko@384: CallConv_Unknown, /**< Unknown -- no extra info available */ pavolmarko@384: CallConv_ThisCall, /**< This call (object pointer required) */ pavolmarko@384: CallConv_Cdecl, /**< Standard C call */ pavolmarko@384: }; pavolmarko@157: pavolmarko@384: int numOfParams; //!< number of parameters pavolmarko@384: PassInfo retPassInfo; //!< PassInfo for the return value. size=0 -> no retval pavolmarko@384: const PassInfo *paramsPassInfo; //!< PassInfos for the parameters pavolmarko@384: pavolmarko@412: // paramsPassInfo[0] is basically a dummy parameter. pavolmarko@412: // However, paramsPassInfo[0].size stores the version of the ProtoInfo structure. pavolmarko@412: pavolmarko@384: // Extra info: pavolmarko@384: int convention; pavolmarko@412: pavolmarko@412: // Version2: pavolmarko@418: PassInfo::V2Info retPassInfo2; pavolmarko@418: const PassInfo::V2Info *paramsPassInfo2; pavolmarko@1: }; pavolmarko@1: pavolmarko@123: struct IHookManagerInfo; pavolmarko@1: pavolmarko@1: /** pavolmarko@117: * @brief Pointer to hook manager interface function pavolmarko@1: * pavolmarko@384: * The hook manager should store hi for later use if store==true. It should then call hi->SetInfo(...) if hi pavolmarko@384: * is non-null. The hook manager can return 0 for success or a non-zero value if it doesn't want to be used. pavolmarko@117: * pavolmarko@117: * @param hi A pointer to IHookManagerInfo pavolmarko@1: */ pavolmarko@384: typedef int (*HookManagerPubFunc)(bool store, IHookManagerInfo *hi); pavolmarko@1: pavolmarko@1: class ISHDelegate pavolmarko@1: { pavolmarko@1: public: pavolmarko@384: virtual bool IsEqual(ISHDelegate *pOtherDeleg) = 0; // pOtherDeleg is from the same plugin and hookman pavolmarko@384: virtual void DeleteThis() = 0; pavolmarko@117: }; pavolmarko@1: pavolmarko@117: struct IHookManagerInfo pavolmarko@117: { pavolmarko@384: virtual void SetInfo(int hookman_version, int vtbloffs, int vtblidx, pavolmarko@384: ProtoInfo *proto, void *hookfunc_vfnptr) = 0; pavolmarko@1: }; pavolmarko@1: 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@384: struct IHookContext pavolmarko@384: { pavolmarko@384: virtual ISHDelegate *GetNext() = 0; pavolmarko@384: virtual void *GetOverrideRetPtr() = 0; pavolmarko@384: virtual const void *GetOrigRetPtr() = 0; pavolmarko@384: virtual bool ShouldCallOrig() = 0; pavolmarko@384: }; pavolmarko@384: 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@324: * @brief Modes for the new AddHook pavolmarko@324: */ pavolmarko@324: enum AddHookMode pavolmarko@324: { pavolmarko@324: Hook_Normal, pavolmarko@328: Hook_VP, pavolmarko@328: Hook_DVP pavolmarko@324: }; pavolmarko@324: pavolmarko@324: /** pavolmarko@324: * @brief Add a (VP) hook. pavolmarko@324: * pavolmarko@324: * @return non-zero hook id on success, 0 otherwise pavolmarko@324: * pavolmarko@324: * @param plug The unique identifier of the plugin that calls this function pavolmarko@324: * @param mode Can be either Hook_Normal or Hook_VP (vtable-wide hook) pavolmarko@324: * @param iface The interface pointer pavolmarko@324: * @param ifacesize The size of the class iface points to pavolmarko@324: * @param myHookMan A hook manager function that should be capable of handling the function pavolmarko@384: * @param handler A pointer to the hook handler something pavolmarko@324: * @param post Set to true if you want a post handler pavolmarko@324: */ pavolmarko@384: virtual int AddHook(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, pavolmarko@384: ISHDelegate *handler, bool post) = 0; pavolmarko@384: pavolmarko@384: // Source backwarts compat (only for normal hooks) pavolmarko@384: virtual bool RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, pavolmarko@324: ISHDelegate *handler, bool post) = 0; pavolmarko@324: pavolmarko@324: /** pavolmarko@384: * @brief Remove a hook by ID. pavolmarko@384: * pavolmarko@384: * @return true on success, false otherwise pavolmarko@384: * pavolmarko@384: * @param hookid The hook id (returned by AddHook) pavolmarko@384: */ pavolmarko@384: virtual bool RemoveHookByID(int hookid) = 0; pavolmarko@384: pavolmarko@384: /** pavolmarko@384: * @brief Pause a hook by ID. pavolmarko@384: * pavolmarko@384: * @return true on success, false otherwise pavolmarko@384: * pavolmarko@384: * @param hookid The hook id (returned by AddHook) pavolmarko@384: */ pavolmarko@384: virtual bool PauseHookByID(int hookid) = 0; pavolmarko@384: pavolmarko@384: /** pavolmarko@384: * @brief Unpause a hook by ID. pavolmarko@324: * pavolmarko@324: * @return true on success, false otherwise pavolmarko@324: * pavolmarko@384: * @param hookid The hook id (returned by AddHook) pavolmarko@384: */ pavolmarko@384: virtual bool UnpauseHookByID(int hookid) = 0; pavolmarko@384: pavolmarko@384: /** pavolmarko@384: * @brief Checks whether a plugin has (a) hook manager(s) that is/are currently used by other plugins pavolmarko@384: * pavolmarko@384: * @param plug The unique identifier of the plugin in question pavolmarko@324: */ pavolmarko@384: pavolmarko@384: virtual void SetRes(META_RES res) = 0; //!< Sets the meta result pavolmarko@384: virtual META_RES GetPrevRes() = 0; //!< Gets the meta result of the pavolmarko@384: //!< previously calledhandler pavolmarko@384: virtual META_RES GetStatus() = 0; //!< Gets the highest meta result pavolmarko@384: virtual const void *GetOrigRet() = 0; //!< Gets the original result. pavolmarko@384: //!< If not in post function, undefined pavolmarko@384: virtual const void *GetOverrideRet() = 0; //!< Gets the override result. pavolmarko@384: //!< If none is specified, NULL pavolmarko@384: virtual void *GetIfacePtr() = 0; //!< Gets the interface pointer pavolmarko@384: pavolmarko@384: virtual void *GetOverrideRetPtr() = 0; //!< Used for setting the override return value pavolmarko@384: pavolmarko@384: /** pavolmarko@384: * @brief Remove a hook manager. Auto-removes all hooks attached to it from plugin plug. pavolmarko@384: * pavolmarko@384: * @param plug The owner of the hook manager pavolmarko@384: * @param pubFunc The hook manager's info function pavolmarko@384: */ pavolmarko@384: virtual void RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc) = 0; pavolmarko@384: pavolmarko@384: // For SH_CALL: pavolmarko@328: pavolmarko@328: /** pavolmarko@328: * @brief Makes sure that hooks are going to be ignored on the next call of vfnptr pavolmarko@328: * pavolmarko@328: * @param plug The unique identifier of the plugin that calls this function pavolmarko@328: * @param vfnptr The virtual function pointer of the function in question pavolmarko@328: */ pavolmarko@384: virtual void SetIgnoreHooks(void *vfnptr) = 0; pavolmarko@328: pavolmarko@328: /** pavolmarko@328: * @brief Reverses SetIgnoreHooks' effect pavolmarko@328: * pavolmarko@328: * @param plug The unique identifier of the plugin that calls this function pavolmarko@328: * @param vfnptr The virtual function pointer of the function in question pavolmarko@328: */ pavolmarko@384: virtual void ResetIgnoreHooks(void *vfnptr) = 0; pavolmarko@384: pavolmarko@386: /** pavolmarko@386: * @brief Finds the original entry of a virtual function pointer pavolmarko@386: * pavolmarko@386: * @param vfnptr The virtual function pointer pavolmarko@386: * @return The original entry if the virtual function pointer has been patched; NULL otherwise. pavolmarko@386: */ pavolmarko@386: virtual void *GetOrigVfnPtrEntry(void *vfnptr) = 0; pavolmarko@386: pavolmarko@384: ////////////////////////////////////////////////////////////////////////// pavolmarko@384: pavolmarko@384: // For hook managers pavolmarko@384: pavolmarko@384: // Returns the current iface ptr pavolmarko@384: virtual void DoRecall() = 0; //!< Initiates a recall sequence pavolmarko@384: pavolmarko@384: /* pavolmarko@384: HOW RECALLS WORK: pavolmarko@384: pavolmarko@384: The problem: pavolmarko@384: Users want the ability to change parameters of the called function pavolmarko@384: from inside their handler. pavolmarko@384: The solution: pavolmarko@384: 1) Mark as "recall" pavolmarko@384: 2) Recall the function pavolmarko@384: 3) => SH's hook func gets called: pavolmarko@384: 4) The first iterator points at the first hook the last hookfunc didn't execute yet pavolmarko@384: 5) does all iteration and returns normally pavolmarko@384: 6) The user's handler returns immediately pavolmarko@384: 7) The hook func returns immediately as well pavolmarko@384: pavolmarko@384: Also note that the recalled hookfunc starts with the status the recalling hookfunc pavolmarko@384: ended with. The last handler (doing the recall) is also able to specify its own pavolmarko@384: META_RES. pavolmarko@384: */ pavolmarko@333: pavolmarko@333: /** pavolmarko@384: * @brief Set up the hook loop. pavolmarko@333: * pavolmarko@384: * @param statusPtr pointer to status variable pavolmarko@384: * @param prevResPtr pointer to previous result variable pavolmarko@384: * @param curResPtr pointer to current result variable pavolmarko@384: * @param ifacePtrPtr pointer to interface this pointer variable pavolmarko@384: * @param origRetPr pointer to original return value variable. NULL for void funcs pavolmarko@384: * @param overrideRetPtr pointer to override return value variable. NULL for void funcs pavolmarko@384: * pavolmarko@384: * @return Override Return Pointer the hookfunc should use (may differ from overrideRetPtr pavolmarko@384: * when the hook func is being called as part of a recall pavolmarko@333: */ pavolmarko@384: virtual IHookContext *SetupHookLoop(IHookManagerInfo *hi, void *vfnptr, void *thisptr, void **origentry, pavolmarko@384: META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr, pavolmarko@384: const void *origRetPtr, void *overrideRetPtr) = 0; pavolmarko@384: pavolmarko@384: virtual void EndContext(IHookContext *pCtx) = 0; 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@234: T &ref = *reinterpret_cast::type *>(shptr->GetOrigRet()); pavolmarko@233: return &ref; pavolmarko@233: } pavolmarko@233: inline static T* GetOverrideRet(ISourceHook *shptr) pavolmarko@233: { pavolmarko@234: T &ref = *reinterpret_cast::type *>(shptr->GetOverrideRet()); pavolmarko@233: return &ref; pavolmarko@233: } pavolmarko@233: }; pavolmarko@386: pavolmarko@386: template pavolmarko@386: void *GetOrigVfnPtrEntry(X *pInstance, MFP mfp, ISourceHook *pSH) pavolmarko@386: { pavolmarko@386: SourceHook::MemFuncInfo info = {true, -1, 0, 0}; pavolmarko@386: SourceHook::GetFuncInfo(pInstance, mfp, info); pavolmarko@386: pavolmarko@386: void *vfnptr = reinterpret_cast( pavolmarko@386: *reinterpret_cast(reinterpret_cast(pInstance) + info.thisptroffs + info.vtbloffs) + info.vtblindex); pavolmarko@386: pavolmarko@386: void *origentry = pSH->GetOrigVfnPtrEntry(vfnptr); pavolmarko@386: pavolmarko@386: return origentry ? origentry : *reinterpret_cast(vfnptr); pavolmarko@386: } pavolmarko@412: pavolmarko@412: template struct GetPassInfo pavolmarko@412: { pavolmarko@412: static const int type = 0; pavolmarko@412: static const unsigned int flags = PassInfo::PassFlag_ByVal; pavolmarko@412: }; pavolmarko@412: pavolmarko@412: template struct GetPassInfo pavolmarko@412: { pavolmarko@412: static const int type = 0; pavolmarko@412: static const unsigned int flags = PassInfo::PassFlag_ByRef; pavolmarko@412: }; 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@384: pavolmarko@384: template pavolmarko@384: SourceHook::CallClass *SH_GET_CALLCLASS(T *p) pavolmarko@384: { pavolmarko@384: return static_cast< SourceHook::CallClass *>(p); pavolmarko@384: } pavolmarko@384: #define SH_RELEASE_CALLCLASS(p) pavolmarko@384: pavolmarko@384: #define SH_GET_MCALLCLASS(p, size) reinterpret_cast(p) pavolmarko@384: pavolmarko@384: // only call these from the hook handlers directly! pavolmarko@384: 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@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@384: 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@386: #define SH_GET_ORIG_VFNPTR_ENTRY(inst, mfp) (SourceHook::GetOrigVfnPtrEntry(inst, mfp, SH_GLOB_SHPTR)) pavolmarko@386: pavolmarko@324: // New ADD / REMOVE macros. pavolmarko@324: #define SH_STATIC(func) fastdelegate::MakeDelegate(func) pavolmarko@324: #define SH_MEMBER(inst, func) fastdelegate::MakeDelegate(inst, func) pavolmarko@324: pavolmarko@1: #define SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \ pavolmarko@58: __SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast(ifaceptr), \ pavolmarko@384: SourceHook::ISourceHook::Hook_Normal, post, handler) 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@324: post, handler) pavolmarko@157: pavolmarko@157: #define SH_ADD_MANUALHOOK(hookname, ifaceptr, handler, post) \ pavolmarko@384: __SourceHook_FHMAdd##hookname(reinterpret_cast(ifaceptr), \ pavolmarko@384: SourceHook::ISourceHook::Hook_Normal, post, handler) pavolmarko@157: pavolmarko@157: #define SH_REMOVE_MANUALHOOK(hookname, ifaceptr, handler, post) \ pavolmarko@324: __SourceHook_FHMRemove##hookname(reinterpret_cast(ifaceptr), post, handler) pavolmarko@324: pavolmarko@324: #define SH_ADD_VPHOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \ pavolmarko@384: __SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast(ifaceptr), \ pavolmarko@384: SourceHook::ISourceHook::Hook_VP, post, handler) pavolmarko@328: pavolmarko@384: #define SH_ADD_DVPHOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \ pavolmarko@384: __SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast(ifaceptr), \ pavolmarko@384: SourceHook::ISourceHook::Hook_DVP, post, handler) pavolmarko@324: pavolmarko@324: #define SH_ADD_MANUALVPHOOK(hookname, ifaceptr, handler, post) \ pavolmarko@384: __SourceHook_FHMAdd##hookname(reinterpret_cast(ifaceptr), SourceHook::ISourceHook::Hook_VP, post, handler) pavolmarko@328: pavolmarko@384: #define SH_ADD_MANUALDVPHOOK(hookname, ifaceptr, handler, post) \ pavolmarko@384: __SourceHook_FHMAdd##hookname(reinterpret_cast(ifaceptr), SourceHook::ISourceHook::Hook_DVP, post, handler) pavolmarko@324: pavolmarko@324: #define SH_REMOVE_HOOK_ID(hookid) \ pavolmarko@384: (SH_GLOB_SHPTR->RemoveHookByID(hookid)) pavolmarko@324: pavolmarko@324: // Old macros pavolmarko@324: // !! These are now deprecated. Instead, use one of these: pavolmarko@324: // SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post) pavolmarko@324: // SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post) pavolmarko@324: pavolmarko@324: #define SH_ADD_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \ pavolmarko@324: SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post) pavolmarko@324: #define SH_ADD_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \ pavolmarko@324: SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post) pavolmarko@324: pavolmarko@324: // SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post) pavolmarko@324: // SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post) pavolmarko@324: pavolmarko@324: #define SH_REMOVE_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \ pavolmarko@324: SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post) pavolmarko@324: #define SH_REMOVE_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \ pavolmarko@324: SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post) pavolmarko@324: pavolmarko@324: // SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post) pavolmarko@324: // SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post) pavolmarko@324: pavolmarko@324: #define SH_ADD_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \ pavolmarko@324: SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post) pavolmarko@324: #define SH_ADD_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \ pavolmarko@324: SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post) pavolmarko@324: pavolmarko@324: // SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post) pavolmarko@324: // SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post) pavolmarko@324: pavolmarko@157: #define SH_REMOVE_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \ pavolmarko@324: SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post) pavolmarko@157: #define SH_REMOVE_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \ pavolmarko@324: SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post) 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@384: static int HookManPubFunc(bool store, ::SourceHook::IHookManagerInfo *hi) \ 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@324: if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \ pavolmarko@324: return 1; \ pavolmarko@384: if (store) \ pavolmarko@384: ms_HI = hi; \ pavolmarko@384: if (hi) \ pavolmarko@1: { \ ds@238: MemFuncInfo mfi = {true, -1, 0, 0}; \ pavolmarko@1: GetFuncInfo(&SH_FHCls(ifacetype,ifacefunc,overload)::Func, mfi); \ pavolmarko@384: hi->SetInfo(SH_HOOKMAN_VERSION, ms_MFI.vtbloffs, ms_MFI.vtblindex, &ms_Proto, \ pavolmarko@384: reinterpret_cast(reinterpret_cast(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex] ); \ pavolmarko@1: } \ pavolmarko@384: return 0; \ 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@384: int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \ pavolmarko@45: SH_FHCls(ifacetype,ifacefunc,overload)::FD handler) \ pavolmarko@45: { \ pavolmarko@45: using namespace ::SourceHook; \ ds@238: MemFuncInfo mfi = {true, -1, 0, 0}; \ 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@384: return SH_GLOB_SHPTR->AddHook(SH_GLOB_PLUGPTR, mode, \ pavolmarko@328: iface, mfi.thisptroffs, SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, \ pavolmarko@384: new SH_FHCls(ifacetype,ifacefunc,overload)::CMyDelegateImpl(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; \ ds@238: MemFuncInfo mfi = {true, -1, 0, 0}; \ pavolmarko@45: GetFuncInfo(funcptr, mfi); \ pavolmarko@384: SH_FHCls(ifacetype,ifacefunc,overload)::CMyDelegateImpl 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@384: static int HookManPubFunc(bool store, ::SourceHook::IHookManagerInfo *hi) \ pavolmarko@157: { \ pavolmarko@157: using namespace ::SourceHook; \ pavolmarko@157: /* Verify interface version */ \ pavolmarko@157: if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \ pavolmarko@157: return 1; \ pavolmarko@324: if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \ pavolmarko@324: return 1; \ pavolmarko@384: if (store) \ pavolmarko@384: ms_HI = hi; \ pavolmarko@384: if (hi) \ pavolmarko@157: { \ ds@238: MemFuncInfo mfi = {true, -1, 0, 0}; \ pavolmarko@157: GetFuncInfo(&SH_MFHCls(hookname)::Func, mfi); \ pavolmarko@384: hi->SetInfo(SH_HOOKMAN_VERSION, ms_MFI.vtbloffs, ms_MFI.vtblindex, &ms_Proto, \ pavolmarko@384: reinterpret_cast(reinterpret_cast(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex] ); \ pavolmarko@157: } \ pavolmarko@384: return 0; \ 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@384: int __SourceHook_FHMAdd##hookname(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \ pavolmarko@157: SH_MFHCls(hookname)::FD handler) \ pavolmarko@157: { \ pavolmarko@384: return SH_GLOB_SHPTR->AddHook(SH_GLOB_PLUGPTR, mode, \ pavolmarko@328: iface, pthisptroffs, SH_MFHCls(hookname)::HookManPubFunc, \ pavolmarko@384: new SH_MFHCls(hookname)::CMyDelegateImpl(handler), post); \ pavolmarko@157: } \ pavolmarko@157: bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \ pavolmarko@157: SH_MFHCls(hookname)::FD handler) \ pavolmarko@157: { \ pavolmarko@384: SH_MFHCls(hookname)::CMyDelegateImpl 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@41: #define SH_SETUPCALLS(rettype, paramtypes, params) \ pavolmarko@384: /* 1) Set up */ \ 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@384: void *vfnptr_origentry; \ pavolmarko@41: \ pavolmarko@128: META_RES status = MRES_IGNORED; \ pavolmarko@128: META_RES prev_res; \ pavolmarko@128: META_RES cur_res; \ pavolmarko@384: \ pavolmarko@412: typedef ReferenceCarrier< rettype >::type my_rettype; \ pavolmarko@233: my_rettype orig_ret; \ pavolmarko@233: my_rettype override_ret; \ pavolmarko@233: my_rettype plugin_ret; \ pavolmarko@384: IMyDelegate *iter; \ pavolmarko@384: IHookContext *pContext = SH_GLOB_SHPTR->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast(this), \ pavolmarko@384: &vfnptr_origentry, &status, &prev_res, &cur_res, &orig_ret, &override_ret); pavolmarko@1: pavolmarko@1: #define SH_CALL_HOOKS(post, params) \ pavolmarko@384: prev_res = MRES_IGNORED; \ pavolmarko@387: while ( (iter = static_cast(pContext->GetNext())) ) \ pavolmarko@1: { \ pavolmarko@384: cur_res = MRES_IGNORED; \ pavolmarko@384: plugin_ret = iter->Call params; \ pavolmarko@384: prev_res = cur_res; \ pavolmarko@384: if (cur_res > status) \ pavolmarko@384: status = cur_res; \ pavolmarko@384: if (cur_res >= MRES_OVERRIDE) \ pavolmarko@384: *reinterpret_cast(pContext->GetOverrideRetPtr()) = plugin_ret; \ pavolmarko@1: } pavolmarko@1: pavolmarko@157: #define SH_CALL_ORIG(rettype, paramtypes, params) \ pavolmarko@384: if (status != MRES_SUPERCEDE && pContext->ShouldCallOrig()) \ 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@384: orig_ret = override_ret; /* :TODO: ??? : use pContext->GetOverrideRetPtr() or not? */ pavolmarko@1: pavolmarko@1: #define SH_RETURN() \ pavolmarko@384: const my_rettype *retptr = reinterpret_cast( \ pavolmarko@384: (status >= MRES_OVERRIDE) ? pContext->GetOverrideRetPtr() : pContext->GetOrigRetPtr()); \ pavolmarko@384: SH_GLOB_SHPTR->EndContext(pContext); \ pavolmarko@384: return *retptr; 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@384: /* 1) Set up */ \ 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@384: void *vfnptr_origentry; \ pavolmarko@41: \ pavolmarko@128: META_RES status = MRES_IGNORED; \ pavolmarko@128: META_RES prev_res; \ pavolmarko@128: META_RES cur_res; \ pavolmarko@384: \ pavolmarko@384: IMyDelegate *iter; \ pavolmarko@384: IHookContext *pContext = SH_GLOB_SHPTR->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast(this), \ pavolmarko@384: &vfnptr_origentry, &status, &prev_res, &cur_res, NULL, NULL); pavolmarko@1: pavolmarko@1: #define SH_CALL_HOOKS_void(post, params) \ pavolmarko@384: prev_res = MRES_IGNORED; \ pavolmarko@387: while ( (iter = static_cast(pContext->GetNext())) ) \ pavolmarko@1: { \ pavolmarko@384: cur_res = MRES_IGNORED; \ pavolmarko@384: iter->Call params; \ pavolmarko@384: prev_res = cur_res; \ pavolmarko@384: if (cur_res > status) \ pavolmarko@384: status = cur_res; \ pavolmarko@1: } pavolmarko@1: pavolmarko@157: #define SH_CALL_ORIG_void(paramtypes, params) \ pavolmarko@384: if (status != MRES_SUPERCEDE && pContext->ShouldCallOrig()) \ 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@384: SH_GLOB_SHPTR->EndContext(pContext); 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@384: #define MAKE_DELEG(ret_type, params_decl, params_pass) \ pavolmarko@384: struct IMyDelegate : ::SourceHook::ISHDelegate { virtual ret_type Call params_decl = 0; }; \ pavolmarko@384: struct CMyDelegateImpl : IMyDelegate \ pavolmarko@384: { \ pavolmarko@384: FD m_Deleg; \ pavolmarko@384: CMyDelegateImpl(FD deleg) : m_Deleg(deleg) {} \ pavolmarko@384: ret_type Call params_decl { return m_Deleg params_pass; } \ pavolmarko@384: void DeleteThis() { delete this; } \ pavolmarko@384: bool IsEqual(ISHDelegate *pOtherDeleg) { return m_Deleg == static_cast(pOtherDeleg)->m_Deleg; } \ pavolmarko@384: }; pavolmarko@384: pavolmarko@384: #define MAKE_DELEG_void(params_decl, params_pass) \ pavolmarko@384: struct IMyDelegate : ::SourceHook::ISHDelegate { virtual void Call params_decl = 0; }; \ pavolmarko@384: struct CMyDelegateImpl : IMyDelegate \ pavolmarko@384: { \ pavolmarko@384: FD m_Deleg; \ pavolmarko@384: CMyDelegateImpl(FD deleg) : m_Deleg(deleg) {} \ pavolmarko@384: void Call params_decl { m_Deleg params_pass; } \ pavolmarko@384: void DeleteThis() { delete this; } \ pavolmarko@384: bool IsEqual(ISHDelegate *pOtherDeleg) { return m_Deleg == static_cast(pOtherDeleg)->m_Deleg; } \ pavolmarko@384: }; pavolmarko@384: pavolmarko@413: // GetPassInfo -> easier access. __SH_GPI generates a SourceHook::PassInfo instance. pavolmarko@412: #define __SH_GPI(tt) { sizeof(tt), ::SourceHook::GetPassInfo< tt >::type, ::SourceHook::GetPassInfo< tt >::flags } pavolmarko@418: // Extra pass info V2 pavolmarko@418: #define __SH_EPI { 0, 0, 0, 0 } pavolmarko@412: 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@384: MAKE_DELEG(rettype, (@[$2,1,$1|, :param$2 p$2@]), (@[$2,1,$1|, :p$2@])); \ 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@418: const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \ pavolmarko@418: const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \ pavolmarko@412: ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { $1, __SH_GPI(rettype), \ pavolmarko@418: __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0, __SH_EPI, __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload }; pavolmarko@384: pavolmarko@421: #define SH_DECL_EXTERN$1(ifacetype, ifacefunc, attr, overload, rettype@[$2,1,$1:, param$2@]) \ pavolmarko@421: int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \ pavolmarko@421: fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> handler); \ pavolmarko@421: bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \ pavolmarko@421: fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> handler); 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@384: MAKE_DELEG_void((@[$2,1,$1|, :param$2 p$2@]), (@[$2,1,$1|, :p$2@])); \ 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@418: const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {1, 0, 0}@[$2,1,$1:,__SH_GPI(param$2)@] }; \ pavolmarko@418: const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \ pavolmarko@384: ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { $1, { 0, 0, 0 }, \ pavolmarko@418: __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0, __SH_EPI, __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload }; pavolmarko@1: pavolmarko@421: #define SH_DECL_EXTERN$1_void(ifacetype, ifacefunc, attr, overload@[$2,1,$1:, param$2@]) \ pavolmarko@421: int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \ pavolmarko@421: fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> handler); \ pavolmarko@421: bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \ pavolmarko@421: fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> handler); pavolmarko@421: 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@384: MAKE_DELEG(rettype, (@[$2,1,$1|, :param$2 p$2@]@[$1!=0:, @]const char *px), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]px)); \ pavolmarko@384: 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@418: const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \ pavolmarko@418: const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \ pavolmarko@412: ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { $1, __SH_GPI(rettype), \ pavolmarko@418: __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0, __SH_EPI, __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload }; pavolmarko@1: pavolmarko@421: #define SH_DECL_EXTERN$1_vafmt(ifacetype, ifacefunc, attr, overload, rettype@[$2,1,$1:, param$2@]) \ pavolmarko@421: int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \ pavolmarko@421: fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, rettype> handler); \ pavolmarko@421: bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \ pavolmarko@421: fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, rettype> handler); pavolmarko@421: 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@384: MAKE_DELEG_void((@[$2,1,$1|, :param$2 p$2@]@[$1!=0:, @]const char *px), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]px)); \ 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@418: const ::SourceHook::PassInfo __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \ pavolmarko@418: const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \ pavolmarko@384: ::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto = { $1, { 0, 0, 0 }, \ pavolmarko@418: __SourceHook_ParamInfos_##ifacetype##ifacefunc##overload, 0, __SH_EPI, __SourceHook_ParamInfos2_##ifacetype##ifacefunc##overload }; pavolmarko@157: pavolmarko@421: #define SH_DECL_EXTERN$1_void_vafmt(ifacetype, ifacefunc, attr, overload@[$2,1,$1:, param$2@]) \ pavolmarko@421: int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \ pavolmarko@421: fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *> handler); \ pavolmarko@421: bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \ pavolmarko@421: fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *> handler); pavolmarko@421: 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@384: MAKE_DELEG(rettype, (@[$2,1,$1|, :param$2 p$2@]), (@[$2,1,$1|, :p$2@])); \ 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@418: const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \ pavolmarko@418: const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2M_##hookname[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \ pavolmarko@412: ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { $1, __SH_GPI(rettype), \ pavolmarko@418: __SourceHook_ParamInfosM_##hookname, 0, __SH_EPI, __SourceHook_ParamInfos2M_##hookname }; pavolmarko@157: pavolmarko@421: #define SH_DECL_MANUALEXTERN$1(hookname, rettype@[$2,1,$1:, param$2@]) \ pavolmarko@421: int __SourceHook_FHMAdd##hookname(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \ pavolmarko@421: fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> handler); \ pavolmarko@421: bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \ pavolmarko@421: fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> handler); pavolmarko@421: 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@384: MAKE_DELEG_void((@[$2,1,$1|, :param$2 p$2@]), (@[$2,1,$1|, :p$2@])); \ 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@418: const ::SourceHook::PassInfo __SourceHook_ParamInfosM_##hookname[] = { {1, 0, 0}@[$2,1,$1:, __SH_GPI(param$2)@] }; \ pavolmarko@418: const ::SourceHook::PassInfo::V2Info __SourceHook_ParamInfos2M_##hookname[] = { __SH_EPI@[$2,1,$1:, __SH_EPI@] }; \ pavolmarko@384: ::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto = { $1, { 0, 0, 0 }, \ pavolmarko@418: __SourceHook_ParamInfosM_##hookname , 0, __SH_EPI, __SourceHook_ParamInfos2M_##hookname }; pavolmarko@1: pavolmarko@421: #define SH_DECL_MANUALEXTERN$1_void(hookname@[$2,1,$1:, param$2@]) \ pavolmarko@421: int __SourceHook_FHMAdd##hookname(void *iface, ::SourceHook::ISourceHook::AddHookMode mode, bool post, \ pavolmarko@421: fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> handler); \ pavolmarko@421: bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \ pavolmarko@421: fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> handler); pavolmarko@196: @] pavolmarko@1: pavolmarko@41: pavolmarko@41: ////////////////////////////////////////////////////////////////////////// pavolmarko@41: // SH_CALL pavolmarko@41: pavolmarko@328: #define SH_MAKE_EXECUTABLECLASS_OB(call, prms) \ pavolmarko@61: { \ pavolmarko@61: using namespace ::SourceHook; \ pavolmarko@61: \ pavolmarko@384: m_pSH->SetIgnoreHooks(m_VfnPtr); \ pavolmarko@328: RetType tmpret = (m_ThisPtr->*m_MFP)call; \ pavolmarko@384: m_pSH->ResetIgnoreHooks(m_VfnPtr); \ pavolmarko@328: return tmpret; \ pavolmarko@61: } pavolmarko@61: pavolmarko@328: #define SH_MAKE_EXECUTABLECLASS_OB_void(call, prms) \ pavolmarko@199: { \ pavolmarko@199: using namespace ::SourceHook; \ pavolmarko@199: \ pavolmarko@384: m_pSH->SetIgnoreHooks(m_VfnPtr); \ pavolmarko@328: (m_ThisPtr->*m_MFP)call; \ pavolmarko@384: m_pSH->ResetIgnoreHooks(m_VfnPtr); \ pavolmarko@199: } pavolmarko@199: pavolmarko@41: namespace SourceHook pavolmarko@41: { pavolmarko@328: @[$1,0,$a: pavolmarko@328: // Support for $1 arguments pavolmarko@384: template class ExecutableClass$1 pavolmarko@199: { pavolmarko@328: ObjType *m_ThisPtr; pavolmarko@328: void *m_VfnPtr; pavolmarko@384: MFPType m_MFP; pavolmarko@329: ISourceHook *m_pSH; pavolmarko@199: public: pavolmarko@384: ExecutableClass$1(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp), pavolmarko@384: m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { } pavolmarko@328: pavolmarko@199: RetType operator()(@[$2,1,$1|, :Param$2 p$2@]) const pavolmarko@328: SH_MAKE_EXECUTABLECLASS_OB((@[$2,1,$1|, :p$2@]), (@[$2,1,$1|, :Param$2@])) pavolmarko@328: 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@328: SH_MAKE_EXECUTABLECLASS_OB((@[$3,1,$2|, :p$3@]), (@[$3,1,$2|, :Param$3@])) pavolmarko@199: @] pavolmarko@199: }; pavolmarko@328: pavolmarko@384: template class ExecutableClass$1 pavolmarko@328: { pavolmarko@384: ObjType *m_ThisPtr; pavolmarko@384: void *m_VfnPtr; pavolmarko@384: MFPType m_MFP; pavolmarko@384: ISourceHook *m_pSH; pavolmarko@328: public: pavolmarko@384: ExecutableClass$1(ObjType *tp, MFPType mfp, void *vp, ISourceHook *pSH) : m_ThisPtr(tp), pavolmarko@384: m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH) { } pavolmarko@328: pavolmarko@328: void operator()(@[$2,1,$1|, :Param$2 p$2@]) const pavolmarko@328: SH_MAKE_EXECUTABLECLASS_OB_void((@[$2,1,$1|, :p$2@]), (@[$2,1,$1|, :Param$2@])) pavolmarko@328: pavolmarko@328: @[$2,$1+1,$a: pavolmarko@328: template <@[$3,$1+1,$2|, :class Param$3@]> void operator()(@[$3,1,$2|, :Param$3 p$3@]) const pavolmarko@328: SH_MAKE_EXECUTABLECLASS_OB_void((@[$3,1,$2|, :p$3@]), (@[$3,1,$2|, :Param$3@])) pavolmarko@328: @] pavolmarko@328: }; pavolmarko@196: @] pavolmarko@41: pavolmarko@41: } pavolmarko@41: pavolmarko@328: #define SH__CALL_GET_VFNPTR_NORMAL \ pavolmarko@328: using namespace ::SourceHook; \ pavolmarko@328: MemFuncInfo mfi = {true, -1, 0, 0}; \ pavolmarko@384: GetFuncInfo(ptr, mfp, mfi); \ pavolmarko@328: void *vfnptr = reinterpret_cast( \ pavolmarko@328: *reinterpret_cast(reinterpret_cast(ptr) + mfi.thisptroffs + mfi.vtbloffs) + mfi.vtblindex); pavolmarko@328: pavolmarko@328: #define SH__CALL_GET_VFNPTR_MANUAL \ pavolmarko@328: using namespace ::SourceHook; \ pavolmarko@328: void *vfnptr = reinterpret_cast( \ pavolmarko@384: *reinterpret_cast( (reinterpret_cast(ptr) + thisptroffs + vtbloffs) ) + vtblidx); \ pavolmarko@328: /* patch mfp */ \ pavolmarko@328: *reinterpret_cast(&mfp) = *reinterpret_cast(vfnptr); pavolmarko@328: 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@384: SourceHook::ExecutableClass$1 pavolmarko@384: SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]), SourceHook::ISourceHook *shptr) pavolmarko@41: { pavolmarko@328: SH__CALL_GET_VFNPTR_NORMAL pavolmarko@384: return SourceHook::ExecutableClass$1(ptr, mfp, vfnptr, shptr); pavolmarko@41: } pavolmarko@41: pavolmarko@196: template pavolmarko@384: SourceHook::ExecutableClass$1 pavolmarko@384: SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@])const, SourceHook::ISourceHook *shptr) pavolmarko@45: { pavolmarko@328: SH__CALL_GET_VFNPTR_NORMAL pavolmarko@384: return SourceHook::ExecutableClass$1(ptr, mfp, vfnptr, shptr); pavolmarko@50: } pavolmarko@50: pavolmarko@328: template pavolmarko@328: SourceHook::ExecutableClass$1 pavolmarko@384: SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr) pavolmarko@199: { pavolmarko@328: SH__CALL_GET_VFNPTR_MANUAL pavolmarko@328: return SourceHook::ExecutableClass$1( pavolmarko@384: reinterpret_cast(ptr), mfp, vfnptr, shptr); 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@384: SourceHook::ExecutableClass$1 pavolmarko@384: SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]@[$1!=0:, @]...), SourceHook::ISourceHook *shptr) pavolmarko@58: { pavolmarko@328: SH__CALL_GET_VFNPTR_NORMAL pavolmarko@384: return SourceHook::ExecutableClass$1(ptr, mfp, vfnptr, shptr); pavolmarko@58: } pavolmarko@58: pavolmarko@196: template pavolmarko@384: SourceHook::ExecutableClass$1 pavolmarko@384: SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]@[$1!=0:, @]...)const, SourceHook::ISourceHook *shptr) pavolmarko@58: { pavolmarko@328: SH__CALL_GET_VFNPTR_NORMAL pavolmarko@384: return SourceHook::ExecutableClass$1(ptr, mfp, vfnptr, shptr); pavolmarko@58: } pavolmarko@199: pavolmarko@196: @] pavolmarko@58: pavolmarko@58: #endif pavolmarko@58: pavolmarko@384: #define SH_CALL(ptr, mfp) SH_CALL2((ptr), (mfp), (mfp), SH_GLOB_SHPTR) pavolmarko@384: #define SH_MCALL2(ptr, mfp, vtblidx, vtbloffs, thisptroffs) SH_MCALL3((ptr), (mfp), (mfp), (vtblidx), (vtbloffs), (thisptroffs), SH_GLOB_SHPTR) 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@384: #undef SH_MAKE_EXECUTABLECLASS_OB_void 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@234: *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. -> :(