sourcehook/generate/sourcehook.h
author Pavol Marko <pavolmarko@gmail.com>
Sun Oct 07 22:10:07 2007 +0000 (2007-10-07)
changeset 380 f9e21a2ac558
parent 333 3813f1ac0cfe
child 382 8b06ecc6e76d
permissions -rw-r--r--
New auto-hookfunc-gen friendly interface
! breaks binary compatibility !
     1 /* ======== SourceHook ========
     2 * Copyright (C) 2004-2007 Metamod:Source Development Team
     3 * No warranties of any kind
     4 *
     5 * License: zlib/libpng
     6 *
     7 * Author(s): Pavol "PM OnoTo" Marko
     8 * ============================
     9 */
    10 
    11 /**
    12 *	@file sourcehook.h
    13 *	@brief Contains the public SourceHook API
    14 */
    15 
    16 #ifndef __SOURCEHOOK_H__
    17 #define __SOURCEHOOK_H__
    18 
    19 // Interface revisions:
    20 //  1 - Initial revision
    21 //  2 - Changed to virtual functions for iterators and all queries
    22 //  3 - Added "hook loop status variable"
    23 //  4 - Reentrant
    24 #define SH_IFACE_VERSION 4
    25 
    26 // Impl versions:
    27 // ???
    28 // 4 - addition of hook ids and vp hooks (with them, AddHookNew and RemoveHookNew)
    29 //     This is not a SH_IFACE_VERSION change so that old plugins continue working!
    30 // 5 - addition of direct vp hooks (new hook mode; from now on AddHookNew checks for
    31 //	   invalid hookmode -> impl version won't have to change because of things like this)
    32 #define SH_IMPL_VERSION 5
    33 
    34 // Hookman version:
    35 //  1 - Support for recalls, performance optimisations
    36 #define SH_HOOKMAN_VERSION 1
    37 
    38 // The value of SH_GLOB_SHPTR has to be a pointer to SourceHook::ISourceHook
    39 // It's used in various macros
    40 #ifndef SH_GLOB_SHPTR
    41 #define SH_GLOB_SHPTR g_SHPtr
    42 #endif
    43 
    44 // Used to identify the current plugin
    45 #ifndef SH_GLOB_PLUGPTR
    46 #define SH_GLOB_PLUGPTR g_PLID
    47 #endif
    48 
    49 #ifdef SH_DEBUG
    50 # include <stdio.h>
    51 # include <stdlib.h>
    52 
    53 # define SH_ASSERT(x, info) \
    54 	do { \
    55 		if (!(x)) \
    56 		{ \
    57 			printf("SOURCEHOOK DEBUG ASSERTION FAILED: %s:%u(%s): %s: ", __FILE__, __LINE__, __FUNCTION__, #x); \
    58 			printf info; \
    59 			putchar('\n'); \
    60 			abort(); \
    61 		} \
    62 	} while(0)
    63 
    64 #else
    65 # define SH_ASSERT(x, info)
    66 #endif
    67 
    68 // System
    69 #define SH_SYS_WIN32 1
    70 #define SH_SYS_LINUX 2
    71 
    72 #ifdef _WIN32
    73 # define SH_SYS SH_SYS_WIN32
    74 #elif defined __linux__
    75 # define SH_SYS SH_SYS_LINUX
    76 #else
    77 # error Unsupported system
    78 #endif
    79 
    80 // Compiler
    81 #define SH_COMP_GCC 1
    82 #define SH_COMP_MSVC 2
    83 
    84 #ifdef _MSC_VER
    85 # define SH_COMP SH_COMP_MSVC
    86 #elif defined __GNUC__
    87 # define SH_COMP SH_COMP_GCC
    88 #else
    89 # error Unsupported compiler
    90 #endif
    91 
    92 #if SH_COMP==SH_COMP_MSVC
    93 # define vsnprintf _vsnprintf
    94 #endif
    95 
    96 #if SH_SYS != SH_SYS_WIN32
    97 # include <unistd.h>
    98 #endif
    99 
   100 #define SH_PTRSIZE sizeof(void*)
   101 
   102 #include "FastDelegate.h"
   103 #include "sh_memfuncinfo.h"
   104 
   105 // Good old metamod!
   106 
   107 // Flags returned by a plugin's api function.
   108 // NOTE: order is crucial, as greater/less comparisons are made.
   109 enum META_RES
   110 {
   111 	MRES_IGNORED=0,		// plugin didn't take any action
   112 	MRES_HANDLED,		// plugin did something, but real function should still be called
   113 	MRES_OVERRIDE,		// call real function, but use my return value
   114 	MRES_SUPERCEDE		// skip real function; use my return value
   115 };
   116 
   117 
   118 namespace SourceHook
   119 {
   120 	/**
   121 	*	@brief	Specifies the size (in bytes) for the internal buffer of vafmt(printf-like) function handlers
   122 	*/
   123 	const int STRBUF_LEN=4096;
   124 
   125 	/**
   126 	*	@brief	An empty class. No inheritance used. Used for original-function-call hacks
   127 	*/
   128 	class EmptyClass
   129 	{
   130 	};
   131 
   132 	/**
   133 	*	@brief Implicit cast.
   134 	*/
   135 	template <class In, class Out>
   136 		inline Out implicit_cast(In input)
   137 		{
   138 			return input;
   139 		}
   140 
   141 	/**
   142 	*	@brief A plugin typedef
   143 	*
   144 	*	SourceHook doesn't really care what this is. As long as the ==, != and = operators work on it and every
   145 	*	plugin has a unique identifier, everything is ok.
   146 	*	It should also be possible to set it to 0.
   147 	*/
   148 	typedef int Plugin;
   149 
   150 	struct ProtoInfo
   151 	{
   152 		ProtoInfo(int rtsz, int nop, const int *p) : beginningNull(0), retTypeSize(rtsz), numOfParams(nop), params(p)
   153 		{
   154 		}
   155 		int beginningNull;		//!< To distinguish from old protos (which never begin with 0)
   156 		int retTypeSize;		//!< 0 if void
   157 		int numOfParams;		//!< number of parameters
   158 		const int *params;		//!< params[0]=0 (or -1 for vararg), params[1]=size of first param, ...
   159 	};
   160 
   161 	/**
   162 	*	@brief Specifies the actions for hook managers
   163 	*/
   164 	enum HookManagerAction
   165 	{
   166 		HA_GetInfo = 0,			//!< Store info about the hook manager
   167 		HA_Register,			//!< Save the IHookManagerInfo pointer for future reference
   168 		HA_Unregister			//!< Clear the saved pointer
   169 	};
   170 
   171 	struct IHookManagerInfo;
   172 
   173 	/**
   174 	*	@brief Pointer to hook manager interface function
   175 	*
   176 	*	A "hook manager" is a the only thing that knows the actual protoype of the function at compile time.
   177 	*
   178 	*   @param ha What the hook manager should do
   179 	*	@param hi A pointer to IHookManagerInfo
   180 	*/
   181 	typedef int (*HookManagerPubFunc)(HookManagerAction ha, IHookManagerInfo *hi);
   182 
   183 	class ISHDelegate
   184 	{
   185 	public:
   186 		virtual void DeleteThis() = 0;				// Ugly, I know
   187 		virtual bool IsEqual(ISHDelegate *other) = 0;
   188 	};
   189 
   190 	template <class T> class CSHDelegate : public ISHDelegate
   191 	{
   192 		T m_Deleg;
   193 	public:
   194 		CSHDelegate(T deleg) : m_Deleg(deleg)
   195 		{
   196 		}
   197 
   198 		CSHDelegate(const CSHDelegate &other) : m_Deleg(other.m_Deleg)
   199 		{
   200 		}
   201 
   202 		void DeleteThis()
   203 		{
   204 			delete this;
   205 		}
   206 
   207 		bool IsEqual(ISHDelegate *other)
   208 		{
   209 			return static_cast<CSHDelegate<T>* >(other)->GetDeleg() == GetDeleg();
   210 		}
   211 
   212 		T &GetDeleg()
   213 		{
   214 			return m_Deleg;
   215 		}
   216 	};
   217 
   218 	struct IHookList
   219 	{
   220 		struct IIter
   221 		{
   222 			virtual bool End() = 0;
   223 			virtual void Next() = 0;
   224 			virtual ISHDelegate *Handler() = 0;
   225 			virtual int ThisPtrOffs() = 0;
   226 		};
   227 		virtual IIter *GetIter() = 0;
   228 		virtual void ReleaseIter(IIter *pIter) = 0;
   229 	};
   230 
   231 	struct IIface
   232 	{
   233 		virtual void *GetPtr() = 0;
   234 		virtual IHookList *GetPreHooks() = 0;
   235 		virtual IHookList *GetPostHooks() = 0;
   236 	};
   237 
   238 	struct IVfnPtr
   239 	{
   240 		virtual void *GetVfnPtr() = 0;
   241 		virtual void *GetOrigEntry() = 0;
   242 
   243 		virtual IIface *FindIface(void *ptr) = 0;
   244 	};
   245 
   246 	struct IHookManagerInfo
   247 	{
   248 		virtual IVfnPtr *FindVfnPtr(void *vfnptr) = 0;
   249 
   250 		virtual void SetInfo(int vtbloffs, int vtblidx, const char *proto) = 0;
   251 		virtual void SetHookfuncVfnptr(void *hookfunc_vfnptr) = 0;
   252 
   253 		// Added 23.12.2005 (yup! I'm coding RIGHT BEFORE CHRISTMAS!)
   254 		// If the hookman doesn't set this, it defaults 0
   255 		// SourceHook prefers hookmans with higher version numbers
   256 		virtual void SetVersion(int version) = 0;
   257 	};
   258 
   259 	class AutoHookIter
   260 	{
   261 		IHookList *m_pList;
   262 		IHookList::IIter *m_pIter;
   263 	public:
   264 		AutoHookIter(IHookList *pList)
   265 			: m_pList(pList), m_pIter(pList->GetIter())
   266 		{
   267 		}
   268 
   269 		~AutoHookIter()
   270 		{
   271 			if (m_pList)
   272 				m_pList->ReleaseIter(m_pIter);
   273 		}
   274 
   275 		bool End()
   276 		{
   277 			return m_pIter->End();
   278 		}
   279 
   280 		void Next()
   281 		{
   282 			m_pIter->Next();
   283 		}
   284 
   285 		ISHDelegate *Handler()
   286 		{
   287 			return m_pIter->Handler();
   288 		}
   289 
   290 		int ThisPtrOffs()
   291 		{
   292 			return m_pIter->ThisPtrOffs();
   293 		}
   294 
   295 		void SetToZero()
   296 		{
   297 			m_pList = 0;
   298 		}
   299 	};
   300 
   301 	template<class B> struct DeprecatedCallClass
   302 	{
   303 		virtual B *GetThisPtr() = 0;
   304 		virtual void *GetOrigFunc(int vtbloffs, int vtblidx) = 0;
   305 	};
   306 
   307 	// 09.08.2008 (6 AM, I just woke up, the others are still sleeping so i finally can use this notebook !!)
   308 	// - Today is an important day.
   309 	// I'm adding support for functions which return references.
   310 
   311 	// How it works:
   312 	//  SH_SETUPCALLS doesn't use plain rettype to store the temporary return values (plugin ret, orig ret,
   313 	//  override ret) anymore; instead, it uses SourceHook::ReferenceCarrier<rettype>::type
   314 	//  this is typedefed to the original rettype normally, but if the rettype is a reference, it's a special class
   315 	//  which stores the reference as a pointer, and implements constructors, operator= and a conversion operator.
   316 	//  special cases were needed for getoverrideret / getorigret; these are implemented through the
   317 	//  SourceHook::MacroRefHelpers structs.
   318 	//  Furthermore, SetOverrideRet had to be changed a bit; see SourceHook::OverrideFunctor somewhere down in this file.
   319 	template <class T> struct ReferenceCarrier
   320 	{
   321 		typedef T type;
   322 	};
   323 
   324 	template <class T> struct ReferenceCarrier<T&>
   325 	{
   326 		class type
   327 		{
   328 			T *m_StoredRef;
   329 		public:
   330 			type() : m_StoredRef(NULL)
   331 			{
   332 			}
   333 			type(T& ref) : m_StoredRef(&ref)
   334 			{
   335 			}
   336 
   337 			T& operator= (T& ref)
   338 			{
   339 				m_StoredRef = &ref;
   340 				return ref;
   341 			}
   342 
   343 			operator T& () const
   344 			{
   345 				return *m_StoredRef;
   346 			}
   347 		};
   348 	};
   349 
   350 	/**
   351 	*	@brief The main SourceHook interface
   352 	*/
   353 	class ISourceHook
   354 	{
   355 	public:
   356 		/**
   357 		*	@brief Return interface version
   358 		*/
   359 		virtual int GetIfaceVersion() = 0;
   360 
   361 		/**
   362 		*	@brief Return implementation version
   363 		*/
   364 		virtual int GetImplVersion() = 0;
   365 
   366 		/**
   367 		*	@brief Add a hook.
   368 		*
   369 		*	@return True if the function succeeded, false otherwise
   370 		*
   371 		*	@param plug The unique identifier of the plugin that calls this function
   372 		*	@param iface The interface pointer
   373 		*	@param ifacesize The size of the class iface points to
   374 		*	@param myHookMan A hook manager function that should be capable of handling the function
   375 		*	@param handler A pointer to a FastDelegate containing the hook handler
   376 		*	@param post Set to true if you want a post handler
   377 		*/
   378 		virtual bool AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
   379 			ISHDelegate *handler, bool post) = 0;
   380 
   381 		/**
   382 		*	@brief Removes a hook.
   383 		*
   384 		*	@return True if the function succeeded, false otherwise
   385 		*
   386 		*	@param plug The unique identifier of the plugin that calls this function
   387 		*	@param iface The interface pointer
   388 		*	@param myHookMan A hook manager function that should be capable of handling the function
   389 		*	@param handler A pointer to a FastDelegate containing the hook handler
   390 		*	@param post Set to true if you want a post handler
   391 		*/
   392 		virtual bool RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
   393 			ISHDelegate *handler, bool post) = 0;
   394 
   395 		/**
   396 		*	@brief Checks whether a plugin has (a) hook manager(s) that is/are currently used by other plugins
   397 		*
   398 		*	@param plug The unique identifier of the plugin in question
   399 		*/
   400 		virtual bool IsPluginInUse(Plugin plug) = 0;
   401 
   402 		/**
   403 		*	@brief Return a pointer to a callclass. Generate a new one if required.
   404 		*
   405 		*	@param iface The interface pointer
   406 		*	@param size Size of the class instance
   407 		*/
   408 		virtual DeprecatedCallClass<void> *GetCallClass(void *iface, size_t size) = 0;
   409 
   410 		/**
   411 		*	@brief Release a callclass
   412 		*
   413 		*	@param ptr Pointer to the callclass
   414 		*/
   415 		virtual void ReleaseCallClass(DeprecatedCallClass<void> *ptr) = 0;
   416 
   417 		virtual void SetRes(META_RES res) = 0;				//!< Sets the meta result
   418 		virtual META_RES GetPrevRes() = 0;					//!< Gets the meta result of the
   419 															//!<  previously calledhandler
   420 		virtual META_RES GetStatus() = 0;					//!< Gets the highest meta result
   421 		virtual const void *GetOrigRet() = 0;				//!< Gets the original result.
   422 															//!<  If not in post function, undefined
   423 		virtual const void *GetOverrideRet() = 0;			//!< Gets the override result.
   424 															//!<  If none is specified, NULL
   425 		virtual void *GetIfacePtr() = 0;					//!< Gets the interface pointer
   426 		//////////////////////////////////////////////////////////////////////////
   427 		// For hook managers
   428 		virtual void HookLoopBegin(IIface *pIface) = 0;			//!< Should be called when a hook loop begins
   429 		virtual void HookLoopEnd() = 0;							//!< Should be called when a hook loop exits
   430 		virtual void SetCurResPtr(META_RES *mres) = 0;			//!< Sets pointer to the current meta result
   431 		virtual void SetPrevResPtr(META_RES *mres) = 0;			//!< Sets pointer to previous meta result
   432 		virtual void SetStatusPtr(META_RES *mres) = 0;			//!< Sets pointer to the status variable
   433 		virtual void SetIfacePtrPtr(void **pp) = 0;				//!< Sets pointer to the interface this pointer
   434 		virtual void SetOrigRetPtr(const void *ptr) = 0;		//!< Sets the original return pointer
   435 		virtual void SetOverrideRetPtr(void *ptr) = 0;			//!< Sets the override result pointer
   436 		virtual bool ShouldContinue() = 0;						//!< Returns false if the hook loop should exit
   437 
   438 		/**
   439 		*	@brief Remove a hook manager. Auto-removes all hooks attached to it from plugin plug.
   440 		*
   441 		*	@param plug The owner of the hook manager
   442 		*   @param pubFunc The hook manager's info function
   443 		*/
   444 		virtual void RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc) = 0;
   445 
   446 		virtual void DoRecall() = 0;							//!< Initiates a recall sequence
   447 		/*
   448 			HOW RECALLS WORK:
   449 			
   450 			The problem:
   451 				Users want the ability to change parameters of the called function
   452 				from inside their handler.
   453 			The solution:
   454 				1) Mark as "recall"
   455 				2) Recall the function
   456 				3) => SH's hook func gets called:
   457 				  4) The first iterator points at the first hook the last hookfunc didn't execute yet
   458 				  5) does all iteration and returns normally
   459 		        6) The user's handler returns immediately
   460 				7) The hook func returns immediately as well
   461 
   462 				Also note that the recalled hookfunc starts with the status the recalling hookfunc
   463 				ended with. The last handler (doing the recall) is also able to specify its own
   464 				META_RES.
   465 		*/
   466 
   467 		virtual void *GetOverrideRetPtr() = 0;		//!< Returns the pointer set by SetOverrideRetPtr
   468 
   469 		/**
   470 		*	@brief Set up the hook loop. Equivalent to calling:
   471 		*	SetStatusPtr, SetPrevResPtr, SetCurResPtr, SetIfacePtrPtr, SetOrigRetPtr, Get/SetOverrideRetPtr
   472 		*
   473 		*	@param statusPtr		pointer to status variable
   474 		*	@param prevResPtr		pointer to previous result variable
   475 		*	@param curResPtr		pointer to current result variable
   476 		*	@param ifacePtrPtr		pointer to interface this pointer variable
   477 		*	@param origRetPr		pointer to original return value variable. NULL for void funcs
   478 		*	@param overrideRetPtr	pointer to override return value variable. NULL for void funcs
   479 		*	
   480 		*	@return Override Return Pointer the hookfunc should use (may differ from overrideRetPtr
   481 		*		when the hook func is being called as part of a recall
   482 		*/
   483 		virtual void *SetupHookLoop(META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr,
   484 			void **ifacePtrPtr, const void *origRetPtr, void *overrideRetPtr) = 0;
   485 
   486 		/**
   487 		*	@brief Modes for the new AddHook
   488 		*/
   489 		enum AddHookMode
   490 		{
   491 			Hook_Normal,
   492 			Hook_VP,
   493 			Hook_DVP
   494 		}; 
   495 
   496 		/**
   497 		*	@brief Add a (VP) hook.
   498 		*
   499 		*	@return non-zero hook id on success, 0 otherwise
   500 		*
   501 		*	@param plug The unique identifier of the plugin that calls this function
   502 		*	@param mode	Can be either Hook_Normal or Hook_VP (vtable-wide hook)
   503 		*	@param iface The interface pointer
   504 		*	@param ifacesize The size of the class iface points to
   505 		*	@param myHookMan A hook manager function that should be capable of handling the function
   506 		*	@param handler A pointer to a FastDelegate containing the hook handler
   507 		*	@param post Set to true if you want a post handler
   508 		*/
   509 		virtual int AddHookNew(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
   510 			ISHDelegate *handler, bool post) = 0;
   511 
   512 		/**
   513 		*	@brief Remove a VP hook by ID.
   514 		*
   515 		*	@return true on success, false otherwise
   516 		*
   517 		*	@param plug The unique identifier of the plugin that calls this function
   518 		*	@param hookid The hook id (returned by AddHookNew)
   519 		*/
   520 		virtual bool RemoveHookByID(Plugin plug, int hookid) = 0;
   521 
   522 		/**
   523 		*	@brief Makes sure that hooks are going to be ignored on the next call of vfnptr
   524 		*
   525 		*	@param plug The unique identifier of the plugin that calls this function
   526 		*	@param vfnptr The virtual function pointer of the function in question
   527 		*/
   528 		virtual void SetIgnoreHooks(Plugin plug, void *vfnptr) = 0;
   529 
   530 		/**
   531 		*	@brief Reverses SetIgnoreHooks' effect
   532 		*
   533 		*	@param plug The unique identifier of the plugin that calls this function
   534 		*	@param vfnptr The virtual function pointer of the function in question
   535 		*/
   536 		virtual void ResetIgnoreHooks(Plugin plug, void *vfnptr) = 0;
   537 
   538 		/**
   539 		*	@brief Finds the original entry of a virtual function pointer
   540 		*
   541 		*	@param vfnptr The virtual function pointer
   542 		*	@return The original entry if the virtual function pointer has been patched; NULL otherwise.
   543 		*/
   544 		virtual void *GetOrigVfnPtrEntry(void *vfnptr) = 0;
   545 	};
   546 
   547 	// For META_RESULT_ORIG_RET and META_RESULT_OVERRIDE_RET:
   548 	//  These have to be able to return references. If T is a reference, the pointers returned
   549 	//  from the SH_GLOB_SHPTR are pointers to instances of ReferenceCarrier<T>::type.
   550 	template <class T> struct MacroRefHelpers
   551 	{
   552 		inline static const T* GetOrigRet(ISourceHook *shptr)
   553 		{
   554 			return reinterpret_cast<const T*>(shptr->GetOrigRet());
   555 		}
   556 		inline static const T* GetOverrideRet(ISourceHook *shptr)
   557 		{
   558 			return reinterpret_cast<const T*>(shptr->GetOverrideRet());
   559 		}
   560 	};
   561 
   562 	template <class T> struct MacroRefHelpers<T&>
   563 	{
   564 		inline static T* GetOrigRet(ISourceHook *shptr)
   565 		{
   566 			T &ref = *reinterpret_cast<const typename ReferenceCarrier<T&>::type *>(shptr->GetOrigRet());
   567 			return &ref;
   568 		}
   569 		inline static T* GetOverrideRet(ISourceHook *shptr)
   570 		{
   571 			T &ref = *reinterpret_cast<const typename ReferenceCarrier<T&>::type *>(shptr->GetOverrideRet());
   572 			return &ref;
   573 		}
   574 	};
   575 
   576 	// For source-level compatibility
   577 	template <class T> struct CallClass
   578 	{
   579 		T *ptr;
   580 
   581 		CallClass(T *p) : ptr(p)
   582 		{
   583 		}
   584 
   585 		operator T*()
   586 		{
   587 			return ptr;
   588 		}
   589 	};
   590 
   591 	typedef CallClass<void> GenericCallClass;
   592 	typedef CallClass<EmptyClass> ManualCallClass;
   593 
   594 	template <class T>
   595 	CallClass<T> *GetCallClass(T *p)
   596 	{
   597 		return new CallClass<T>(p);
   598 	}
   599 
   600 	template <class T>
   601 	void ReleaseCallClass(CallClass<T> *p)
   602 	{
   603 		delete p;
   604 	}
   605 
   606 	template <class X, class MFP>
   607 	void *GetOrigVfnPtrEntry(X *pInstance, MFP mfp, ISourceHook *pSH)
   608 	{
   609 		SourceHook::MemFuncInfo info = {true, -1, 0, 0};
   610 		SourceHook::GetFuncInfo(pInstance, mfp, info);
   611 
   612 		void *vfnptr = reinterpret_cast<void*>(
   613 			*reinterpret_cast<void***>(reinterpret_cast<char*>(pInstance) + info.thisptroffs + info.vtbloffs) + info.vtblindex);
   614 
   615 		void *origentry = pSH->GetOrigVfnPtrEntry(vfnptr);
   616 		
   617 		return origentry ? origentry : *reinterpret_cast<void**>(vfnptr);
   618 	}
   619 }
   620 
   621 /************************************************************************/
   622 /* High level interface                                                 */
   623 /************************************************************************/
   624 #define META_RESULT_STATUS					SH_GLOB_SHPTR->GetStatus()
   625 #define META_RESULT_PREVIOUS				SH_GLOB_SHPTR->GetPrevRes()
   626 #define META_RESULT_ORIG_RET(type)			*SourceHook::MacroRefHelpers<type>::GetOrigRet(SH_GLOB_SHPTR)
   627 #define META_RESULT_OVERRIDE_RET(type)		*SourceHook::MacroRefHelpers<type>::GetOverrideRet(SH_GLOB_SHPTR)
   628 #define META_IFACEPTR(type)					reinterpret_cast<type*>(SH_GLOB_SHPTR->GetIfacePtr())
   629 
   630 #define SET_META_RESULT(result)				SH_GLOB_SHPTR->SetRes(result)
   631 #define RETURN_META(result)					do { SET_META_RESULT(result); return; } while(0)
   632 #define RETURN_META_VALUE(result, value)	do { SET_META_RESULT(result); return (value); } while(0)
   633 
   634 // If a hook on a function which returns a reference does not want to specify a return value,
   635 // it can use this macro.
   636 //   ONLY USE THIS WITH MRES_IGNORED AND MRES_HANDLED !!!
   637 #define RETURN_META_NOREF(result, rettype)	do { SET_META_RESULT(result); return reinterpret_cast<rettype>(*SH_GLOB_SHPTR); } while(0)
   638 
   639 // only call these from the hook handlers directly!
   640 // :TODO: enforce it ?
   641 
   642 // Why take a memfuncptr instead of iface and func when we have to deduce the iface anyway now?
   643 // Well, without it, there'd be no way to specify which overloaded version we want in _VALUE
   644 
   645 // SourceHook::SetOverrideRet is defined later.
   646 #define RETURN_META_NEWPARAMS(result, memfuncptr, newparams) \
   647 	do { \
   648 		SET_META_RESULT(result); \
   649 		SH_GLOB_SHPTR->DoRecall(); \
   650 		(SourceHook::RecallGetIface(SH_GLOB_SHPTR, memfuncptr)->*(memfuncptr)) newparams; \
   651 		RETURN_META(MRES_SUPERCEDE); \
   652 	} while (0)
   653 
   654 #define RETURN_META_VALUE_NEWPARAMS(result, value, memfuncptr, newparams) \
   655 	do { \
   656 		SET_META_RESULT(result); \
   657 		SH_GLOB_SHPTR->DoRecall(); \
   658 		if ((result) >= MRES_OVERRIDE) \
   659 		{ \
   660 			/* meh, set the override result here because we don't get a chance to return */ \
   661 			/* before continuing the hook loop through the recall */ \
   662 			SourceHook::SetOverrideResult(memfuncptr)(SH_GLOB_SHPTR, value); \
   663 		} \
   664 		RETURN_META_VALUE(MRES_SUPERCEDE, \
   665 			(SourceHook::RecallGetIface(SH_GLOB_SHPTR, memfuncptr)->*(memfuncptr)) newparams); \
   666 	} while (0)
   667 
   668 // :TODO: thisptroffs in MNEWPARAMS ??
   669 
   670 #if SH_COMP == SH_COMP_MSVC
   671 
   672 #define SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname) \
   673 	union \
   674 	{ \
   675 		SH_MFHCls(hookname)::ECMFP mfp; \
   676 		void *addr; \
   677 	} u; \
   678 	SourceHook::EmptyClass *thisptr = reinterpret_cast<SourceHook::EmptyClass*>(SH_GLOB_SHPTR->GetIfacePtr()); \
   679 	u.addr = (*reinterpret_cast<void***>(reinterpret_cast<char*>(thisptr) + SH_MFHCls(hookname)::ms_MFI.vtbloffs))[ \
   680 		SH_MFHCls(hookname)::ms_MFI.vtblindex];
   681 
   682 #elif SH_COMP == SH_COMP_GCC
   683 
   684 #define SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname) \
   685 	union \
   686 	{ \
   687 		SH_MFHCls(hookname)::ECMFP mfp; \
   688 		struct \
   689 		{ \
   690 			void *addr; \
   691 			intptr_t adjustor; \
   692 		} s; \
   693 	} u; \
   694 	SourceHook::EmptyClass *thisptr = reinterpret_cast<SourceHook::EmptyClass*>(SH_GLOB_SHPTR->GetIfacePtr()); \
   695 	u.s.addr = (*reinterpret_cast<void***>(reinterpret_cast<char*>(thisptr) + SH_MFHCls(hookname)::ms_MFI.vtbloffs))[ \
   696 		SH_MFHCls(hookname)::ms_MFI.vtblindex]; \
   697 	u.s.adjustor = 0;
   698 
   699 #endif
   700 
   701 #define RETURN_META_MNEWPARAMS(result, hookname, newparams) \
   702 	do { \
   703 		SET_META_RESULT(result); \
   704 		SH_GLOB_SHPTR->DoRecall(); \
   705 		SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname); \
   706 		(thisptr->*(u.mfp)) newparams; \
   707 		RETURN_META(MRES_SUPERCEDE); \
   708 	} while (0)
   709 
   710 #define RETURN_META_VALUE_MNEWPARAMS(result, value, hookname, newparams) \
   711 	do { \
   712 		SET_META_RESULT(result); \
   713 		SH_GLOB_SHPTR->DoRecall(); \
   714 		if ((result) >= MRES_OVERRIDE) \
   715 		{ \
   716 			/* see RETURN_META_VALUE_NEWPARAMS */ \
   717 			SourceHook::SetOverrideResult<SH_MFHCls(hookname)::RetType>(SH_GLOB_SHPTR, value); \
   718 		} \
   719 		SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname); \
   720 		RETURN_META_VALUE(MRES_SUPERCEDE, (thisptr->*(u.mfp)) newparams); \
   721 	} while (0)
   722 
   723 #define SH_MANUALHOOK_RECONFIGURE(hookname, pvtblindex, pvtbloffs, pthisptroffs) \
   724 	do { \
   725 		SH_GLOB_SHPTR->RemoveHookManager(SH_GLOB_PLUGPTR, SH_MFHCls(hookname)::HookManPubFunc); \
   726 		SH_MFHCls(hookname)::ms_MFI.thisptroffs = pthisptroffs; \
   727 		SH_MFHCls(hookname)::ms_MFI.vtblindex = pvtblindex; \
   728 		SH_MFHCls(hookname)::ms_MFI.vtbloffs = pvtbloffs; \
   729 	} while (0)
   730 
   731 
   732 #define SH_GET_ORIG_VFNPTR_ENTRY(inst, mfp) (SourceHook::GetOrigVfnPtrEntry(inst, mfp, SH_GLOB_SHPTR))
   733 
   734 // For source-level compatibility
   735 
   736 #define SH_GET_CALLCLASS(ptr) SourceHook::GetCallClass(ptr)
   737 #define SH_GET_MCALLCLASS(ptr, size) SourceHook::GetCallClass(reinterpret_cast<SourceHook::EmptyClass*>(ptr))
   738 #define SH_RELEASE_CALLCLASS(ptr) SourceHook::ReleaseCallClass(ptr)
   739 
   740 // New ADD / REMOVE macros.
   741 #define SH_STATIC(func) fastdelegate::MakeDelegate(func)
   742 #define SH_MEMBER(inst, func) fastdelegate::MakeDelegate(inst, func)
   743 
   744 #define SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
   745 	__SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
   746 	post, handler)
   747 
   748 #define SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
   749 	__SourceHook_FHRemove##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
   750 	post, handler) 
   751 
   752 #define SH_ADD_MANUALHOOK(hookname, ifaceptr, handler, post) \
   753 	__SourceHook_FHMAdd##hookname(reinterpret_cast<void*>(ifaceptr), post, handler)
   754 
   755 #define SH_REMOVE_MANUALHOOK(hookname, ifaceptr, handler, post) \
   756 	__SourceHook_FHMRemove##hookname(reinterpret_cast<void*>(ifaceptr), post, handler) 
   757 
   758 #define SH_ADD_VPHOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
   759 	__SourceHook_FHVPAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
   760 	post, handler, false)
   761 
   762 #define SH_ADD_DVPHOOK(ifacetype, ifacefunc, vtableptr, handler, post) \
   763 	__SourceHook_FHVPAdd##ifacetype##ifacefunc(reinterpret_cast<void*>(vtableptr), \
   764 	post, handler, true)
   765 
   766 #define SH_ADD_MANUALVPHOOK(hookname, ifaceptr, handler, post) \
   767 	__SourceHook_FHMVPAdd##hookname(reinterpret_cast<void*>(ifaceptr), post, handler, false)
   768 
   769 #define SH_ADD_MANUALDVPHOOK(hookname, vtableptr, handler, post) \
   770 	__SourceHook_FHMVPAdd##hookname(reinterpret_cast<void*>(vtableptr), post, handler, true)
   771 
   772 #define SH_REMOVE_HOOK_ID(hookid) \
   773 	(SH_GLOB_SHPTR->RemoveHookByID(SH_GLOB_PLUGPTR, hookid))
   774 
   775 // Old macros
   776 // !! These are now deprecated. Instead, use one of these:
   777 //  SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
   778 //  SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post)
   779 
   780 #define SH_ADD_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \
   781 	SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
   782 #define SH_ADD_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \
   783 	SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
   784 
   785 //  SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
   786 //  SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post)
   787 
   788 #define SH_REMOVE_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \
   789 	SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
   790 #define SH_REMOVE_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \
   791 	SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
   792 
   793 //  SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
   794 //  SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post)
   795 
   796 #define SH_ADD_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \
   797 	SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
   798 #define SH_ADD_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \
   799 	SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
   800 
   801 //  SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
   802 //  SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post)
   803 
   804 #define SH_REMOVE_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \
   805 	SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
   806 #define SH_REMOVE_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \
   807 	SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)  
   808 
   809 #define SH_NOATTRIB
   810 
   811 
   812 
   813 
   814 #if SH_COMP == SH_COMP_MSVC
   815 # define SH_SETUP_MFP(mfp) \
   816 	reinterpret_cast<void**>(&mfp)[0] = vfnptr_origentry;
   817 #elif SH_COMP == SH_COMP_GCC
   818 # define SH_SETUP_MFP(mfp) \
   819 	reinterpret_cast<void**>(&mfp)[0] = vfnptr_origentry; \
   820 	reinterpret_cast<void**>(&mfp)[1] = 0;
   821 #else
   822 # error Not supported yet.
   823 #endif
   824 
   825 //////////////////////////////////////////////////////////////////////////
   826 #define SH_FHCls(ift, iff, ov) __SourceHook_FHCls_##ift##iff##ov
   827 #define SH_MFHCls(hookname) __SourceHook_MFHCls_##hookname
   828 
   829 #define SHINT_MAKE_HOOKMANPUBFUNC(ifacetype, ifacefunc, overload, funcptr) \
   830 	SH_FHCls(ifacetype,ifacefunc,overload)() \
   831 	{ \
   832 		GetFuncInfo(funcptr, ms_MFI); \
   833 	} \
   834 	\
   835 	static int HookManPubFunc(::SourceHook::HookManagerAction action, ::SourceHook::IHookManagerInfo *param) \
   836 	{ \
   837 		using namespace ::SourceHook; \
   838 		GetFuncInfo(funcptr, ms_MFI); \
   839 		/* Verify interface version */ \
   840 		if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \
   841 			return 1; \
   842 		if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \
   843 			return 1; \
   844 		\
   845 		if (action == HA_GetInfo) \
   846 		{ \
   847 			param->SetVersion(SH_HOOKMAN_VERSION); \
   848 			param->SetInfo(ms_MFI.vtbloffs, ms_MFI.vtblindex, \
   849 				reinterpret_cast<const char*>(&ms_Proto)); \
   850 			\
   851 			MemFuncInfo mfi = {true, -1, 0, 0}; \
   852 			GetFuncInfo(&SH_FHCls(ifacetype,ifacefunc,overload)::Func, mfi); \
   853 			param->SetHookfuncVfnptr( \
   854 				reinterpret_cast<void**>(reinterpret_cast<char*>(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex]); \
   855 			return 0; \
   856 		} \
   857 		else if (action == HA_Register) \
   858 		{ \
   859 			ms_HI = param; \
   860 			return 0; \
   861 		} \
   862 		else if (action == HA_Unregister) \
   863 		{ \
   864 			ms_HI = NULL; \
   865 			return 0; \
   866 		} \
   867 		else \
   868 			return 1; \
   869 	}
   870 
   871 // It has to be possible to use the macros in namespaces
   872 // -> So we need to access and extend the global SourceHook namespace
   873 // We use a namespace alias for this
   874 #define SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, funcptr) \
   875 	struct SH_FHCls(ifacetype,ifacefunc,overload) \
   876 	{ \
   877 		static SH_FHCls(ifacetype,ifacefunc,overload) ms_Inst; \
   878 		static ::SourceHook::MemFuncInfo ms_MFI; \
   879 		static ::SourceHook::IHookManagerInfo *ms_HI; \
   880 		static ::SourceHook::ProtoInfo ms_Proto; \
   881 		SHINT_MAKE_HOOKMANPUBFUNC(ifacetype, ifacefunc, overload, funcptr)
   882 
   883 #define SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, funcptr) \
   884 	}; \
   885 	SH_FHCls(ifacetype,ifacefunc,overload) SH_FHCls(ifacetype,ifacefunc,overload)::ms_Inst; \
   886 	::SourceHook::MemFuncInfo SH_FHCls(ifacetype,ifacefunc,overload)::ms_MFI; \
   887 	::SourceHook::IHookManagerInfo *SH_FHCls(ifacetype,ifacefunc,overload)::ms_HI; \
   888 	int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, bool post, \
   889 		SH_FHCls(ifacetype,ifacefunc,overload)::FD handler) \
   890 	{ \
   891 		using namespace ::SourceHook; \
   892 		MemFuncInfo mfi = {true, -1, 0, 0}; \
   893 		GetFuncInfo(funcptr, mfi); \
   894 		if (mfi.thisptroffs < 0 || !mfi.isVirtual) \
   895 			return false; /* No non-virtual functions / virtual inheritance supported */ \
   896 		\
   897 		return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, ::SourceHook::ISourceHook::Hook_Normal, iface, mfi.thisptroffs, \
   898 			SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, \
   899 			new CSHDelegate<SH_FHCls(ifacetype,ifacefunc,overload)::FD>(handler), post); \
   900 	} \
   901 	int __SourceHook_FHVPAdd##ifacetype##ifacefunc(void *iface, bool post, \
   902 		SH_FHCls(ifacetype,ifacefunc,overload)::FD handler, bool direct) \
   903 	{ \
   904 		using namespace ::SourceHook; \
   905 		MemFuncInfo mfi = {true, -1, 0, 0}; \
   906 		GetFuncInfo(funcptr, mfi); \
   907 		if (mfi.thisptroffs < 0 || !mfi.isVirtual) \
   908 			return false; /* No non-virtual functions / virtual inheritance supported */ \
   909 		\
   910 		return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, \
   911 			direct ? ::SourceHook::ISourceHook::Hook_DVP : ::SourceHook::ISourceHook::Hook_VP, \
   912 			iface, mfi.thisptroffs, SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, \
   913 			new CSHDelegate<SH_FHCls(ifacetype,ifacefunc,overload)::FD>(handler), post); \
   914 	} \
   915 	bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \
   916 		SH_FHCls(ifacetype,ifacefunc,overload)::FD handler) \
   917 	{ \
   918 		using namespace ::SourceHook; \
   919 		MemFuncInfo mfi = {true, -1, 0, 0}; \
   920 		GetFuncInfo(funcptr, mfi); \
   921 		if (mfi.thisptroffs < 0) \
   922 			return false; /* No virtual inheritance supported */ \
   923 		\
   924 		CSHDelegate<SH_FHCls(ifacetype,ifacefunc,overload)::FD> tmp(handler); \
   925 		return SH_GLOB_SHPTR->RemoveHook(SH_GLOB_PLUGPTR, iface, mfi.thisptroffs, \
   926 			SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, &tmp, post); \
   927 	} \
   928 
   929 #define SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, pvtbloffs, pvtblidx, pthisptroffs) \
   930 	struct SH_MFHCls(hookname) \
   931 	{ \
   932 		static SH_MFHCls(hookname) ms_Inst; \
   933 		static ::SourceHook::MemFuncInfo ms_MFI; \
   934 		static ::SourceHook::IHookManagerInfo *ms_HI; \
   935 		static ::SourceHook::ProtoInfo ms_Proto; \
   936 		\
   937 		SH_MFHCls(hookname)() \
   938 		{ \
   939 			ms_MFI.isVirtual = true; \
   940 			ms_MFI.thisptroffs = pthisptroffs; \
   941 			ms_MFI.vtblindex = pvtblidx; \
   942 			ms_MFI.vtbloffs = pvtbloffs; \
   943 		} \
   944 		static int HookManPubFunc(::SourceHook::HookManagerAction action, ::SourceHook::IHookManagerInfo *param) \
   945 		{ \
   946 			using namespace ::SourceHook; \
   947 			/* we don't set ms_MFI here because manual hookmans can be reconfigured */ \
   948 			/* :FIXME: possible problem: someone adding a hook from a constructor of a global entity */ \
   949 			/* which is construced before SH_MFHCls(hookname)() gets called? */ \
   950 			/* Verify interface version */ \
   951 			if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \
   952 				return 1; \
   953 			if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \
   954 				return 1; \
   955 			\
   956 			if (action == HA_GetInfo) \
   957 			{ \
   958 				param->SetVersion(SH_HOOKMAN_VERSION); \
   959 				param->SetInfo(ms_MFI.vtbloffs, ms_MFI.vtblindex, \
   960 					reinterpret_cast<const char*>(&ms_Proto)); \
   961 				\
   962 				MemFuncInfo mfi = {true, -1, 0, 0}; \
   963 				GetFuncInfo(&SH_MFHCls(hookname)::Func, mfi); \
   964 				param->SetHookfuncVfnptr( \
   965 					reinterpret_cast<void**>(reinterpret_cast<char*>(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex]); \
   966 				return 0; \
   967 			} \
   968 			else if (action == HA_Register) \
   969 			{ \
   970 				ms_HI = param; \
   971 				return 0; \
   972 			} \
   973 			else if (action == HA_Unregister) \
   974 			{ \
   975 				ms_HI = NULL; \
   976 				return 0; \
   977 			} \
   978 			else \
   979 				return 1; \
   980 		}
   981 
   982 #define SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, pvtbloffs, pvtblidx, pthisptroffs) \
   983 	}; \
   984 	SH_MFHCls(hookname) SH_MFHCls(hookname)::ms_Inst; \
   985 	::SourceHook::MemFuncInfo SH_MFHCls(hookname)::ms_MFI; \
   986 	::SourceHook::IHookManagerInfo *SH_MFHCls(hookname)::ms_HI; \
   987 	int __SourceHook_FHMAdd##hookname(void *iface, bool post, \
   988 		SH_MFHCls(hookname)::FD handler) \
   989 	{ \
   990 		return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, ::SourceHook::ISourceHook::Hook_Normal, iface, pthisptroffs, \
   991 			SH_MFHCls(hookname)::HookManPubFunc, \
   992 			new ::SourceHook::CSHDelegate<SH_MFHCls(hookname)::FD>(handler), post); \
   993 	} \
   994 	int __SourceHook_FHMVPAdd##hookname(void *iface, bool post, \
   995 		SH_MFHCls(hookname)::FD handler, bool direct) \
   996 	{ \
   997 		return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, \
   998 			direct ? ::SourceHook::ISourceHook::Hook_DVP : ::SourceHook::ISourceHook::Hook_VP, \
   999 			iface, pthisptroffs, SH_MFHCls(hookname)::HookManPubFunc, \
  1000 			new ::SourceHook::CSHDelegate<SH_MFHCls(hookname)::FD>(handler), post); \
  1001 	} \
  1002 	bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \
  1003 		SH_MFHCls(hookname)::FD handler) \
  1004 	{ \
  1005 		::SourceHook::CSHDelegate<SH_MFHCls(hookname)::FD> tmp(handler); \
  1006 		return SH_GLOB_SHPTR->RemoveHook(SH_GLOB_PLUGPTR, iface, pthisptroffs, \
  1007 			SH_MFHCls(hookname)::HookManPubFunc, &tmp, post); \
  1008 	} \
  1009 
  1010 
  1011 #define SH_SETUPCALLS(rettype, paramtypes, params) \
  1012 	/* 1) Find the vfnptr */ \
  1013 	using namespace ::SourceHook; \
  1014 	void *ourvfnptr = reinterpret_cast<void*>( \
  1015 		*reinterpret_cast<void***>(reinterpret_cast<char*>(this) + ms_MFI.vtbloffs) + ms_MFI.vtblindex); \
  1016 	IVfnPtr *vfnptr = ms_HI->FindVfnPtr(ourvfnptr); \
  1017 	SH_ASSERT(vfnptr, ("Called with vfnptr 0x%p which couldn't be found in the list", ourvfnptr)); \
  1018 	\
  1019 	void *vfnptr_origentry = vfnptr->GetOrigEntry(); \
  1020 	/* ... and the iface */ \
  1021 	IIface *ifinfo = vfnptr->FindIface(reinterpret_cast<void*>(this)); \
  1022 	if (!ifinfo) \
  1023 	{ \
  1024 		/* The iface info was not found. Redirect the call to the original function. */ \
  1025 		rettype (EmptyClass::*mfp)paramtypes; \
  1026 		SH_SETUP_MFP(mfp); \
  1027 		return (reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
  1028 	} \
  1029 	/* 2) Declare some vars and set it up */ \
  1030 	SH_GLOB_SHPTR->HookLoopBegin(ifinfo); \
  1031 	IHookList *prelist = ifinfo->GetPreHooks(); \
  1032 	IHookList *postlist = ifinfo->GetPostHooks(); \
  1033 	META_RES status = MRES_IGNORED; \
  1034 	META_RES prev_res; \
  1035 	META_RES cur_res; \
  1036 	typedef ReferenceCarrier<rettype>::type my_rettype; \
  1037 	my_rettype orig_ret; \
  1038 	my_rettype override_ret; \
  1039 	my_rettype plugin_ret; \
  1040 	void* ifptr; \
  1041 	my_rettype *pOverrideRet = reinterpret_cast<my_rettype*>(SH_GLOB_SHPTR->SetupHookLoop( \
  1042 		&status, &prev_res, &cur_res, &ifptr, &orig_ret, &override_ret));
  1043 
  1044 #define SH_CALL_HOOKS(post, params) \
  1045 	if (SH_GLOB_SHPTR->ShouldContinue()) \
  1046 	{ \
  1047 		prev_res = MRES_IGNORED; \
  1048 		for (AutoHookIter iter(post##list); !iter.End(); iter.Next()) \
  1049 		{ \
  1050 			cur_res = MRES_IGNORED; \
  1051 			ifptr = reinterpret_cast<void*>(reinterpret_cast<char*>(this) - iter.ThisPtrOffs()); \
  1052 			plugin_ret = reinterpret_cast<CSHDelegate<FD>*>(iter.Handler())->GetDeleg() params; \
  1053 			prev_res = cur_res; \
  1054 			if (cur_res > status) \
  1055 				status = cur_res; \
  1056 			if (cur_res >= MRES_OVERRIDE) \
  1057 				*pOverrideRet = plugin_ret; \
  1058 			if (!SH_GLOB_SHPTR->ShouldContinue()) \
  1059 			{ \
  1060 				iter.SetToZero(); \
  1061 				break; \
  1062 			} \
  1063 		} \
  1064 	}
  1065 
  1066 #define SH_CALL_ORIG(rettype, paramtypes, params) \
  1067 	if (status != MRES_SUPERCEDE) \
  1068 	{ \
  1069 		rettype (EmptyClass::*mfp)paramtypes; \
  1070 		SH_SETUP_MFP(mfp); \
  1071 		orig_ret = (reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
  1072 	} \
  1073 	else \
  1074 		orig_ret = override_ret; \
  1075 
  1076 #define SH_RETURN() \
  1077 	SH_GLOB_SHPTR->HookLoopEnd(); \
  1078 	return status >= MRES_OVERRIDE ? *pOverrideRet : orig_ret;
  1079 
  1080 #define SH_HANDLEFUNC(paramtypes, params, rettype) \
  1081 	SH_SETUPCALLS(rettype, paramtypes, params) \
  1082 	SH_CALL_HOOKS(pre, params) \
  1083 	SH_CALL_ORIG(rettype, paramtypes, params) \
  1084 	SH_CALL_HOOKS(post, params) \
  1085 	SH_RETURN()
  1086 
  1087 //////////////////////////////////////////////////////////////////////////
  1088 #define SH_SETUPCALLS_void(paramtypes, params) \
  1089 	/* 1) Find the vfnptr */ \
  1090 	using namespace ::SourceHook; \
  1091 	void *ourvfnptr = reinterpret_cast<void*>( \
  1092 		*reinterpret_cast<void***>(reinterpret_cast<char*>(this) + ms_MFI.vtbloffs) + ms_MFI.vtblindex); \
  1093 	IVfnPtr *vfnptr = ms_HI->FindVfnPtr(ourvfnptr); \
  1094 	SH_ASSERT(vfnptr, ("Called with vfnptr 0x%p which couldn't be found in the list", ourvfnptr)); \
  1095 	\
  1096 	void *vfnptr_origentry = vfnptr->GetOrigEntry(); \
  1097 	/* ... and the iface */ \
  1098 	IIface *ifinfo = vfnptr->FindIface(reinterpret_cast<void*>(this)); \
  1099 	if (!ifinfo) \
  1100 	{ \
  1101 		/* The iface info was not found. Redirect the call to the original function. */ \
  1102 		void (EmptyClass::*mfp)paramtypes; \
  1103 		SH_SETUP_MFP(mfp); \
  1104 		(reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
  1105 		return; \
  1106 	} \
  1107 	/* 2) Declare some vars and set it up */ \
  1108 	SH_GLOB_SHPTR->HookLoopBegin(ifinfo); \
  1109 	IHookList *prelist = ifinfo->GetPreHooks(); \
  1110 	IHookList *postlist = ifinfo->GetPostHooks(); \
  1111 	META_RES status = MRES_IGNORED; \
  1112 	META_RES prev_res; \
  1113 	META_RES cur_res; \
  1114 	void* ifptr; \
  1115 	SH_GLOB_SHPTR->SetupHookLoop(&status, &prev_res, &cur_res, &ifptr, NULL, NULL); \
  1116 
  1117 #define SH_CALL_HOOKS_void(post, params) \
  1118 	if (SH_GLOB_SHPTR->ShouldContinue()) \
  1119 	{ \
  1120 		prev_res = MRES_IGNORED; \
  1121 		for (AutoHookIter iter(post##list); !iter.End(); iter.Next()) \
  1122 		{ \
  1123 			cur_res = MRES_IGNORED; \
  1124 			ifptr = reinterpret_cast<void*>(reinterpret_cast<char*>(this) - iter.ThisPtrOffs()); \
  1125 			reinterpret_cast<CSHDelegate<FD>*>(iter.Handler())->GetDeleg() params; \
  1126 			prev_res = cur_res; \
  1127 			if (cur_res > status) \
  1128 				status = cur_res; \
  1129 			if (!SH_GLOB_SHPTR->ShouldContinue()) \
  1130 			{ \
  1131 				iter.SetToZero(); \
  1132 				break; \
  1133 			} \
  1134 		} \
  1135 	}
  1136 
  1137 #define SH_CALL_ORIG_void(paramtypes, params) \
  1138 	if (status != MRES_SUPERCEDE) \
  1139 	{ \
  1140 		void (EmptyClass::*mfp)paramtypes; \
  1141 		SH_SETUP_MFP(mfp); \
  1142 		(reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
  1143 	}
  1144 
  1145 #define SH_RETURN_void() \
  1146 	SH_GLOB_SHPTR->HookLoopEnd();
  1147 
  1148 #define SH_HANDLEFUNC_void(paramtypes, params) \
  1149 	SH_SETUPCALLS_void(paramtypes, params) \
  1150 	SH_CALL_HOOKS_void(pre, params) \
  1151 	SH_CALL_ORIG_void(paramtypes, params) \
  1152 	SH_CALL_HOOKS_void(post, params) \
  1153 	SH_RETURN_void()
  1154 
  1155 
  1156 // Special vafmt handlers
  1157 // :TODO: what
  1158 #define SH_HANDLEFUNC_vafmt(paramtypes, params_orig, params_plug, rettype) \
  1159 	SH_SETUPCALLS(rettype, paramtypes, params_orig) \
  1160 	SH_CALL_HOOKS(pre, params_plug) \
  1161 	SH_CALL_ORIG(rettype, paramtypes, params_orig) \
  1162 	SH_CALL_HOOKS(post, params_plug) \
  1163 	SH_RETURN()
  1164 
  1165 #define SH_HANDLEFUNC_void_vafmt(paramtypes, params_orig, params_plug) \
  1166 	SH_SETUPCALLS_void(paramtypes, params_orig) \
  1167 	SH_CALL_HOOKS_void(pre, params_plug) \
  1168 	SH_CALL_ORIG_void(paramtypes, params_orig) \
  1169 	SH_CALL_HOOKS_void(post, params_plug) \
  1170 	SH_RETURN_void()
  1171 
  1172 //////////////////////////////////////////////////////////////////////////
  1173 
  1174 // :FIXME:
  1175 //  sizeof on references returns the size of the datatype, NOT the pointer size or something
  1176 //  -> one should probably flag references in __SourceHook_ParamSizes_* !
  1177 //		or simply assume that their size is sizeof(void*)=SH_PTRSIZE... could be doable through a simple template
  1178 
  1179 
  1180 // ********* Support for 0 arguments *********
  1181 #define SH_DECL_HOOK0(ifacetype, ifacefunc, attr, overload, rettype) \
  1182 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)() attr> \
  1183 		(&ifacetype::ifacefunc))) \
  1184 		typedef fastdelegate::FastDelegate0<rettype> FD; \
  1185 		virtual rettype Func() \
  1186 		{ SH_HANDLEFUNC((), (), rettype); } \
  1187 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1188 		(static_cast<rettype (ifacetype::*)() attr>(&ifacetype::ifacefunc))) \
  1189 	\
  1190 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0 }; \
  1191 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1192 		0, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1193 
  1194 #define SH_DECL_HOOK0_void(ifacetype, ifacefunc, attr, overload) \
  1195 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)() attr> \
  1196 		(&ifacetype::ifacefunc))) \
  1197 		typedef fastdelegate::FastDelegate0<> FD; \
  1198 		virtual void Func() \
  1199 		{ SH_HANDLEFUNC_void((), ()); } \
  1200 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1201 		(static_cast<void (ifacetype::*)() attr>(&ifacetype::ifacefunc))) \
  1202 	\
  1203 	\
  1204 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0 }; \
  1205 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1206 		0, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1207 
  1208 #define SH_DECL_HOOK0_vafmt(ifacetype, ifacefunc, attr, overload, rettype) \
  1209 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(const char *, ...) attr> \
  1210 		(&ifacetype::ifacefunc))) \
  1211 		typedef fastdelegate::FastDelegate1<const char *, rettype> FD; \
  1212 		virtual rettype Func(const char *fmt, ...) \
  1213 		{ \
  1214 			char buf[::SourceHook::STRBUF_LEN]; \
  1215 			va_list ap; \
  1216 			va_start(ap, fmt); \
  1217 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1218 			va_end(ap); \
  1219 			SH_HANDLEFUNC_vafmt((...), ("%s", buf), (buf), rettype); \
  1220 		} \
  1221 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1222 		(static_cast<rettype (ifacetype::*)(const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1223 	\
  1224 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1 }; \
  1225 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1226 		0, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1227 
  1228 #define SH_DECL_HOOK0_void_vafmt(ifacetype, ifacefunc, attr, overload) \
  1229 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(const char *, ...) attr> \
  1230 		(&ifacetype::ifacefunc))) \
  1231 		typedef fastdelegate::FastDelegate1<const char *> FD; \
  1232 		virtual void Func(const char *fmt, ...) \
  1233 		{ \
  1234 			char buf[::SourceHook::STRBUF_LEN]; \
  1235 			va_list ap; \
  1236 			va_start(ap, fmt); \
  1237 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1238 			va_end(ap); \
  1239 			SH_HANDLEFUNC_void_vafmt((...), ("%s", buf), (buf)); \
  1240 		} \
  1241 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1242 		(static_cast<void (ifacetype::*)(const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1243 	\
  1244 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1 }; \
  1245 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1246 		0, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1247 
  1248 #define SH_DECL_MANUALHOOK0(hookname, vtblidx, vtbloffs, thisptroffs, rettype) \
  1249 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1250 		typedef fastdelegate::FastDelegate0<rettype> FD; \
  1251 		virtual rettype Func() \
  1252 		{ SH_HANDLEFUNC((), (), rettype); } \
  1253 		typedef rettype(::SourceHook::EmptyClass::*ECMFP)(); \
  1254 		typedef rettype RetType; \
  1255 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1256 	\
  1257 	const int __SourceHook_ParamSizesM_##hookname[] = { 0 }; \
  1258 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(sizeof(rettype), \
  1259 		0, __SourceHook_ParamSizesM_##hookname); \
  1260 
  1261 #define SH_DECL_MANUALHOOK0_void(hookname, vtblidx, vtbloffs, thisptroffs) \
  1262 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1263 		typedef fastdelegate::FastDelegate0<> FD; \
  1264 		virtual void Func() \
  1265 		{ SH_HANDLEFUNC_void((), ()); } \
  1266 		typedef void(::SourceHook::EmptyClass::*ECMFP)(); \
  1267 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1268 	\
  1269 	const int __SourceHook_ParamSizesM_##hookname[] = { 0 }; \
  1270 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(0, \
  1271 		0, __SourceHook_ParamSizesM_##hookname); \
  1272 
  1273 
  1274 // ********* Support for 1 arguments *********
  1275 #define SH_DECL_HOOK1(ifacetype, ifacefunc, attr, overload, rettype, param1) \
  1276 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1) attr> \
  1277 		(&ifacetype::ifacefunc))) \
  1278 		typedef fastdelegate::FastDelegate1<param1, rettype> FD; \
  1279 		virtual rettype Func(param1 p1) \
  1280 		{ SH_HANDLEFUNC((param1), (p1), rettype); } \
  1281 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1282 		(static_cast<rettype (ifacetype::*)(param1) attr>(&ifacetype::ifacefunc))) \
  1283 	\
  1284 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1) }; \
  1285 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1286 		1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1287 
  1288 #define SH_DECL_HOOK1_void(ifacetype, ifacefunc, attr, overload, param1) \
  1289 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1) attr> \
  1290 		(&ifacetype::ifacefunc))) \
  1291 		typedef fastdelegate::FastDelegate1<param1> FD; \
  1292 		virtual void Func(param1 p1) \
  1293 		{ SH_HANDLEFUNC_void((param1), (p1)); } \
  1294 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1295 		(static_cast<void (ifacetype::*)(param1) attr>(&ifacetype::ifacefunc))) \
  1296 	\
  1297 	\
  1298 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1) }; \
  1299 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1300 		1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1301 
  1302 #define SH_DECL_HOOK1_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1) \
  1303 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, const char *, ...) attr> \
  1304 		(&ifacetype::ifacefunc))) \
  1305 		typedef fastdelegate::FastDelegate2<param1, const char *, rettype> FD; \
  1306 		virtual rettype Func(param1 p1, const char *fmt, ...) \
  1307 		{ \
  1308 			char buf[::SourceHook::STRBUF_LEN]; \
  1309 			va_list ap; \
  1310 			va_start(ap, fmt); \
  1311 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1312 			va_end(ap); \
  1313 			SH_HANDLEFUNC_vafmt((param1, ...), (p1, "%s", buf), (p1, buf), rettype); \
  1314 		} \
  1315 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1316 		(static_cast<rettype (ifacetype::*)(param1, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1317 	\
  1318 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1) }; \
  1319 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1320 		1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1321 
  1322 #define SH_DECL_HOOK1_void_vafmt(ifacetype, ifacefunc, attr, overload, param1) \
  1323 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, const char *, ...) attr> \
  1324 		(&ifacetype::ifacefunc))) \
  1325 		typedef fastdelegate::FastDelegate2<param1, const char *> FD; \
  1326 		virtual void Func(param1 p1, const char *fmt, ...) \
  1327 		{ \
  1328 			char buf[::SourceHook::STRBUF_LEN]; \
  1329 			va_list ap; \
  1330 			va_start(ap, fmt); \
  1331 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1332 			va_end(ap); \
  1333 			SH_HANDLEFUNC_void_vafmt((param1, ...), (p1, "%s", buf), (p1, buf)); \
  1334 		} \
  1335 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1336 		(static_cast<void (ifacetype::*)(param1, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1337 	\
  1338 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1) }; \
  1339 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1340 		1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1341 
  1342 #define SH_DECL_MANUALHOOK1(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1) \
  1343 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1344 		typedef fastdelegate::FastDelegate1<param1, rettype> FD; \
  1345 		virtual rettype Func(param1 p1) \
  1346 		{ SH_HANDLEFUNC((param1), (p1), rettype); } \
  1347 		typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1); \
  1348 		typedef rettype RetType; \
  1349 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1350 	\
  1351 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1) }; \
  1352 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(sizeof(rettype), \
  1353 		1, __SourceHook_ParamSizesM_##hookname); \
  1354 
  1355 #define SH_DECL_MANUALHOOK1_void(hookname, vtblidx, vtbloffs, thisptroffs, param1) \
  1356 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1357 		typedef fastdelegate::FastDelegate1<param1> FD; \
  1358 		virtual void Func(param1 p1) \
  1359 		{ SH_HANDLEFUNC_void((param1), (p1)); } \
  1360 		typedef void(::SourceHook::EmptyClass::*ECMFP)(param1); \
  1361 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1362 	\
  1363 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1) }; \
  1364 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(0, \
  1365 		1, __SourceHook_ParamSizesM_##hookname); \
  1366 
  1367 
  1368 // ********* Support for 2 arguments *********
  1369 #define SH_DECL_HOOK2(ifacetype, ifacefunc, attr, overload, rettype, param1, param2) \
  1370 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2) attr> \
  1371 		(&ifacetype::ifacefunc))) \
  1372 		typedef fastdelegate::FastDelegate2<param1, param2, rettype> FD; \
  1373 		virtual rettype Func(param1 p1, param2 p2) \
  1374 		{ SH_HANDLEFUNC((param1, param2), (p1, p2), rettype); } \
  1375 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1376 		(static_cast<rettype (ifacetype::*)(param1, param2) attr>(&ifacetype::ifacefunc))) \
  1377 	\
  1378 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2) }; \
  1379 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1380 		2, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1381 
  1382 #define SH_DECL_HOOK2_void(ifacetype, ifacefunc, attr, overload, param1, param2) \
  1383 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2) attr> \
  1384 		(&ifacetype::ifacefunc))) \
  1385 		typedef fastdelegate::FastDelegate2<param1, param2> FD; \
  1386 		virtual void Func(param1 p1, param2 p2) \
  1387 		{ SH_HANDLEFUNC_void((param1, param2), (p1, p2)); } \
  1388 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1389 		(static_cast<void (ifacetype::*)(param1, param2) attr>(&ifacetype::ifacefunc))) \
  1390 	\
  1391 	\
  1392 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2) }; \
  1393 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1394 		2, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1395 
  1396 #define SH_DECL_HOOK2_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2) \
  1397 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, const char *, ...) attr> \
  1398 		(&ifacetype::ifacefunc))) \
  1399 		typedef fastdelegate::FastDelegate3<param1, param2, const char *, rettype> FD; \
  1400 		virtual rettype Func(param1 p1, param2 p2, const char *fmt, ...) \
  1401 		{ \
  1402 			char buf[::SourceHook::STRBUF_LEN]; \
  1403 			va_list ap; \
  1404 			va_start(ap, fmt); \
  1405 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1406 			va_end(ap); \
  1407 			SH_HANDLEFUNC_vafmt((param1, param2, ...), (p1, p2, "%s", buf), (p1, p2, buf), rettype); \
  1408 		} \
  1409 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1410 		(static_cast<rettype (ifacetype::*)(param1, param2, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1411 	\
  1412 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2) }; \
  1413 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1414 		2, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1415 
  1416 #define SH_DECL_HOOK2_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2) \
  1417 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, const char *, ...) attr> \
  1418 		(&ifacetype::ifacefunc))) \
  1419 		typedef fastdelegate::FastDelegate3<param1, param2, const char *> FD; \
  1420 		virtual void Func(param1 p1, param2 p2, const char *fmt, ...) \
  1421 		{ \
  1422 			char buf[::SourceHook::STRBUF_LEN]; \
  1423 			va_list ap; \
  1424 			va_start(ap, fmt); \
  1425 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1426 			va_end(ap); \
  1427 			SH_HANDLEFUNC_void_vafmt((param1, param2, ...), (p1, p2, "%s", buf), (p1, p2, buf)); \
  1428 		} \
  1429 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1430 		(static_cast<void (ifacetype::*)(param1, param2, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1431 	\
  1432 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2) }; \
  1433 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1434 		2, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1435 
  1436 #define SH_DECL_MANUALHOOK2(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2) \
  1437 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1438 		typedef fastdelegate::FastDelegate2<param1, param2, rettype> FD; \
  1439 		virtual rettype Func(param1 p1, param2 p2) \
  1440 		{ SH_HANDLEFUNC((param1, param2), (p1, p2), rettype); } \
  1441 		typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2); \
  1442 		typedef rettype RetType; \
  1443 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1444 	\
  1445 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2) }; \
  1446 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(sizeof(rettype), \
  1447 		2, __SourceHook_ParamSizesM_##hookname); \
  1448 
  1449 #define SH_DECL_MANUALHOOK2_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2) \
  1450 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1451 		typedef fastdelegate::FastDelegate2<param1, param2> FD; \
  1452 		virtual void Func(param1 p1, param2 p2) \
  1453 		{ SH_HANDLEFUNC_void((param1, param2), (p1, p2)); } \
  1454 		typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2); \
  1455 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1456 	\
  1457 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2) }; \
  1458 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(0, \
  1459 		2, __SourceHook_ParamSizesM_##hookname); \
  1460 
  1461 
  1462 // ********* Support for 3 arguments *********
  1463 #define SH_DECL_HOOK3(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3) \
  1464 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3) attr> \
  1465 		(&ifacetype::ifacefunc))) \
  1466 		typedef fastdelegate::FastDelegate3<param1, param2, param3, rettype> FD; \
  1467 		virtual rettype Func(param1 p1, param2 p2, param3 p3) \
  1468 		{ SH_HANDLEFUNC((param1, param2, param3), (p1, p2, p3), rettype); } \
  1469 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1470 		(static_cast<rettype (ifacetype::*)(param1, param2, param3) attr>(&ifacetype::ifacefunc))) \
  1471 	\
  1472 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3) }; \
  1473 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1474 		3, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1475 
  1476 #define SH_DECL_HOOK3_void(ifacetype, ifacefunc, attr, overload, param1, param2, param3) \
  1477 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3) attr> \
  1478 		(&ifacetype::ifacefunc))) \
  1479 		typedef fastdelegate::FastDelegate3<param1, param2, param3> FD; \
  1480 		virtual void Func(param1 p1, param2 p2, param3 p3) \
  1481 		{ SH_HANDLEFUNC_void((param1, param2, param3), (p1, p2, p3)); } \
  1482 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1483 		(static_cast<void (ifacetype::*)(param1, param2, param3) attr>(&ifacetype::ifacefunc))) \
  1484 	\
  1485 	\
  1486 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3) }; \
  1487 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1488 		3, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1489 
  1490 #define SH_DECL_HOOK3_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3) \
  1491 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, const char *, ...) attr> \
  1492 		(&ifacetype::ifacefunc))) \
  1493 		typedef fastdelegate::FastDelegate4<param1, param2, param3, const char *, rettype> FD; \
  1494 		virtual rettype Func(param1 p1, param2 p2, param3 p3, const char *fmt, ...) \
  1495 		{ \
  1496 			char buf[::SourceHook::STRBUF_LEN]; \
  1497 			va_list ap; \
  1498 			va_start(ap, fmt); \
  1499 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1500 			va_end(ap); \
  1501 			SH_HANDLEFUNC_vafmt((param1, param2, param3, ...), (p1, p2, p3, "%s", buf), (p1, p2, p3, buf), rettype); \
  1502 		} \
  1503 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1504 		(static_cast<rettype (ifacetype::*)(param1, param2, param3, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1505 	\
  1506 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2), sizeof(param3) }; \
  1507 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1508 		3, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1509 
  1510 #define SH_DECL_HOOK3_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2, param3) \
  1511 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, const char *, ...) attr> \
  1512 		(&ifacetype::ifacefunc))) \
  1513 		typedef fastdelegate::FastDelegate4<param1, param2, param3, const char *> FD; \
  1514 		virtual void Func(param1 p1, param2 p2, param3 p3, const char *fmt, ...) \
  1515 		{ \
  1516 			char buf[::SourceHook::STRBUF_LEN]; \
  1517 			va_list ap; \
  1518 			va_start(ap, fmt); \
  1519 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1520 			va_end(ap); \
  1521 			SH_HANDLEFUNC_void_vafmt((param1, param2, param3, ...), (p1, p2, p3, "%s", buf), (p1, p2, p3, buf)); \
  1522 		} \
  1523 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1524 		(static_cast<void (ifacetype::*)(param1, param2, param3, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1525 	\
  1526 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2), sizeof(param3) }; \
  1527 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1528 		3, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1529 
  1530 #define SH_DECL_MANUALHOOK3(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2, param3) \
  1531 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1532 		typedef fastdelegate::FastDelegate3<param1, param2, param3, rettype> FD; \
  1533 		virtual rettype Func(param1 p1, param2 p2, param3 p3) \
  1534 		{ SH_HANDLEFUNC((param1, param2, param3), (p1, p2, p3), rettype); } \
  1535 		typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3); \
  1536 		typedef rettype RetType; \
  1537 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1538 	\
  1539 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3) }; \
  1540 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(sizeof(rettype), \
  1541 		3, __SourceHook_ParamSizesM_##hookname); \
  1542 
  1543 #define SH_DECL_MANUALHOOK3_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2, param3) \
  1544 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1545 		typedef fastdelegate::FastDelegate3<param1, param2, param3> FD; \
  1546 		virtual void Func(param1 p1, param2 p2, param3 p3) \
  1547 		{ SH_HANDLEFUNC_void((param1, param2, param3), (p1, p2, p3)); } \
  1548 		typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3); \
  1549 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1550 	\
  1551 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3) }; \
  1552 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(0, \
  1553 		3, __SourceHook_ParamSizesM_##hookname); \
  1554 
  1555 
  1556 // ********* Support for 4 arguments *********
  1557 #define SH_DECL_HOOK4(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4) \
  1558 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4) attr> \
  1559 		(&ifacetype::ifacefunc))) \
  1560 		typedef fastdelegate::FastDelegate4<param1, param2, param3, param4, rettype> FD; \
  1561 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4) \
  1562 		{ SH_HANDLEFUNC((param1, param2, param3, param4), (p1, p2, p3, p4), rettype); } \
  1563 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1564 		(static_cast<rettype (ifacetype::*)(param1, param2, param3, param4) attr>(&ifacetype::ifacefunc))) \
  1565 	\
  1566 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4) }; \
  1567 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1568 		4, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1569 
  1570 #define SH_DECL_HOOK4_void(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4) \
  1571 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4) attr> \
  1572 		(&ifacetype::ifacefunc))) \
  1573 		typedef fastdelegate::FastDelegate4<param1, param2, param3, param4> FD; \
  1574 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4) \
  1575 		{ SH_HANDLEFUNC_void((param1, param2, param3, param4), (p1, p2, p3, p4)); } \
  1576 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1577 		(static_cast<void (ifacetype::*)(param1, param2, param3, param4) attr>(&ifacetype::ifacefunc))) \
  1578 	\
  1579 	\
  1580 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4) }; \
  1581 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1582 		4, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1583 
  1584 #define SH_DECL_HOOK4_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4) \
  1585 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, const char *, ...) attr> \
  1586 		(&ifacetype::ifacefunc))) \
  1587 		typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, const char *, rettype> FD; \
  1588 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, const char *fmt, ...) \
  1589 		{ \
  1590 			char buf[::SourceHook::STRBUF_LEN]; \
  1591 			va_list ap; \
  1592 			va_start(ap, fmt); \
  1593 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1594 			va_end(ap); \
  1595 			SH_HANDLEFUNC_vafmt((param1, param2, param3, param4, ...), (p1, p2, p3, p4, "%s", buf), (p1, p2, p3, p4, buf), rettype); \
  1596 		} \
  1597 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1598 		(static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1599 	\
  1600 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4) }; \
  1601 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1602 		4, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1603 
  1604 #define SH_DECL_HOOK4_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4) \
  1605 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, const char *, ...) attr> \
  1606 		(&ifacetype::ifacefunc))) \
  1607 		typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, const char *> FD; \
  1608 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, const char *fmt, ...) \
  1609 		{ \
  1610 			char buf[::SourceHook::STRBUF_LEN]; \
  1611 			va_list ap; \
  1612 			va_start(ap, fmt); \
  1613 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1614 			va_end(ap); \
  1615 			SH_HANDLEFUNC_void_vafmt((param1, param2, param3, param4, ...), (p1, p2, p3, p4, "%s", buf), (p1, p2, p3, p4, buf)); \
  1616 		} \
  1617 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1618 		(static_cast<void (ifacetype::*)(param1, param2, param3, param4, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1619 	\
  1620 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4) }; \
  1621 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1622 		4, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1623 
  1624 #define SH_DECL_MANUALHOOK4(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2, param3, param4) \
  1625 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1626 		typedef fastdelegate::FastDelegate4<param1, param2, param3, param4, rettype> FD; \
  1627 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4) \
  1628 		{ SH_HANDLEFUNC((param1, param2, param3, param4), (p1, p2, p3, p4), rettype); } \
  1629 		typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4); \
  1630 		typedef rettype RetType; \
  1631 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1632 	\
  1633 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4) }; \
  1634 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(sizeof(rettype), \
  1635 		4, __SourceHook_ParamSizesM_##hookname); \
  1636 
  1637 #define SH_DECL_MANUALHOOK4_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2, param3, param4) \
  1638 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1639 		typedef fastdelegate::FastDelegate4<param1, param2, param3, param4> FD; \
  1640 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4) \
  1641 		{ SH_HANDLEFUNC_void((param1, param2, param3, param4), (p1, p2, p3, p4)); } \
  1642 		typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4); \
  1643 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1644 	\
  1645 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4) }; \
  1646 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(0, \
  1647 		4, __SourceHook_ParamSizesM_##hookname); \
  1648 
  1649 
  1650 // ********* Support for 5 arguments *********
  1651 #define SH_DECL_HOOK5(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5) \
  1652 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5) attr> \
  1653 		(&ifacetype::ifacefunc))) \
  1654 		typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, param5, rettype> FD; \
  1655 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \
  1656 		{ SH_HANDLEFUNC((param1, param2, param3, param4, param5), (p1, p2, p3, p4, p5), rettype); } \
  1657 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1658 		(static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5) attr>(&ifacetype::ifacefunc))) \
  1659 	\
  1660 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5) }; \
  1661 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1662 		5, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1663 
  1664 #define SH_DECL_HOOK5_void(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5) \
  1665 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5) attr> \
  1666 		(&ifacetype::ifacefunc))) \
  1667 		typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, param5> FD; \
  1668 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \
  1669 		{ SH_HANDLEFUNC_void((param1, param2, param3, param4, param5), (p1, p2, p3, p4, p5)); } \
  1670 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1671 		(static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5) attr>(&ifacetype::ifacefunc))) \
  1672 	\
  1673 	\
  1674 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5) }; \
  1675 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1676 		5, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1677 
  1678 #define SH_DECL_HOOK5_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5) \
  1679 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, const char *, ...) attr> \
  1680 		(&ifacetype::ifacefunc))) \
  1681 		typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, const char *, rettype> FD; \
  1682 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, const char *fmt, ...) \
  1683 		{ \
  1684 			char buf[::SourceHook::STRBUF_LEN]; \
  1685 			va_list ap; \
  1686 			va_start(ap, fmt); \
  1687 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1688 			va_end(ap); \
  1689 			SH_HANDLEFUNC_vafmt((param1, param2, param3, param4, param5, ...), (p1, p2, p3, p4, p5, "%s", buf), (p1, p2, p3, p4, p5, buf), rettype); \
  1690 		} \
  1691 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1692 		(static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1693 	\
  1694 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5) }; \
  1695 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1696 		5, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1697 
  1698 #define SH_DECL_HOOK5_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5) \
  1699 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, const char *, ...) attr> \
  1700 		(&ifacetype::ifacefunc))) \
  1701 		typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, const char *> FD; \
  1702 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, const char *fmt, ...) \
  1703 		{ \
  1704 			char buf[::SourceHook::STRBUF_LEN]; \
  1705 			va_list ap; \
  1706 			va_start(ap, fmt); \
  1707 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1708 			va_end(ap); \
  1709 			SH_HANDLEFUNC_void_vafmt((param1, param2, param3, param4, param5, ...), (p1, p2, p3, p4, p5, "%s", buf), (p1, p2, p3, p4, p5, buf)); \
  1710 		} \
  1711 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1712 		(static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1713 	\
  1714 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5) }; \
  1715 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1716 		5, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1717 
  1718 #define SH_DECL_MANUALHOOK5(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2, param3, param4, param5) \
  1719 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1720 		typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, param5, rettype> FD; \
  1721 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \
  1722 		{ SH_HANDLEFUNC((param1, param2, param3, param4, param5), (p1, p2, p3, p4, p5), rettype); } \
  1723 		typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5); \
  1724 		typedef rettype RetType; \
  1725 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1726 	\
  1727 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5) }; \
  1728 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(sizeof(rettype), \
  1729 		5, __SourceHook_ParamSizesM_##hookname); \
  1730 
  1731 #define SH_DECL_MANUALHOOK5_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2, param3, param4, param5) \
  1732 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1733 		typedef fastdelegate::FastDelegate5<param1, param2, param3, param4, param5> FD; \
  1734 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5) \
  1735 		{ SH_HANDLEFUNC_void((param1, param2, param3, param4, param5), (p1, p2, p3, p4, p5)); } \
  1736 		typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5); \
  1737 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1738 	\
  1739 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5) }; \
  1740 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(0, \
  1741 		5, __SourceHook_ParamSizesM_##hookname); \
  1742 
  1743 
  1744 // ********* Support for 6 arguments *********
  1745 #define SH_DECL_HOOK6(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5, param6) \
  1746 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6) attr> \
  1747 		(&ifacetype::ifacefunc))) \
  1748 		typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, param6, rettype> FD; \
  1749 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \
  1750 		{ SH_HANDLEFUNC((param1, param2, param3, param4, param5, param6), (p1, p2, p3, p4, p5, p6), rettype); } \
  1751 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1752 		(static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6) attr>(&ifacetype::ifacefunc))) \
  1753 	\
  1754 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6) }; \
  1755 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1756 		6, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1757 
  1758 #define SH_DECL_HOOK6_void(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5, param6) \
  1759 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6) attr> \
  1760 		(&ifacetype::ifacefunc))) \
  1761 		typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, param6> FD; \
  1762 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \
  1763 		{ SH_HANDLEFUNC_void((param1, param2, param3, param4, param5, param6), (p1, p2, p3, p4, p5, p6)); } \
  1764 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1765 		(static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6) attr>(&ifacetype::ifacefunc))) \
  1766 	\
  1767 	\
  1768 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6) }; \
  1769 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1770 		6, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1771 
  1772 #define SH_DECL_HOOK6_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5, param6) \
  1773 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, const char *, ...) attr> \
  1774 		(&ifacetype::ifacefunc))) \
  1775 		typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, const char *, rettype> FD; \
  1776 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, const char *fmt, ...) \
  1777 		{ \
  1778 			char buf[::SourceHook::STRBUF_LEN]; \
  1779 			va_list ap; \
  1780 			va_start(ap, fmt); \
  1781 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1782 			va_end(ap); \
  1783 			SH_HANDLEFUNC_vafmt((param1, param2, param3, param4, param5, param6, ...), (p1, p2, p3, p4, p5, p6, "%s", buf), (p1, p2, p3, p4, p5, p6, buf), rettype); \
  1784 		} \
  1785 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1786 		(static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1787 	\
  1788 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6) }; \
  1789 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1790 		6, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1791 
  1792 #define SH_DECL_HOOK6_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5, param6) \
  1793 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, const char *, ...) attr> \
  1794 		(&ifacetype::ifacefunc))) \
  1795 		typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, const char *> FD; \
  1796 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, const char *fmt, ...) \
  1797 		{ \
  1798 			char buf[::SourceHook::STRBUF_LEN]; \
  1799 			va_list ap; \
  1800 			va_start(ap, fmt); \
  1801 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1802 			va_end(ap); \
  1803 			SH_HANDLEFUNC_void_vafmt((param1, param2, param3, param4, param5, param6, ...), (p1, p2, p3, p4, p5, p6, "%s", buf), (p1, p2, p3, p4, p5, p6, buf)); \
  1804 		} \
  1805 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1806 		(static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1807 	\
  1808 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6) }; \
  1809 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1810 		6, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1811 
  1812 #define SH_DECL_MANUALHOOK6(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2, param3, param4, param5, param6) \
  1813 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1814 		typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, param6, rettype> FD; \
  1815 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \
  1816 		{ SH_HANDLEFUNC((param1, param2, param3, param4, param5, param6), (p1, p2, p3, p4, p5, p6), rettype); } \
  1817 		typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5, param6); \
  1818 		typedef rettype RetType; \
  1819 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1820 	\
  1821 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6) }; \
  1822 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(sizeof(rettype), \
  1823 		6, __SourceHook_ParamSizesM_##hookname); \
  1824 
  1825 #define SH_DECL_MANUALHOOK6_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2, param3, param4, param5, param6) \
  1826 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1827 		typedef fastdelegate::FastDelegate6<param1, param2, param3, param4, param5, param6> FD; \
  1828 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6) \
  1829 		{ SH_HANDLEFUNC_void((param1, param2, param3, param4, param5, param6), (p1, p2, p3, p4, p5, p6)); } \
  1830 		typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5, param6); \
  1831 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1832 	\
  1833 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6) }; \
  1834 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(0, \
  1835 		6, __SourceHook_ParamSizesM_##hookname); \
  1836 
  1837 
  1838 // ********* Support for 7 arguments *********
  1839 #define SH_DECL_HOOK7(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5, param6, param7) \
  1840 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7) attr> \
  1841 		(&ifacetype::ifacefunc))) \
  1842 		typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, param7, rettype> FD; \
  1843 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7) \
  1844 		{ SH_HANDLEFUNC((param1, param2, param3, param4, param5, param6, param7), (p1, p2, p3, p4, p5, p6, p7), rettype); } \
  1845 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1846 		(static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7) attr>(&ifacetype::ifacefunc))) \
  1847 	\
  1848 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6), sizeof(param7) }; \
  1849 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1850 		7, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1851 
  1852 #define SH_DECL_HOOK7_void(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5, param6, param7) \
  1853 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7) attr> \
  1854 		(&ifacetype::ifacefunc))) \
  1855 		typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, param7> FD; \
  1856 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7) \
  1857 		{ SH_HANDLEFUNC_void((param1, param2, param3, param4, param5, param6, param7), (p1, p2, p3, p4, p5, p6, p7)); } \
  1858 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1859 		(static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7) attr>(&ifacetype::ifacefunc))) \
  1860 	\
  1861 	\
  1862 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6), sizeof(param7) }; \
  1863 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1864 		7, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1865 
  1866 #define SH_DECL_HOOK7_vafmt(ifacetype, ifacefunc, attr, overload, rettype, param1, param2, param3, param4, param5, param6, param7) \
  1867 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7, const char *, ...) attr> \
  1868 		(&ifacetype::ifacefunc))) \
  1869 		typedef fastdelegate::FastDelegate8<param1, param2, param3, param4, param5, param6, param7, const char *, rettype> FD; \
  1870 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7, const char *fmt, ...) \
  1871 		{ \
  1872 			char buf[::SourceHook::STRBUF_LEN]; \
  1873 			va_list ap; \
  1874 			va_start(ap, fmt); \
  1875 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1876 			va_end(ap); \
  1877 			SH_HANDLEFUNC_vafmt((param1, param2, param3, param4, param5, param6, param7, ...), (p1, p2, p3, p4, p5, p6, p7, "%s", buf), (p1, p2, p3, p4, p5, p6, p7, buf), rettype); \
  1878 		} \
  1879 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1880 		(static_cast<rettype (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1881 	\
  1882 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6), sizeof(param7) }; \
  1883 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
  1884 		7, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1885 
  1886 #define SH_DECL_HOOK7_void_vafmt(ifacetype, ifacefunc, attr, overload, param1, param2, param3, param4, param5, param6, param7) \
  1887 	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7, const char *, ...) attr> \
  1888 		(&ifacetype::ifacefunc))) \
  1889 		typedef fastdelegate::FastDelegate8<param1, param2, param3, param4, param5, param6, param7, const char *> FD; \
  1890 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7, const char *fmt, ...) \
  1891 		{ \
  1892 			char buf[::SourceHook::STRBUF_LEN]; \
  1893 			va_list ap; \
  1894 			va_start(ap, fmt); \
  1895 			vsnprintf(buf, sizeof(buf), fmt, ap); \
  1896 			va_end(ap); \
  1897 			SH_HANDLEFUNC_void_vafmt((param1, param2, param3, param4, param5, param6, param7, ...), (p1, p2, p3, p4, p5, p6, p7, "%s", buf), (p1, p2, p3, p4, p5, p6, p7, buf)); \
  1898 		} \
  1899 	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
  1900 		(static_cast<void (ifacetype::*)(param1, param2, param3, param4, param5, param6, param7, const char *, ...) attr>(&ifacetype::ifacefunc))) \
  1901 	\
  1902 	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6), sizeof(param7) }; \
  1903 	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
  1904 		7, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
  1905 
  1906 #define SH_DECL_MANUALHOOK7(hookname, vtblidx, vtbloffs, thisptroffs, rettype, param1, param2, param3, param4, param5, param6, param7) \
  1907 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1908 		typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, param7, rettype> FD; \
  1909 		virtual rettype Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7) \
  1910 		{ SH_HANDLEFUNC((param1, param2, param3, param4, param5, param6, param7), (p1, p2, p3, p4, p5, p6, p7), rettype); } \
  1911 		typedef rettype(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5, param6, param7); \
  1912 		typedef rettype RetType; \
  1913 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1914 	\
  1915 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6), sizeof(param7) }; \
  1916 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(sizeof(rettype), \
  1917 		7, __SourceHook_ParamSizesM_##hookname); \
  1918 
  1919 #define SH_DECL_MANUALHOOK7_void(hookname, vtblidx, vtbloffs, thisptroffs, param1, param2, param3, param4, param5, param6, param7) \
  1920 	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1921 		typedef fastdelegate::FastDelegate7<param1, param2, param3, param4, param5, param6, param7> FD; \
  1922 		virtual void Func(param1 p1, param2 p2, param3 p3, param4 p4, param5 p5, param6 p6, param7 p7) \
  1923 		{ SH_HANDLEFUNC_void((param1, param2, param3, param4, param5, param6, param7), (p1, p2, p3, p4, p5, p6, p7)); } \
  1924 		typedef void(::SourceHook::EmptyClass::*ECMFP)(param1, param2, param3, param4, param5, param6, param7); \
  1925 	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
  1926 	\
  1927 	const int __SourceHook_ParamSizesM_##hookname[] = { 0, sizeof(param1), sizeof(param2), sizeof(param3), sizeof(param4), sizeof(param5), sizeof(param6), sizeof(param7) }; \
  1928 	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(0, \
  1929 		7, __SourceHook_ParamSizesM_##hookname); \
  1930 
  1931 
  1932 
  1933 
  1934 //////////////////////////////////////////////////////////////////////////
  1935 // SH_CALL
  1936 
  1937 #define SH_MAKE_EXECUTABLECLASS_OB(call, prms) \
  1938 { \
  1939 	using namespace ::SourceHook; \
  1940 	\
  1941 	m_pSH->SetIgnoreHooks(m_Plug, m_VfnPtr); \
  1942 	RetType tmpret = (m_ThisPtr->*m_MFP)call; \
  1943 	m_pSH->ResetIgnoreHooks(m_Plug, m_VfnPtr); \
  1944 	return tmpret; \
  1945 }
  1946 
  1947 #define SH_MAKE_EXECUTABLECLASS_OB_void(call, prms) \
  1948 { \
  1949 	using namespace ::SourceHook; \
  1950 	\
  1951 	m_pSH->SetIgnoreHooks(m_Plug, m_VfnPtr); \
  1952 	(m_ThisPtr->*m_MFP)call; \
  1953 	m_pSH->ResetIgnoreHooks(m_Plug, m_VfnPtr); \
  1954 }
  1955 
  1956 namespace SourceHook
  1957 {
  1958 	// Call Class Wrapper!
  1959 	template <class T> struct CCW
  1960 	{
  1961 		typedef T type;
  1962 
  1963 		// Get Real Pointer!
  1964 		static inline T *GRP(T *p)
  1965 		{
  1966 			return p;
  1967 		}
  1968 	};
  1969 
  1970 	template <class T> struct CCW< CallClass<T> >
  1971 	{
  1972 		typedef T type;
  1973 
  1974 		// Get Real Pointer!
  1975 		static inline T *GRP(CallClass<T> *p)
  1976 		{
  1977 			return p->ptr;
  1978 		}
  1979 	};
  1980 
  1981 
  1982 	// Support for 0 arguments
  1983 	template<class ObjType, class MFP, class RetType> class ExecutableClass0
  1984 	{
  1985 		ObjType *m_ThisPtr;
  1986 		void *m_VfnPtr;
  1987 		MFP m_MFP;
  1988 		ISourceHook *m_pSH;
  1989 		Plugin m_Plug;
  1990 	public:
  1991 		ExecutableClass0(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  1992 			m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  1993 	
  1994 		RetType operator()() const
  1995 			SH_MAKE_EXECUTABLECLASS_OB((), ())
  1996 	         
  1997 		
  1998 		template <class Param1> RetType operator()(Param1 p1) const
  1999 			SH_MAKE_EXECUTABLECLASS_OB((p1), (Param1))
  2000 		
  2001 		template <class Param1, class Param2> RetType operator()(Param1 p1, Param2 p2) const
  2002 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2), (Param1, Param2))
  2003 		
  2004 		template <class Param1, class Param2, class Param3> RetType operator()(Param1 p1, Param2 p2, Param3 p3) const
  2005 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3), (Param1, Param2, Param3))
  2006 		
  2007 		template <class Param1, class Param2, class Param3, class Param4> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
  2008 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
  2009 		
  2010 		template <class Param1, class Param2, class Param3, class Param4, class Param5> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2011 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2012 		
  2013 		template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2014 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2015 		
  2016 		template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2017 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2018 		
  2019 	};
  2020 
  2021 	template<class ObjType, class MFP> class ExecutableClass0<ObjType, MFP, void>
  2022 	{
  2023 	   ObjType *m_ThisPtr;
  2024 	   void *m_VfnPtr;
  2025 	   MFP m_MFP;
  2026 	   ISourceHook *m_pSH;
  2027 	   Plugin m_Plug;
  2028 	public:
  2029 	   ExecutableClass0(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2030 		   m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2031 	
  2032 	   void operator()() const
  2033 	      SH_MAKE_EXECUTABLECLASS_OB_void((), ())
  2034 	         
  2035 	   
  2036 	   template <class Param1> void operator()(Param1 p1) const
  2037 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1), (Param1))
  2038 	   
  2039 	   template <class Param1, class Param2> void operator()(Param1 p1, Param2 p2) const
  2040 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2), (Param1, Param2))
  2041 	   
  2042 	   template <class Param1, class Param2, class Param3> void operator()(Param1 p1, Param2 p2, Param3 p3) const
  2043 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3), (Param1, Param2, Param3))
  2044 	   
  2045 	   template <class Param1, class Param2, class Param3, class Param4> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
  2046 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
  2047 	   
  2048 	   template <class Param1, class Param2, class Param3, class Param4, class Param5> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2049 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2050 	   
  2051 	   template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2052 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2053 	   
  2054 	   template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2055 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2056 	   
  2057 	};
  2058 
  2059 	// Support for 1 arguments
  2060 	template<class ObjType, class MFP, class RetType, class Param1> class ExecutableClass1
  2061 	{
  2062 		ObjType *m_ThisPtr;
  2063 		void *m_VfnPtr;
  2064 		MFP m_MFP;
  2065 		ISourceHook *m_pSH;
  2066 		Plugin m_Plug;
  2067 	public:
  2068 		ExecutableClass1(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2069 			m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2070 	
  2071 		RetType operator()(Param1 p1) const
  2072 			SH_MAKE_EXECUTABLECLASS_OB((p1), (Param1))
  2073 	         
  2074 		
  2075 		template <class Param2> RetType operator()(Param1 p1, Param2 p2) const
  2076 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2), (Param1, Param2))
  2077 		
  2078 		template <class Param2, class Param3> RetType operator()(Param1 p1, Param2 p2, Param3 p3) const
  2079 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3), (Param1, Param2, Param3))
  2080 		
  2081 		template <class Param2, class Param3, class Param4> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
  2082 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
  2083 		
  2084 		template <class Param2, class Param3, class Param4, class Param5> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2085 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2086 		
  2087 		template <class Param2, class Param3, class Param4, class Param5, class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2088 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2089 		
  2090 		template <class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2091 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2092 		
  2093 	};
  2094 
  2095 	template<class ObjType, class MFP, class Param1> class ExecutableClass1<ObjType, MFP, void, Param1>
  2096 	{
  2097 	   ObjType *m_ThisPtr;
  2098 	   void *m_VfnPtr;
  2099 	   MFP m_MFP;
  2100 	   ISourceHook *m_pSH;
  2101 	   Plugin m_Plug;
  2102 	public:
  2103 	   ExecutableClass1(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2104 		   m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2105 	
  2106 	   void operator()(Param1 p1) const
  2107 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1), (Param1))
  2108 	         
  2109 	   
  2110 	   template <class Param2> void operator()(Param1 p1, Param2 p2) const
  2111 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2), (Param1, Param2))
  2112 	   
  2113 	   template <class Param2, class Param3> void operator()(Param1 p1, Param2 p2, Param3 p3) const
  2114 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3), (Param1, Param2, Param3))
  2115 	   
  2116 	   template <class Param2, class Param3, class Param4> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
  2117 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
  2118 	   
  2119 	   template <class Param2, class Param3, class Param4, class Param5> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2120 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2121 	   
  2122 	   template <class Param2, class Param3, class Param4, class Param5, class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2123 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2124 	   
  2125 	   template <class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2126 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2127 	   
  2128 	};
  2129 
  2130 	// Support for 2 arguments
  2131 	template<class ObjType, class MFP, class RetType, class Param1, class Param2> class ExecutableClass2
  2132 	{
  2133 		ObjType *m_ThisPtr;
  2134 		void *m_VfnPtr;
  2135 		MFP m_MFP;
  2136 		ISourceHook *m_pSH;
  2137 		Plugin m_Plug;
  2138 	public:
  2139 		ExecutableClass2(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2140 			m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2141 	
  2142 		RetType operator()(Param1 p1, Param2 p2) const
  2143 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2), (Param1, Param2))
  2144 	         
  2145 		
  2146 		template <class Param3> RetType operator()(Param1 p1, Param2 p2, Param3 p3) const
  2147 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3), (Param1, Param2, Param3))
  2148 		
  2149 		template <class Param3, class Param4> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
  2150 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
  2151 		
  2152 		template <class Param3, class Param4, class Param5> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2153 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2154 		
  2155 		template <class Param3, class Param4, class Param5, class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2156 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2157 		
  2158 		template <class Param3, class Param4, class Param5, class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2159 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2160 		
  2161 	};
  2162 
  2163 	template<class ObjType, class MFP, class Param1, class Param2> class ExecutableClass2<ObjType, MFP, void, Param1, Param2>
  2164 	{
  2165 	   ObjType *m_ThisPtr;
  2166 	   void *m_VfnPtr;
  2167 	   MFP m_MFP;
  2168 	   ISourceHook *m_pSH;
  2169 	   Plugin m_Plug;
  2170 	public:
  2171 	   ExecutableClass2(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2172 		   m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2173 	
  2174 	   void operator()(Param1 p1, Param2 p2) const
  2175 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2), (Param1, Param2))
  2176 	         
  2177 	   
  2178 	   template <class Param3> void operator()(Param1 p1, Param2 p2, Param3 p3) const
  2179 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3), (Param1, Param2, Param3))
  2180 	   
  2181 	   template <class Param3, class Param4> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
  2182 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
  2183 	   
  2184 	   template <class Param3, class Param4, class Param5> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2185 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2186 	   
  2187 	   template <class Param3, class Param4, class Param5, class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2188 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2189 	   
  2190 	   template <class Param3, class Param4, class Param5, class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2191 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2192 	   
  2193 	};
  2194 
  2195 	// Support for 3 arguments
  2196 	template<class ObjType, class MFP, class RetType, class Param1, class Param2, class Param3> class ExecutableClass3
  2197 	{
  2198 		ObjType *m_ThisPtr;
  2199 		void *m_VfnPtr;
  2200 		MFP m_MFP;
  2201 		ISourceHook *m_pSH;
  2202 		Plugin m_Plug;
  2203 	public:
  2204 		ExecutableClass3(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2205 			m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2206 	
  2207 		RetType operator()(Param1 p1, Param2 p2, Param3 p3) const
  2208 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3), (Param1, Param2, Param3))
  2209 	         
  2210 		
  2211 		template <class Param4> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
  2212 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
  2213 		
  2214 		template <class Param4, class Param5> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2215 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2216 		
  2217 		template <class Param4, class Param5, class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2218 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2219 		
  2220 		template <class Param4, class Param5, class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2221 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2222 		
  2223 	};
  2224 
  2225 	template<class ObjType, class MFP, class Param1, class Param2, class Param3> class ExecutableClass3<ObjType, MFP, void, Param1, Param2, Param3>
  2226 	{
  2227 	   ObjType *m_ThisPtr;
  2228 	   void *m_VfnPtr;
  2229 	   MFP m_MFP;
  2230 	   ISourceHook *m_pSH;
  2231 	   Plugin m_Plug;
  2232 	public:
  2233 	   ExecutableClass3(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2234 		   m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2235 	
  2236 	   void operator()(Param1 p1, Param2 p2, Param3 p3) const
  2237 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3), (Param1, Param2, Param3))
  2238 	         
  2239 	   
  2240 	   template <class Param4> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
  2241 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
  2242 	   
  2243 	   template <class Param4, class Param5> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2244 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2245 	   
  2246 	   template <class Param4, class Param5, class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2247 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2248 	   
  2249 	   template <class Param4, class Param5, class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2250 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2251 	   
  2252 	};
  2253 
  2254 	// Support for 4 arguments
  2255 	template<class ObjType, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4> class ExecutableClass4
  2256 	{
  2257 		ObjType *m_ThisPtr;
  2258 		void *m_VfnPtr;
  2259 		MFP m_MFP;
  2260 		ISourceHook *m_pSH;
  2261 		Plugin m_Plug;
  2262 	public:
  2263 		ExecutableClass4(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2264 			m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2265 	
  2266 		RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
  2267 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
  2268 	         
  2269 		
  2270 		template <class Param5> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2271 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2272 		
  2273 		template <class Param5, class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2274 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2275 		
  2276 		template <class Param5, class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2277 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2278 		
  2279 	};
  2280 
  2281 	template<class ObjType, class MFP, class Param1, class Param2, class Param3, class Param4> class ExecutableClass4<ObjType, MFP, void, Param1, Param2, Param3, Param4>
  2282 	{
  2283 	   ObjType *m_ThisPtr;
  2284 	   void *m_VfnPtr;
  2285 	   MFP m_MFP;
  2286 	   ISourceHook *m_pSH;
  2287 	   Plugin m_Plug;
  2288 	public:
  2289 	   ExecutableClass4(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2290 		   m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2291 	
  2292 	   void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
  2293 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4), (Param1, Param2, Param3, Param4))
  2294 	         
  2295 	   
  2296 	   template <class Param5> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2297 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2298 	   
  2299 	   template <class Param5, class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2300 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2301 	   
  2302 	   template <class Param5, class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2303 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2304 	   
  2305 	};
  2306 
  2307 	// Support for 5 arguments
  2308 	template<class ObjType, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5> class ExecutableClass5
  2309 	{
  2310 		ObjType *m_ThisPtr;
  2311 		void *m_VfnPtr;
  2312 		MFP m_MFP;
  2313 		ISourceHook *m_pSH;
  2314 		Plugin m_Plug;
  2315 	public:
  2316 		ExecutableClass5(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2317 			m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2318 	
  2319 		RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2320 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2321 	         
  2322 		
  2323 		template <class Param6> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2324 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2325 		
  2326 		template <class Param6, class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2327 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2328 		
  2329 	};
  2330 
  2331 	template<class ObjType, class MFP, class Param1, class Param2, class Param3, class Param4, class Param5> class ExecutableClass5<ObjType, MFP, void, Param1, Param2, Param3, Param4, Param5>
  2332 	{
  2333 	   ObjType *m_ThisPtr;
  2334 	   void *m_VfnPtr;
  2335 	   MFP m_MFP;
  2336 	   ISourceHook *m_pSH;
  2337 	   Plugin m_Plug;
  2338 	public:
  2339 	   ExecutableClass5(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2340 		   m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2341 	
  2342 	   void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
  2343 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5), (Param1, Param2, Param3, Param4, Param5))
  2344 	         
  2345 	   
  2346 	   template <class Param6> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2347 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2348 	   
  2349 	   template <class Param6, class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2350 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2351 	   
  2352 	};
  2353 
  2354 	// Support for 6 arguments
  2355 	template<class ObjType, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6> class ExecutableClass6
  2356 	{
  2357 		ObjType *m_ThisPtr;
  2358 		void *m_VfnPtr;
  2359 		MFP m_MFP;
  2360 		ISourceHook *m_pSH;
  2361 		Plugin m_Plug;
  2362 	public:
  2363 		ExecutableClass6(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2364 			m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2365 	
  2366 		RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2367 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2368 	         
  2369 		
  2370 		template <class Param7> RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2371 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2372 		
  2373 	};
  2374 
  2375 	template<class ObjType, class MFP, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6> class ExecutableClass6<ObjType, MFP, void, Param1, Param2, Param3, Param4, Param5, Param6>
  2376 	{
  2377 	   ObjType *m_ThisPtr;
  2378 	   void *m_VfnPtr;
  2379 	   MFP m_MFP;
  2380 	   ISourceHook *m_pSH;
  2381 	   Plugin m_Plug;
  2382 	public:
  2383 	   ExecutableClass6(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2384 		   m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2385 	
  2386 	   void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
  2387 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6), (Param1, Param2, Param3, Param4, Param5, Param6))
  2388 	         
  2389 	   
  2390 	   template <class Param7> void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2391 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2392 	   
  2393 	};
  2394 
  2395 	// Support for 7 arguments
  2396 	template<class ObjType, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> class ExecutableClass7
  2397 	{
  2398 		ObjType *m_ThisPtr;
  2399 		void *m_VfnPtr;
  2400 		MFP m_MFP;
  2401 		ISourceHook *m_pSH;
  2402 		Plugin m_Plug;
  2403 	public:
  2404 		ExecutableClass7(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2405 			m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2406 	
  2407 		RetType operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2408 			SH_MAKE_EXECUTABLECLASS_OB((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2409 	         
  2410 		
  2411 	};
  2412 
  2413 	template<class ObjType, class MFP, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7> class ExecutableClass7<ObjType, MFP, void, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
  2414 	{
  2415 	   ObjType *m_ThisPtr;
  2416 	   void *m_VfnPtr;
  2417 	   MFP m_MFP;
  2418 	   ISourceHook *m_pSH;
  2419 	   Plugin m_Plug;
  2420 	public:
  2421 	   ExecutableClass7(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
  2422 		   m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
  2423 	
  2424 	   void operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
  2425 	      SH_MAKE_EXECUTABLECLASS_OB_void((p1, p2, p3, p4, p5, p6, p7), (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2426 	         
  2427 	   
  2428 	};
  2429 
  2430 
  2431 }
  2432 
  2433 #define SH__CALL_GET_VFNPTR_NORMAL \
  2434 	using namespace ::SourceHook; \
  2435 	MemFuncInfo mfi = {true, -1, 0, 0}; \
  2436 	GetFuncInfo(CCW<Y>::GRP(ptr), mfp, mfi); \
  2437 	void *vfnptr = reinterpret_cast<void*>( \
  2438 		*reinterpret_cast<void***>(reinterpret_cast<char*>(ptr) + mfi.thisptroffs + mfi.vtbloffs) + mfi.vtblindex);
  2439 
  2440 #define SH__CALL_GET_VFNPTR_MANUAL \
  2441 	using namespace ::SourceHook; \
  2442 	void *vfnptr = reinterpret_cast<void*>( \
  2443 		*reinterpret_cast<void***>( (reinterpret_cast<char*>(CCW<Y>::GRP(ptr)) + thisptroffs + vtbloffs) ) + vtblidx); \
  2444 	/* patch mfp */ \
  2445 	*reinterpret_cast<void**>(&mfp) = *reinterpret_cast<void**>(vfnptr);
  2446 
  2447 // SH_CALL needs to deduce the return type -> it uses templates and function overloading
  2448 // That's why SH_CALL takes two parameters: "mfp2" of type RetType(X::*mfp)(params), and "mfp" of type MFP
  2449 // The only purpose of the mfp2 parameter is to extract the return type
  2450 
  2451 
  2452 // Support for 0 arguments
  2453 template <class X, class Y, class MFP, class RetType>
  2454 SourceHook::ExecutableClass0<typename SourceHook::CCW<Y>::type, MFP, RetType>
  2455 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2456 {
  2457 	SH__CALL_GET_VFNPTR_NORMAL
  2458 	return SourceHook::ExecutableClass0<typename CCW<Y>::type, MFP, RetType>(CCW<Y>::GRP(ptr),
  2459 		mfp, vfnptr, shptr, plug);
  2460 }
  2461 
  2462 template <class X, class Y, class MFP, class RetType>
  2463 SourceHook::ExecutableClass0<typename SourceHook::CCW<Y>::type, MFP, RetType>
  2464 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)()const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2465 {
  2466 	SH__CALL_GET_VFNPTR_NORMAL
  2467 	return SourceHook::ExecutableClass0<typename CCW<Y>::type, MFP, RetType>(CCW<Y>::GRP(ptr),
  2468 		mfp, vfnptr, shptr, plug);
  2469 }
  2470 
  2471 template <class X, class Y, class MFP, class RetType>
  2472 SourceHook::ExecutableClass0<SourceHook::EmptyClass, MFP, RetType>
  2473 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2474 {
  2475 	SH__CALL_GET_VFNPTR_MANUAL
  2476 	return SourceHook::ExecutableClass0<EmptyClass, MFP, RetType>(
  2477 		reinterpret_cast<SourceHook::EmptyClass*>(CCW<Y>::GRP(ptr)), mfp, vfnptr, shptr, plug);
  2478 }
  2479 
  2480 // Support for 1 arguments
  2481 template <class X, class Y, class MFP, class RetType, class Param1>
  2482 SourceHook::ExecutableClass1<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1>
  2483 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2484 {
  2485 	SH__CALL_GET_VFNPTR_NORMAL
  2486 	return SourceHook::ExecutableClass1<typename CCW<Y>::type, MFP, RetType, Param1>(CCW<Y>::GRP(ptr),
  2487 		mfp, vfnptr, shptr, plug);
  2488 }
  2489 
  2490 template <class X, class Y, class MFP, class RetType, class Param1>
  2491 SourceHook::ExecutableClass1<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1>
  2492 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2493 {
  2494 	SH__CALL_GET_VFNPTR_NORMAL
  2495 	return SourceHook::ExecutableClass1<typename CCW<Y>::type, MFP, RetType, Param1>(CCW<Y>::GRP(ptr),
  2496 		mfp, vfnptr, shptr, plug);
  2497 }
  2498 
  2499 template <class X, class Y, class MFP, class RetType, class Param1>
  2500 SourceHook::ExecutableClass1<SourceHook::EmptyClass, MFP, RetType, Param1>
  2501 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2502 {
  2503 	SH__CALL_GET_VFNPTR_MANUAL
  2504 	return SourceHook::ExecutableClass1<EmptyClass, MFP, RetType, Param1>(
  2505 		reinterpret_cast<SourceHook::EmptyClass*>(CCW<Y>::GRP(ptr)), mfp, vfnptr, shptr, plug);
  2506 }
  2507 
  2508 // Support for 2 arguments
  2509 template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
  2510 SourceHook::ExecutableClass2<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2>
  2511 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2512 {
  2513 	SH__CALL_GET_VFNPTR_NORMAL
  2514 	return SourceHook::ExecutableClass2<typename CCW<Y>::type, MFP, RetType, Param1, Param2>(CCW<Y>::GRP(ptr),
  2515 		mfp, vfnptr, shptr, plug);
  2516 }
  2517 
  2518 template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
  2519 SourceHook::ExecutableClass2<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2>
  2520 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2521 {
  2522 	SH__CALL_GET_VFNPTR_NORMAL
  2523 	return SourceHook::ExecutableClass2<typename CCW<Y>::type, MFP, RetType, Param1, Param2>(CCW<Y>::GRP(ptr),
  2524 		mfp, vfnptr, shptr, plug);
  2525 }
  2526 
  2527 template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
  2528 SourceHook::ExecutableClass2<SourceHook::EmptyClass, MFP, RetType, Param1, Param2>
  2529 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2530 {
  2531 	SH__CALL_GET_VFNPTR_MANUAL
  2532 	return SourceHook::ExecutableClass2<EmptyClass, MFP, RetType, Param1, Param2>(
  2533 		reinterpret_cast<SourceHook::EmptyClass*>(CCW<Y>::GRP(ptr)), mfp, vfnptr, shptr, plug);
  2534 }
  2535 
  2536 // Support for 3 arguments
  2537 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
  2538 SourceHook::ExecutableClass3<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3>
  2539 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2540 {
  2541 	SH__CALL_GET_VFNPTR_NORMAL
  2542 	return SourceHook::ExecutableClass3<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3>(CCW<Y>::GRP(ptr),
  2543 		mfp, vfnptr, shptr, plug);
  2544 }
  2545 
  2546 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
  2547 SourceHook::ExecutableClass3<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3>
  2548 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2549 {
  2550 	SH__CALL_GET_VFNPTR_NORMAL
  2551 	return SourceHook::ExecutableClass3<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3>(CCW<Y>::GRP(ptr),
  2552 		mfp, vfnptr, shptr, plug);
  2553 }
  2554 
  2555 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
  2556 SourceHook::ExecutableClass3<SourceHook::EmptyClass, MFP, RetType, Param1, Param2, Param3>
  2557 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2558 {
  2559 	SH__CALL_GET_VFNPTR_MANUAL
  2560 	return SourceHook::ExecutableClass3<EmptyClass, MFP, RetType, Param1, Param2, Param3>(
  2561 		reinterpret_cast<SourceHook::EmptyClass*>(CCW<Y>::GRP(ptr)), mfp, vfnptr, shptr, plug);
  2562 }
  2563 
  2564 // Support for 4 arguments
  2565 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
  2566 SourceHook::ExecutableClass4<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4>
  2567 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2568 {
  2569 	SH__CALL_GET_VFNPTR_NORMAL
  2570 	return SourceHook::ExecutableClass4<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4>(CCW<Y>::GRP(ptr),
  2571 		mfp, vfnptr, shptr, plug);
  2572 }
  2573 
  2574 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
  2575 SourceHook::ExecutableClass4<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4>
  2576 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2577 {
  2578 	SH__CALL_GET_VFNPTR_NORMAL
  2579 	return SourceHook::ExecutableClass4<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4>(CCW<Y>::GRP(ptr),
  2580 		mfp, vfnptr, shptr, plug);
  2581 }
  2582 
  2583 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
  2584 SourceHook::ExecutableClass4<SourceHook::EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4>
  2585 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2586 {
  2587 	SH__CALL_GET_VFNPTR_MANUAL
  2588 	return SourceHook::ExecutableClass4<EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4>(
  2589 		reinterpret_cast<SourceHook::EmptyClass*>(CCW<Y>::GRP(ptr)), mfp, vfnptr, shptr, plug);
  2590 }
  2591 
  2592 // Support for 5 arguments
  2593 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
  2594 SourceHook::ExecutableClass5<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5>
  2595 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2596 {
  2597 	SH__CALL_GET_VFNPTR_NORMAL
  2598 	return SourceHook::ExecutableClass5<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5>(CCW<Y>::GRP(ptr),
  2599 		mfp, vfnptr, shptr, plug);
  2600 }
  2601 
  2602 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
  2603 SourceHook::ExecutableClass5<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5>
  2604 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2605 {
  2606 	SH__CALL_GET_VFNPTR_NORMAL
  2607 	return SourceHook::ExecutableClass5<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5>(CCW<Y>::GRP(ptr),
  2608 		mfp, vfnptr, shptr, plug);
  2609 }
  2610 
  2611 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
  2612 SourceHook::ExecutableClass5<SourceHook::EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5>
  2613 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2614 {
  2615 	SH__CALL_GET_VFNPTR_MANUAL
  2616 	return SourceHook::ExecutableClass5<EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5>(
  2617 		reinterpret_cast<SourceHook::EmptyClass*>(CCW<Y>::GRP(ptr)), mfp, vfnptr, shptr, plug);
  2618 }
  2619 
  2620 // Support for 6 arguments
  2621 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  2622 SourceHook::ExecutableClass6<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>
  2623 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2624 {
  2625 	SH__CALL_GET_VFNPTR_NORMAL
  2626 	return SourceHook::ExecutableClass6<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>(CCW<Y>::GRP(ptr),
  2627 		mfp, vfnptr, shptr, plug);
  2628 }
  2629 
  2630 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  2631 SourceHook::ExecutableClass6<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>
  2632 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2633 {
  2634 	SH__CALL_GET_VFNPTR_NORMAL
  2635 	return SourceHook::ExecutableClass6<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>(CCW<Y>::GRP(ptr),
  2636 		mfp, vfnptr, shptr, plug);
  2637 }
  2638 
  2639 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  2640 SourceHook::ExecutableClass6<SourceHook::EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>
  2641 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2642 {
  2643 	SH__CALL_GET_VFNPTR_MANUAL
  2644 	return SourceHook::ExecutableClass6<EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>(
  2645 		reinterpret_cast<SourceHook::EmptyClass*>(CCW<Y>::GRP(ptr)), mfp, vfnptr, shptr, plug);
  2646 }
  2647 
  2648 // Support for 7 arguments
  2649 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  2650 SourceHook::ExecutableClass7<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
  2651 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2652 {
  2653 	SH__CALL_GET_VFNPTR_NORMAL
  2654 	return SourceHook::ExecutableClass7<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>(CCW<Y>::GRP(ptr),
  2655 		mfp, vfnptr, shptr, plug);
  2656 }
  2657 
  2658 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  2659 SourceHook::ExecutableClass7<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
  2660 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2661 {
  2662 	SH__CALL_GET_VFNPTR_NORMAL
  2663 	return SourceHook::ExecutableClass7<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>(CCW<Y>::GRP(ptr),
  2664 		mfp, vfnptr, shptr, plug);
  2665 }
  2666 
  2667 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  2668 SourceHook::ExecutableClass7<SourceHook::EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
  2669 SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2670 {
  2671 	SH__CALL_GET_VFNPTR_MANUAL
  2672 	return SourceHook::ExecutableClass7<EmptyClass, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>(
  2673 		reinterpret_cast<SourceHook::EmptyClass*>(CCW<Y>::GRP(ptr)), mfp, vfnptr, shptr, plug);
  2674 }
  2675 
  2676 
  2677 #if SH_COMP != SH_COMP_MSVC || _MSC_VER > 1300
  2678 // GCC & MSVC 7.1 need this, MSVC 7.0 doesn't like it
  2679 
  2680 
  2681 // Support for 0 arguments
  2682 template <class X, class Y, class MFP, class RetType>
  2683 SourceHook::ExecutableClass0<typename SourceHook::CCW<Y>::type, MFP, RetType>
  2684 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(...), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2685 {
  2686 	SH__CALL_GET_VFNPTR_NORMAL
  2687 	return SourceHook::ExecutableClass0<typename CCW<Y>::type, MFP, RetType>(CCW<Y>::GRP(ptr),
  2688 		mfp, vfnptr, shptr, plug);
  2689 }
  2690 
  2691 template <class X, class Y, class MFP, class RetType>
  2692 SourceHook::ExecutableClass0<typename SourceHook::CCW<Y>::type, MFP, RetType>
  2693 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(...)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2694 {
  2695 	SH__CALL_GET_VFNPTR_NORMAL
  2696 	return SourceHook::ExecutableClass0<typename CCW<Y>::type, MFP, RetType>(CCW<Y>::GRP(ptr),
  2697 		mfp, vfnptr, shptr, plug);
  2698 }
  2699 
  2700 
  2701 // Support for 1 arguments
  2702 template <class X, class Y, class MFP, class RetType, class Param1>
  2703 SourceHook::ExecutableClass1<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1>
  2704 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, ...), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2705 {
  2706 	SH__CALL_GET_VFNPTR_NORMAL
  2707 	return SourceHook::ExecutableClass1<typename CCW<Y>::type, MFP, RetType, Param1>(CCW<Y>::GRP(ptr),
  2708 		mfp, vfnptr, shptr, plug);
  2709 }
  2710 
  2711 template <class X, class Y, class MFP, class RetType, class Param1>
  2712 SourceHook::ExecutableClass1<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1>
  2713 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, ...)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2714 {
  2715 	SH__CALL_GET_VFNPTR_NORMAL
  2716 	return SourceHook::ExecutableClass1<typename CCW<Y>::type, MFP, RetType, Param1>(CCW<Y>::GRP(ptr),
  2717 		mfp, vfnptr, shptr, plug);
  2718 }
  2719 
  2720 
  2721 // Support for 2 arguments
  2722 template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
  2723 SourceHook::ExecutableClass2<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2>
  2724 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, ...), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2725 {
  2726 	SH__CALL_GET_VFNPTR_NORMAL
  2727 	return SourceHook::ExecutableClass2<typename CCW<Y>::type, MFP, RetType, Param1, Param2>(CCW<Y>::GRP(ptr),
  2728 		mfp, vfnptr, shptr, plug);
  2729 }
  2730 
  2731 template <class X, class Y, class MFP, class RetType, class Param1, class Param2>
  2732 SourceHook::ExecutableClass2<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2>
  2733 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, ...)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2734 {
  2735 	SH__CALL_GET_VFNPTR_NORMAL
  2736 	return SourceHook::ExecutableClass2<typename CCW<Y>::type, MFP, RetType, Param1, Param2>(CCW<Y>::GRP(ptr),
  2737 		mfp, vfnptr, shptr, plug);
  2738 }
  2739 
  2740 
  2741 // Support for 3 arguments
  2742 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
  2743 SourceHook::ExecutableClass3<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3>
  2744 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, ...), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2745 {
  2746 	SH__CALL_GET_VFNPTR_NORMAL
  2747 	return SourceHook::ExecutableClass3<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3>(CCW<Y>::GRP(ptr),
  2748 		mfp, vfnptr, shptr, plug);
  2749 }
  2750 
  2751 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3>
  2752 SourceHook::ExecutableClass3<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3>
  2753 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, ...)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2754 {
  2755 	SH__CALL_GET_VFNPTR_NORMAL
  2756 	return SourceHook::ExecutableClass3<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3>(CCW<Y>::GRP(ptr),
  2757 		mfp, vfnptr, shptr, plug);
  2758 }
  2759 
  2760 
  2761 // Support for 4 arguments
  2762 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
  2763 SourceHook::ExecutableClass4<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4>
  2764 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, ...), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2765 {
  2766 	SH__CALL_GET_VFNPTR_NORMAL
  2767 	return SourceHook::ExecutableClass4<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4>(CCW<Y>::GRP(ptr),
  2768 		mfp, vfnptr, shptr, plug);
  2769 }
  2770 
  2771 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4>
  2772 SourceHook::ExecutableClass4<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4>
  2773 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, ...)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2774 {
  2775 	SH__CALL_GET_VFNPTR_NORMAL
  2776 	return SourceHook::ExecutableClass4<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4>(CCW<Y>::GRP(ptr),
  2777 		mfp, vfnptr, shptr, plug);
  2778 }
  2779 
  2780 
  2781 // Support for 5 arguments
  2782 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
  2783 SourceHook::ExecutableClass5<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5>
  2784 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2785 {
  2786 	SH__CALL_GET_VFNPTR_NORMAL
  2787 	return SourceHook::ExecutableClass5<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5>(CCW<Y>::GRP(ptr),
  2788 		mfp, vfnptr, shptr, plug);
  2789 }
  2790 
  2791 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
  2792 SourceHook::ExecutableClass5<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5>
  2793 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2794 {
  2795 	SH__CALL_GET_VFNPTR_NORMAL
  2796 	return SourceHook::ExecutableClass5<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5>(CCW<Y>::GRP(ptr),
  2797 		mfp, vfnptr, shptr, plug);
  2798 }
  2799 
  2800 
  2801 // Support for 6 arguments
  2802 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  2803 SourceHook::ExecutableClass6<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>
  2804 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2805 {
  2806 	SH__CALL_GET_VFNPTR_NORMAL
  2807 	return SourceHook::ExecutableClass6<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>(CCW<Y>::GRP(ptr),
  2808 		mfp, vfnptr, shptr, plug);
  2809 }
  2810 
  2811 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  2812 SourceHook::ExecutableClass6<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>
  2813 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2814 {
  2815 	SH__CALL_GET_VFNPTR_NORMAL
  2816 	return SourceHook::ExecutableClass6<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6>(CCW<Y>::GRP(ptr),
  2817 		mfp, vfnptr, shptr, plug);
  2818 }
  2819 
  2820 
  2821 // Support for 7 arguments
  2822 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  2823 SourceHook::ExecutableClass7<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
  2824 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2825 {
  2826 	SH__CALL_GET_VFNPTR_NORMAL
  2827 	return SourceHook::ExecutableClass7<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>(CCW<Y>::GRP(ptr),
  2828 		mfp, vfnptr, shptr, plug);
  2829 }
  2830 
  2831 template <class X, class Y, class MFP, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  2832 SourceHook::ExecutableClass7<typename SourceHook::CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>
  2833 SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
  2834 {
  2835 	SH__CALL_GET_VFNPTR_NORMAL
  2836 	return SourceHook::ExecutableClass7<typename CCW<Y>::type, MFP, RetType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>(CCW<Y>::GRP(ptr),
  2837 		mfp, vfnptr, shptr, plug);
  2838 }
  2839 
  2840 
  2841 
  2842 #endif
  2843 
  2844 #define SH_CALL(ptr, mfp) SH_CALL2((ptr), (mfp), (mfp), SH_GLOB_SHPTR, SH_GLOB_PLUGPTR)
  2845 #define SH_MCALL2(ptr, mfp, vtblidx, vtbloffs, thisptroffs) SH_MCALL3((ptr), (mfp), (mfp), (vtblidx), (vtbloffs), (thisptroffs), SH_GLOB_SHPTR, SH_GLOB_PLUGPTR)
  2846 #define SH_MCALL(ptr, mhookname) SH_MCALL2((ptr), SH_MFHCls(mhookname)::ECMFP(), SH_MFHCls(mhookname)::ms_MFI.vtblindex, \
  2847 	SH_MFHCls(mhookname)::ms_MFI.vtbloffs, SH_MFHCls(mhookname)::ms_MFI.thisptroffs)
  2848 
  2849 #undef SH_MAKE_EXECUTABLECLASS_OB
  2850 
  2851 //////////////////////////////////////////////////////////////////////////
  2852 // SetOverrideRet and RecallGetIface for recalls
  2853 // These take a ISourceHook pointer instead of using SH_GLOB_SHPTR directly
  2854 // The reason is that the user may want to redefine SH_GLOB_SHPTR - then the macros
  2855 // (META_RETURN_VALUE_NEWPARAMS) should obey the new pointer.
  2856 
  2857 namespace SourceHook
  2858 {
  2859 	template <class RetType>
  2860 	void SetOverrideResult(ISourceHook *shptr, const RetType res)
  2861 	{
  2862 		*reinterpret_cast<RetType*>(shptr->GetOverrideRetPtr()) = res;
  2863 	}
  2864 
  2865 	// SetOverrideResult used to be implemented like this:
  2866 	//  SetOverrideResult(shptr, memfuncptr, return);
  2867 	//  normally the compiler can deduce the return type from memfuncptr, but (at least msvc8) failed when it was a reference
  2868 	//  (it thought it was ambigous - the ref and non-ref type)
  2869 	//  so now SetOverrideResult(memfuncptr) deduces the ret type, and returns a functor which does the work
  2870 	//  new syntax: SetOverrideResult(memfuncptr)(shptr, return)
  2871 	// This also allows us to create a special version for references which respects ReferenceCarrier.
  2872 
  2873 	template <class T> struct OverrideFunctor
  2874 	{
  2875 		void operator()(ISourceHook *shptr, T res)
  2876 		{
  2877 			*reinterpret_cast<T*>(shptr->GetOverrideRetPtr()) = res;
  2878 		}
  2879 	};
  2880 	template <class T> struct OverrideFunctor<T&>
  2881 	{
  2882 		void operator()(ISourceHook *shptr, T &res)
  2883 		{
  2884 			// overrideretptr points to ReferenceCarrier<T&>
  2885 			*reinterpret_cast<typename ReferenceCarrier<T&>::type *>(shptr->GetOverrideRetPtr()) = res;
  2886 		}
  2887 	};
  2888 
  2889 	template <class Iface, class RetType>
  2890 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)())
  2891 	{
  2892 		return OverrideFunctor<RetType>();
  2893 	}
  2894 
  2895 	template <class Iface, class RetType>
  2896 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)())
  2897 	{
  2898 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
  2899 	}
  2900 
  2901 	template <class Iface, class RetType, class Param1>
  2902 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1))
  2903 	{
  2904 		return OverrideFunctor<RetType>();
  2905 	}
  2906 
  2907 	template <class Iface, class RetType, class Param1>
  2908 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1))
  2909 	{
  2910 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
  2911 	}
  2912 
  2913 	template <class Iface, class RetType, class Param1, class Param2>
  2914 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2))
  2915 	{
  2916 		return OverrideFunctor<RetType>();
  2917 	}
  2918 
  2919 	template <class Iface, class RetType, class Param1, class Param2>
  2920 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2))
  2921 	{
  2922 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
  2923 	}
  2924 
  2925 	template <class Iface, class RetType, class Param1, class Param2, class Param3>
  2926 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3))
  2927 	{
  2928 		return OverrideFunctor<RetType>();
  2929 	}
  2930 
  2931 	template <class Iface, class RetType, class Param1, class Param2, class Param3>
  2932 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3))
  2933 	{
  2934 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
  2935 	}
  2936 
  2937 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
  2938 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4))
  2939 	{
  2940 		return OverrideFunctor<RetType>();
  2941 	}
  2942 
  2943 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4>
  2944 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4))
  2945 	{
  2946 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
  2947 	}
  2948 
  2949 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
  2950 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5))
  2951 	{
  2952 		return OverrideFunctor<RetType>();
  2953 	}
  2954 
  2955 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
  2956 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5))
  2957 	{
  2958 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
  2959 	}
  2960 
  2961 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  2962 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6))
  2963 	{
  2964 		return OverrideFunctor<RetType>();
  2965 	}
  2966 
  2967 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  2968 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6))
  2969 	{
  2970 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
  2971 	}
  2972 
  2973 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  2974 	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2975 	{
  2976 		return OverrideFunctor<RetType>();
  2977 	}
  2978 
  2979 	template <class Iface, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  2980 	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7))
  2981 	{
  2982 		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
  2983 	}
  2984 
  2985 }
  2986 
  2987 #endif
  2988 	// The pope is dead. -> :(