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