core-legacy/sourcehook/generate/sourcehook.hxx
author David Anderson <dvander@alliedmods.net>
Sat Oct 15 22:16:50 2011 -0700 (2011-10-15)
changeset 767 fd3ff8d792ce
parent 696 9a569e62130d
permissions -rwxr-xr-x
Fix page protection bug causing a rare startup crash (bug 5133, r=fyren).
dvander@541
     1
/* ======== SourceHook ========
dvander@659
     2
* Copyright (C) 2004-2007 Metamod:Source Development Team
dvander@541
     3
* No warranties of any kind
dvander@541
     4
*
dvander@541
     5
* License: zlib/libpng
dvander@541
     6
*
dvander@541
     7
* Author(s): Pavol "PM OnoTo" Marko
dvander@541
     8
* ============================
dvander@541
     9
*/
dvander@541
    10
dvander@541
    11
/**
dvander@541
    12
*	@file sourcehook.h
dvander@541
    13
*	@brief Contains the public SourceHook API
dvander@541
    14
*/
dvander@541
    15
dvander@541
    16
#ifndef __SOURCEHOOK_H__
dvander@541
    17
#define __SOURCEHOOK_H__
dvander@541
    18
dvander@541
    19
// Interface revisions:
dvander@541
    20
//  1 - Initial revision
dvander@541
    21
//  2 - Changed to virtual functions for iterators and all queries
dvander@541
    22
//  3 - Added "hook loop status variable"
dvander@541
    23
//  4 - Reentrant
dvander@541
    24
#define SH_IFACE_VERSION 4
dvander@659
    25
dvander@659
    26
// Impl versions:
dvander@659
    27
// ???
dvander@659
    28
// 4 - addition of hook ids and vp hooks (with them, AddHookNew and RemoveHookNew)
dvander@659
    29
//     This is not a SH_IFACE_VERSION change so that old plugins continue working!
dvander@659
    30
// 5 - addition of direct vp hooks (new hook mode; from now on AddHookNew checks for
dvander@659
    31
//	   invalid hookmode -> impl version won't have to change because of things like this)
dvander@659
    32
#define SH_IMPL_VERSION 5
dvander@541
    33
dvander@541
    34
// Hookman version:
dvander@541
    35
//  1 - Support for recalls, performance optimisations
dvander@541
    36
#define SH_HOOKMAN_VERSION 1
dvander@541
    37
dvander@541
    38
// The value of SH_GLOB_SHPTR has to be a pointer to SourceHook::ISourceHook
dvander@541
    39
// It's used in various macros
dvander@541
    40
#ifndef SH_GLOB_SHPTR
dvander@541
    41
#define SH_GLOB_SHPTR g_SHPtr
dvander@541
    42
#endif
dvander@541
    43
dvander@541
    44
// Used to identify the current plugin
dvander@541
    45
#ifndef SH_GLOB_PLUGPTR
dvander@541
    46
#define SH_GLOB_PLUGPTR g_PLID
dvander@541
    47
#endif
dvander@541
    48
dvander@541
    49
#ifdef SH_DEBUG
dvander@541
    50
# include <stdio.h>
dvander@541
    51
# include <stdlib.h>
dvander@541
    52
dvander@541
    53
# define SH_ASSERT(x, info) \
dvander@541
    54
	do { \
dvander@541
    55
		if (!(x)) \
dvander@541
    56
		{ \
dvander@541
    57
			printf("SOURCEHOOK DEBUG ASSERTION FAILED: %s:%u(%s): %s: ", __FILE__, __LINE__, __FUNCTION__, #x); \
dvander@541
    58
			printf info; \
dvander@541
    59
			putchar('\n'); \
dvander@541
    60
			abort(); \
dvander@541
    61
		} \
dvander@541
    62
	} while(0)
dvander@541
    63
dvander@541
    64
#else
dvander@541
    65
# define SH_ASSERT(x, info)
dvander@541
    66
#endif
dvander@541
    67
dvander@541
    68
// System
dvander@541
    69
#define SH_SYS_WIN32 1
dvander@541
    70
#define SH_SYS_LINUX 2
dvander@541
    71
dvander@541
    72
#ifdef _WIN32
dvander@541
    73
# define SH_SYS SH_SYS_WIN32
dvander@541
    74
#elif defined __linux__
dvander@541
    75
# define SH_SYS SH_SYS_LINUX
dvander@541
    76
#else
dvander@541
    77
# error Unsupported system
dvander@541
    78
#endif
dvander@541
    79
dvander@541
    80
// Compiler
dvander@541
    81
#define SH_COMP_GCC 1
dvander@541
    82
#define SH_COMP_MSVC 2
dvander@541
    83
dvander@541
    84
#ifdef _MSC_VER
dvander@541
    85
# define SH_COMP SH_COMP_MSVC
dvander@541
    86
#elif defined __GNUC__
dvander@541
    87
# define SH_COMP SH_COMP_GCC
dvander@541
    88
#else
dvander@541
    89
# error Unsupported compiler
dvander@541
    90
#endif
dvander@541
    91
ds@680
    92
#if SH_COMP==SH_COMP_MSVC && _MSC_VER < 1500
dvander@541
    93
# define vsnprintf _vsnprintf
dvander@541
    94
#endif
dvander@541
    95
dvander@541
    96
#if SH_SYS != SH_SYS_WIN32
dvander@541
    97
# include <unistd.h>
dvander@541
    98
#endif
dvander@541
    99
dvander@541
   100
#define SH_PTRSIZE sizeof(void*)
dvander@541
   101
dvander@541
   102
#include "FastDelegate.h"
dvander@541
   103
#include "sh_memfuncinfo.h"
dvander@541
   104
dvander@541
   105
// Good old metamod!
dvander@541
   106
dvander@541
   107
// Flags returned by a plugin's api function.
dvander@541
   108
// NOTE: order is crucial, as greater/less comparisons are made.
dvander@541
   109
enum META_RES
dvander@541
   110
{
dvander@541
   111
	MRES_IGNORED=0,		// plugin didn't take any action
dvander@541
   112
	MRES_HANDLED,		// plugin did something, but real function should still be called
dvander@541
   113
	MRES_OVERRIDE,		// call real function, but use my return value
dvander@541
   114
	MRES_SUPERCEDE		// skip real function; use my return value
dvander@541
   115
};
dvander@541
   116
dvander@541
   117
dvander@541
   118
namespace SourceHook
dvander@541
   119
{
dvander@541
   120
	/**
dvander@541
   121
	*	@brief	Specifies the size (in bytes) for the internal buffer of vafmt(printf-like) function handlers
dvander@541
   122
	*/
dvander@541
   123
	const int STRBUF_LEN=4096;
dvander@541
   124
dvander@541
   125
	/**
dvander@541
   126
	*	@brief	An empty class. No inheritance used. Used for original-function-call hacks
dvander@541
   127
	*/
dvander@541
   128
	class EmptyClass
dvander@541
   129
	{
dvander@541
   130
	};
dvander@541
   131
dvander@541
   132
	/**
dvander@541
   133
	*	@brief Implicit cast.
dvander@541
   134
	*/
dvander@541
   135
	template <class In, class Out>
dvander@541
   136
		inline Out implicit_cast(In input)
dvander@541
   137
		{
dvander@541
   138
			return input;
dvander@541
   139
		}
dvander@541
   140
dvander@541
   141
	/**
dvander@541
   142
	*	@brief A plugin typedef
dvander@541
   143
	*
dvander@541
   144
	*	SourceHook doesn't really care what this is. As long as the ==, != and = operators work on it and every
dvander@541
   145
	*	plugin has a unique identifier, everything is ok.
dvander@541
   146
	*	It should also be possible to set it to 0.
dvander@541
   147
	*/
dvander@541
   148
	typedef int Plugin;
dvander@541
   149
dvander@541
   150
	struct ProtoInfo
dvander@541
   151
	{
dvander@541
   152
		ProtoInfo(int rtsz, int nop, const int *p) : beginningNull(0), retTypeSize(rtsz), numOfParams(nop), params(p)
dvander@541
   153
		{
dvander@541
   154
		}
dvander@541
   155
		int beginningNull;		//!< To distinguish from old protos (which never begin with 0)
dvander@541
   156
		int retTypeSize;		//!< 0 if void
dvander@541
   157
		int numOfParams;		//!< number of parameters
dvander@541
   158
		const int *params;		//!< params[0]=0 (or -1 for vararg), params[1]=size of first param, ...
dvander@541
   159
	};
dvander@541
   160
dvander@541
   161
	/**
dvander@541
   162
	*	@brief Specifies the actions for hook managers
dvander@541
   163
	*/
dvander@541
   164
	enum HookManagerAction
dvander@541
   165
	{
dvander@541
   166
		HA_GetInfo = 0,			//!< Store info about the hook manager
dvander@541
   167
		HA_Register,			//!< Save the IHookManagerInfo pointer for future reference
dvander@541
   168
		HA_Unregister			//!< Clear the saved pointer
dvander@541
   169
	};
dvander@541
   170
dvander@541
   171
	struct IHookManagerInfo;
dvander@541
   172
dvander@541
   173
	/**
dvander@541
   174
	*	@brief Pointer to hook manager interface function
dvander@541
   175
	*
dvander@541
   176
	*	A "hook manager" is a the only thing that knows the actual protoype of the function at compile time.
dvander@541
   177
	*
dvander@541
   178
	*   @param ha What the hook manager should do
dvander@541
   179
	*	@param hi A pointer to IHookManagerInfo
dvander@541
   180
	*/
dvander@541
   181
	typedef int (*HookManagerPubFunc)(HookManagerAction ha, IHookManagerInfo *hi);
dvander@541
   182
dvander@541
   183
	class ISHDelegate
dvander@541
   184
	{
dvander@541
   185
	public:
dvander@541
   186
		virtual void DeleteThis() = 0;				// Ugly, I know
dvander@541
   187
		virtual bool IsEqual(ISHDelegate *other) = 0;
dvander@541
   188
	};
dvander@541
   189
dvander@541
   190
	template <class T> class CSHDelegate : public ISHDelegate
dvander@541
   191
	{
dvander@541
   192
		T m_Deleg;
dvander@541
   193
	public:
dvander@541
   194
		CSHDelegate(T deleg) : m_Deleg(deleg)
dvander@541
   195
		{
dvander@541
   196
		}
dvander@541
   197
dvander@541
   198
		CSHDelegate(const CSHDelegate &other) : m_Deleg(other.m_Deleg)
dvander@541
   199
		{
dvander@541
   200
		}
dvander@541
   201
dvander@541
   202
		void DeleteThis()
dvander@541
   203
		{
dvander@541
   204
			delete this;
dvander@541
   205
		}
dvander@541
   206
dvander@541
   207
		bool IsEqual(ISHDelegate *other)
dvander@541
   208
		{
dvander@541
   209
			return static_cast<CSHDelegate<T>* >(other)->GetDeleg() == GetDeleg();
dvander@541
   210
		}
dvander@541
   211
dvander@541
   212
		T &GetDeleg()
dvander@541
   213
		{
dvander@541
   214
			return m_Deleg;
dvander@541
   215
		}
dvander@541
   216
	};
dvander@541
   217
dvander@541
   218
	struct IHookList
dvander@541
   219
	{
dvander@541
   220
		struct IIter
dvander@541
   221
		{
dvander@541
   222
			virtual bool End() = 0;
dvander@541
   223
			virtual void Next() = 0;
dvander@541
   224
			virtual ISHDelegate *Handler() = 0;
dvander@541
   225
			virtual int ThisPtrOffs() = 0;
dvander@541
   226
		};
dvander@541
   227
		virtual IIter *GetIter() = 0;
dvander@541
   228
		virtual void ReleaseIter(IIter *pIter) = 0;
dvander@541
   229
	};
dvander@541
   230
dvander@541
   231
	struct IIface
dvander@541
   232
	{
dvander@541
   233
		virtual void *GetPtr() = 0;
dvander@541
   234
		virtual IHookList *GetPreHooks() = 0;
dvander@541
   235
		virtual IHookList *GetPostHooks() = 0;
dvander@541
   236
	};
dvander@541
   237
dvander@541
   238
	struct IVfnPtr
dvander@541
   239
	{
dvander@541
   240
		virtual void *GetVfnPtr() = 0;
dvander@541
   241
		virtual void *GetOrigEntry() = 0;
dvander@541
   242
dvander@541
   243
		virtual IIface *FindIface(void *ptr) = 0;
dvander@541
   244
	};
dvander@541
   245
dvander@541
   246
	struct IHookManagerInfo
dvander@541
   247
	{
dvander@541
   248
		virtual IVfnPtr *FindVfnPtr(void *vfnptr) = 0;
dvander@541
   249
dvander@541
   250
		virtual void SetInfo(int vtbloffs, int vtblidx, const char *proto) = 0;
dvander@541
   251
		virtual void SetHookfuncVfnptr(void *hookfunc_vfnptr) = 0;
dvander@541
   252
dvander@541
   253
		// Added 23.12.2005 (yup! I'm coding RIGHT BEFORE CHRISTMAS!)
dvander@541
   254
		// If the hookman doesn't set this, it defaults 0
dvander@541
   255
		// SourceHook prefers hookmans with higher version numbers
dvander@541
   256
		virtual void SetVersion(int version) = 0;
dvander@541
   257
	};
dvander@541
   258
dvander@541
   259
	class AutoHookIter
dvander@541
   260
	{
dvander@541
   261
		IHookList *m_pList;
dvander@541
   262
		IHookList::IIter *m_pIter;
dvander@541
   263
	public:
dvander@541
   264
		AutoHookIter(IHookList *pList)
dvander@541
   265
			: m_pList(pList), m_pIter(pList->GetIter())
dvander@541
   266
		{
dvander@541
   267
		}
dvander@541
   268
dvander@541
   269
		~AutoHookIter()
dvander@541
   270
		{
dvander@541
   271
			if (m_pList)
dvander@541
   272
				m_pList->ReleaseIter(m_pIter);
dvander@541
   273
		}
dvander@541
   274
dvander@541
   275
		bool End()
dvander@541
   276
		{
dvander@541
   277
			return m_pIter->End();
dvander@541
   278
		}
dvander@541
   279
dvander@541
   280
		void Next()
dvander@541
   281
		{
dvander@541
   282
			m_pIter->Next();
dvander@541
   283
		}
dvander@541
   284
dvander@541
   285
		ISHDelegate *Handler()
dvander@541
   286
		{
dvander@541
   287
			return m_pIter->Handler();
dvander@541
   288
		}
dvander@541
   289
dvander@541
   290
		int ThisPtrOffs()
dvander@541
   291
		{
dvander@541
   292
			return m_pIter->ThisPtrOffs();
dvander@541
   293
		}
dvander@541
   294
dvander@541
   295
		void SetToZero()
dvander@541
   296
		{
dvander@541
   297
			m_pList = 0;
dvander@541
   298
		}
dvander@541
   299
	};
dvander@541
   300
dvander@659
   301
	template<class B> struct DeprecatedCallClass
dvander@541
   302
	{
dvander@541
   303
		virtual B *GetThisPtr() = 0;
dvander@541
   304
		virtual void *GetOrigFunc(int vtbloffs, int vtblidx) = 0;
dvander@541
   305
	};
dvander@541
   306
dvander@541
   307
	// 09.08.2008 (6 AM, I just woke up, the others are still sleeping so i finally can use this notebook !!)
dvander@541
   308
	// - Today is an important day.
dvander@541
   309
	// I'm adding support for functions which return references.
dvander@541
   310
dvander@541
   311
	// How it works:
dvander@541
   312
	//  SH_SETUPCALLS doesn't use plain rettype to store the temporary return values (plugin ret, orig ret,
dvander@541
   313
	//  override ret) anymore; instead, it uses SourceHook::ReferenceCarrier<rettype>::type
dvander@541
   314
	//  this is typedefed to the original rettype normally, but if the rettype is a reference, it's a special class
dvander@541
   315
	//  which stores the reference as a pointer, and implements constructors, operator= and a conversion operator.
dvander@541
   316
	//  special cases were needed for getoverrideret / getorigret; these are implemented through the
dvander@541
   317
	//  SourceHook::MacroRefHelpers structs.
dvander@541
   318
	//  Furthermore, SetOverrideRet had to be changed a bit; see SourceHook::OverrideFunctor somewhere down in this file.
dvander@541
   319
	template <class T> struct ReferenceCarrier
dvander@541
   320
	{
dvander@541
   321
		typedef T type;
dvander@541
   322
	};
dvander@541
   323
dvander@541
   324
	template <class T> struct ReferenceCarrier<T&>
dvander@541
   325
	{
dvander@541
   326
		class type
dvander@541
   327
		{
dvander@541
   328
			T *m_StoredRef;
dvander@541
   329
		public:
dvander@541
   330
			type() : m_StoredRef(NULL)
dvander@541
   331
			{
dvander@541
   332
			}
dvander@541
   333
			type(T& ref) : m_StoredRef(&ref)
dvander@541
   334
			{
dvander@541
   335
			}
dvander@541
   336
dvander@541
   337
			T& operator= (T& ref)
dvander@541
   338
			{
dvander@541
   339
				m_StoredRef = &ref;
dvander@541
   340
				return ref;
dvander@541
   341
			}
dvander@541
   342
dvander@541
   343
			operator T& () const
dvander@541
   344
			{
dvander@541
   345
				return *m_StoredRef;
dvander@541
   346
			}
dvander@541
   347
		};
dvander@541
   348
	};
dvander@541
   349
dvander@541
   350
	/**
dvander@541
   351
	*	@brief The main SourceHook interface
dvander@541
   352
	*/
dvander@541
   353
	class ISourceHook
dvander@541
   354
	{
dvander@541
   355
	public:
dvander@541
   356
		/**
dvander@541
   357
		*	@brief Return interface version
dvander@541
   358
		*/
dvander@541
   359
		virtual int GetIfaceVersion() = 0;
dvander@541
   360
dvander@541
   361
		/**
dvander@541
   362
		*	@brief Return implementation version
dvander@541
   363
		*/
dvander@541
   364
		virtual int GetImplVersion() = 0;
dvander@541
   365
dvander@541
   366
		/**
dvander@541
   367
		*	@brief Add a hook.
dvander@541
   368
		*
dvander@541
   369
		*	@return True if the function succeeded, false otherwise
dvander@541
   370
		*
dvander@541
   371
		*	@param plug The unique identifier of the plugin that calls this function
dvander@541
   372
		*	@param iface The interface pointer
dvander@541
   373
		*	@param ifacesize The size of the class iface points to
dvander@541
   374
		*	@param myHookMan A hook manager function that should be capable of handling the function
dvander@541
   375
		*	@param handler A pointer to a FastDelegate containing the hook handler
dvander@541
   376
		*	@param post Set to true if you want a post handler
dvander@541
   377
		*/
dvander@541
   378
		virtual bool AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
dvander@541
   379
			ISHDelegate *handler, bool post) = 0;
dvander@541
   380
dvander@541
   381
		/**
dvander@541
   382
		*	@brief Removes a hook.
dvander@541
   383
		*
dvander@541
   384
		*	@return True if the function succeeded, false otherwise
dvander@541
   385
		*
dvander@541
   386
		*	@param plug The unique identifier of the plugin that calls this function
dvander@541
   387
		*	@param iface The interface pointer
dvander@541
   388
		*	@param myHookMan A hook manager function that should be capable of handling the function
dvander@541
   389
		*	@param handler A pointer to a FastDelegate containing the hook handler
dvander@541
   390
		*	@param post Set to true if you want a post handler
dvander@541
   391
		*/
dvander@541
   392
		virtual bool RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
dvander@541
   393
			ISHDelegate *handler, bool post) = 0;
dvander@541
   394
dvander@541
   395
		/**
dvander@541
   396
		*	@brief Checks whether a plugin has (a) hook manager(s) that is/are currently used by other plugins
dvander@541
   397
		*
dvander@541
   398
		*	@param plug The unique identifier of the plugin in question
dvander@541
   399
		*/
dvander@541
   400
		virtual bool IsPluginInUse(Plugin plug) = 0;
dvander@541
   401
dvander@541
   402
		/**
dvander@541
   403
		*	@brief Return a pointer to a callclass. Generate a new one if required.
dvander@541
   404
		*
dvander@541
   405
		*	@param iface The interface pointer
dvander@541
   406
		*	@param size Size of the class instance
dvander@541
   407
		*/
dvander@659
   408
		virtual DeprecatedCallClass<void> *GetCallClass(void *iface, size_t size) = 0;
dvander@541
   409
dvander@541
   410
		/**
dvander@541
   411
		*	@brief Release a callclass
dvander@541
   412
		*
dvander@541
   413
		*	@param ptr Pointer to the callclass
dvander@541
   414
		*/
dvander@659
   415
		virtual void ReleaseCallClass(DeprecatedCallClass<void> *ptr) = 0;
dvander@541
   416
dvander@541
   417
		virtual void SetRes(META_RES res) = 0;				//!< Sets the meta result
dvander@541
   418
		virtual META_RES GetPrevRes() = 0;					//!< Gets the meta result of the
dvander@541
   419
															//!<  previously calledhandler
dvander@541
   420
		virtual META_RES GetStatus() = 0;					//!< Gets the highest meta result
dvander@541
   421
		virtual const void *GetOrigRet() = 0;				//!< Gets the original result.
dvander@541
   422
															//!<  If not in post function, undefined
dvander@541
   423
		virtual const void *GetOverrideRet() = 0;			//!< Gets the override result.
dvander@541
   424
															//!<  If none is specified, NULL
dvander@541
   425
		virtual void *GetIfacePtr() = 0;					//!< Gets the interface pointer
dvander@541
   426
		//////////////////////////////////////////////////////////////////////////
dvander@541
   427
		// For hook managers
dvander@541
   428
		virtual void HookLoopBegin(IIface *pIface) = 0;			//!< Should be called when a hook loop begins
dvander@541
   429
		virtual void HookLoopEnd() = 0;							//!< Should be called when a hook loop exits
dvander@541
   430
		virtual void SetCurResPtr(META_RES *mres) = 0;			//!< Sets pointer to the current meta result
dvander@541
   431
		virtual void SetPrevResPtr(META_RES *mres) = 0;			//!< Sets pointer to previous meta result
dvander@541
   432
		virtual void SetStatusPtr(META_RES *mres) = 0;			//!< Sets pointer to the status variable
dvander@541
   433
		virtual void SetIfacePtrPtr(void **pp) = 0;				//!< Sets pointer to the interface this pointer
dvander@541
   434
		virtual void SetOrigRetPtr(const void *ptr) = 0;		//!< Sets the original return pointer
dvander@541
   435
		virtual void SetOverrideRetPtr(void *ptr) = 0;			//!< Sets the override result pointer
dvander@541
   436
		virtual bool ShouldContinue() = 0;						//!< Returns false if the hook loop should exit
dvander@541
   437
dvander@541
   438
		/**
dvander@541
   439
		*	@brief Remove a hook manager. Auto-removes all hooks attached to it from plugin plug.
dvander@541
   440
		*
dvander@541
   441
		*	@param plug The owner of the hook manager
dvander@541
   442
		*   @param pubFunc The hook manager's info function
dvander@541
   443
		*/
dvander@541
   444
		virtual void RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc) = 0;
dvander@541
   445
dvander@541
   446
		virtual void DoRecall() = 0;							//!< Initiates a recall sequence
dvander@541
   447
		/*
dvander@541
   448
			HOW RECALLS WORK:
dvander@541
   449
			
dvander@541
   450
			The problem:
dvander@541
   451
				Users want the ability to change parameters of the called function
dvander@541
   452
				from inside their handler.
dvander@541
   453
			The solution:
dvander@541
   454
				1) Mark as "recall"
dvander@541
   455
				2) Recall the function
dvander@541
   456
				3) => SH's hook func gets called:
dvander@541
   457
				  4) The first iterator points at the first hook the last hookfunc didn't execute yet
dvander@541
   458
				  5) does all iteration and returns normally
dvander@541
   459
		        6) The user's handler returns immediately
dvander@541
   460
				7) The hook func returns immediately as well
dvander@541
   461
dvander@541
   462
				Also note that the recalled hookfunc starts with the status the recalling hookfunc
dvander@541
   463
				ended with. The last handler (doing the recall) is also able to specify its own
dvander@541
   464
				META_RES.
dvander@541
   465
		*/
dvander@541
   466
dvander@541
   467
		virtual void *GetOverrideRetPtr() = 0;		//!< Returns the pointer set by SetOverrideRetPtr
dvander@541
   468
dvander@541
   469
		/**
dvander@541
   470
		*	@brief Set up the hook loop. Equivalent to calling:
dvander@541
   471
		*	SetStatusPtr, SetPrevResPtr, SetCurResPtr, SetIfacePtrPtr, SetOrigRetPtr, Get/SetOverrideRetPtr
dvander@541
   472
		*
dvander@541
   473
		*	@param statusPtr		pointer to status variable
dvander@541
   474
		*	@param prevResPtr		pointer to previous result variable
dvander@541
   475
		*	@param curResPtr		pointer to current result variable
dvander@541
   476
		*	@param ifacePtrPtr		pointer to interface this pointer variable
dvander@541
   477
		*	@param origRetPr		pointer to original return value variable. NULL for void funcs
dvander@541
   478
		*	@param overrideRetPtr	pointer to override return value variable. NULL for void funcs
dvander@541
   479
		*	
dvander@541
   480
		*	@return Override Return Pointer the hookfunc should use (may differ from overrideRetPtr
dvander@541
   481
		*		when the hook func is being called as part of a recall
dvander@541
   482
		*/
dvander@541
   483
		virtual void *SetupHookLoop(META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr,
dvander@541
   484
			void **ifacePtrPtr, const void *origRetPtr, void *overrideRetPtr) = 0;
dvander@541
   485
dvander@659
   486
		/**
dvander@659
   487
		*	@brief Modes for the new AddHook
dvander@659
   488
		*/
dvander@659
   489
		enum AddHookMode
dvander@659
   490
		{
dvander@659
   491
			Hook_Normal,
dvander@659
   492
			Hook_VP,
dvander@659
   493
			Hook_DVP
dvander@659
   494
		}; 
dvander@659
   495
dvander@659
   496
		/**
dvander@659
   497
		*	@brief Add a (VP) hook.
dvander@659
   498
		*
dvander@659
   499
		*	@return non-zero hook id on success, 0 otherwise
dvander@659
   500
		*
dvander@659
   501
		*	@param plug The unique identifier of the plugin that calls this function
dvander@659
   502
		*	@param mode	Can be either Hook_Normal or Hook_VP (vtable-wide hook)
dvander@659
   503
		*	@param iface The interface pointer
dvander@659
   504
		*	@param ifacesize The size of the class iface points to
dvander@659
   505
		*	@param myHookMan A hook manager function that should be capable of handling the function
dvander@659
   506
		*	@param handler A pointer to a FastDelegate containing the hook handler
dvander@659
   507
		*	@param post Set to true if you want a post handler
dvander@659
   508
		*/
dvander@659
   509
		virtual int AddHookNew(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
dvander@659
   510
			ISHDelegate *handler, bool post) = 0;
dvander@659
   511
dvander@659
   512
		/**
dvander@659
   513
		*	@brief Remove a VP hook by ID.
dvander@659
   514
		*
dvander@659
   515
		*	@return true on success, false otherwise
dvander@659
   516
		*
dvander@659
   517
		*	@param plug The unique identifier of the plugin that calls this function
dvander@659
   518
		*	@param hookid The hook id (returned by AddHookNew)
dvander@659
   519
		*/
dvander@659
   520
		virtual bool RemoveHookByID(Plugin plug, int hookid) = 0;
dvander@659
   521
dvander@659
   522
		/**
dvander@659
   523
		*	@brief Makes sure that hooks are going to be ignored on the next call of vfnptr
dvander@659
   524
		*
dvander@659
   525
		*	@param plug The unique identifier of the plugin that calls this function
dvander@659
   526
		*	@param vfnptr The virtual function pointer of the function in question
dvander@659
   527
		*/
dvander@659
   528
		virtual void SetIgnoreHooks(Plugin plug, void *vfnptr) = 0;
dvander@659
   529
dvander@659
   530
		/**
dvander@659
   531
		*	@brief Reverses SetIgnoreHooks' effect
dvander@659
   532
		*
dvander@659
   533
		*	@param plug The unique identifier of the plugin that calls this function
dvander@659
   534
		*	@param vfnptr The virtual function pointer of the function in question
dvander@659
   535
		*/
dvander@659
   536
		virtual void ResetIgnoreHooks(Plugin plug, void *vfnptr) = 0;
dvander@659
   537
dvander@659
   538
		/**
dvander@659
   539
		*	@brief Finds the original entry of a virtual function pointer
dvander@659
   540
		*
dvander@659
   541
		*	@param vfnptr The virtual function pointer
dvander@659
   542
		*	@return The original entry if the virtual function pointer has been patched; NULL otherwise.
dvander@659
   543
		*/
dvander@659
   544
		virtual void *GetOrigVfnPtrEntry(void *vfnptr) = 0;
dvander@541
   545
	};
dvander@541
   546
dvander@541
   547
	// For META_RESULT_ORIG_RET and META_RESULT_OVERRIDE_RET:
dvander@541
   548
	//  These have to be able to return references. If T is a reference, the pointers returned
dvander@541
   549
	//  from the SH_GLOB_SHPTR are pointers to instances of ReferenceCarrier<T>::type.
dvander@541
   550
	template <class T> struct MacroRefHelpers
dvander@541
   551
	{
dvander@541
   552
		inline static const T* GetOrigRet(ISourceHook *shptr)
dvander@541
   553
		{
dvander@541
   554
			return reinterpret_cast<const T*>(shptr->GetOrigRet());
dvander@541
   555
		}
dvander@541
   556
		inline static const T* GetOverrideRet(ISourceHook *shptr)
dvander@541
   557
		{
dvander@541
   558
			return reinterpret_cast<const T*>(shptr->GetOverrideRet());
dvander@541
   559
		}
dvander@541
   560
	};
dvander@541
   561
dvander@541
   562
	template <class T> struct MacroRefHelpers<T&>
dvander@541
   563
	{
dvander@541
   564
		inline static T* GetOrigRet(ISourceHook *shptr)
dvander@541
   565
		{
dvander@541
   566
			T &ref = *reinterpret_cast<const typename ReferenceCarrier<T&>::type *>(shptr->GetOrigRet());
dvander@541
   567
			return &ref;
dvander@541
   568
		}
dvander@541
   569
		inline static T* GetOverrideRet(ISourceHook *shptr)
dvander@541
   570
		{
dvander@541
   571
			T &ref = *reinterpret_cast<const typename ReferenceCarrier<T&>::type *>(shptr->GetOverrideRet());
dvander@541
   572
			return &ref;
dvander@541
   573
		}
dvander@541
   574
	};
dvander@659
   575
dvander@659
   576
	// For source-level compatibility
dvander@659
   577
	template <class T> struct CallClass
dvander@659
   578
	{
dvander@659
   579
		T *ptr;
dvander@659
   580
dvander@659
   581
		CallClass(T *p) : ptr(p)
dvander@659
   582
		{
dvander@659
   583
		}
dvander@659
   584
dvander@659
   585
		operator T*()
dvander@659
   586
		{
dvander@659
   587
			return ptr;
dvander@659
   588
		}
dvander@659
   589
	};
dvander@659
   590
dvander@659
   591
	typedef CallClass<void> GenericCallClass;
dvander@659
   592
	typedef CallClass<EmptyClass> ManualCallClass;
dvander@659
   593
dvander@659
   594
	template <class T>
dvander@659
   595
	CallClass<T> *GetCallClass(T *p)
dvander@659
   596
	{
dvander@659
   597
		return new CallClass<T>(p);
dvander@659
   598
	}
dvander@659
   599
dvander@659
   600
	template <class T>
dvander@659
   601
	void ReleaseCallClass(CallClass<T> *p)
dvander@659
   602
	{
dvander@659
   603
		delete p;
dvander@659
   604
	}
dvander@659
   605
dvander@659
   606
	template <class X, class MFP>
dvander@659
   607
	void *GetOrigVfnPtrEntry(X *pInstance, MFP mfp, ISourceHook *pSH)
dvander@659
   608
	{
dvander@659
   609
		SourceHook::MemFuncInfo info = {true, -1, 0, 0};
dvander@659
   610
		SourceHook::GetFuncInfo(pInstance, mfp, info);
dvander@659
   611
dvander@659
   612
		void *vfnptr = reinterpret_cast<void*>(
dvander@659
   613
			*reinterpret_cast<void***>(reinterpret_cast<char*>(pInstance) + info.thisptroffs + info.vtbloffs) + info.vtblindex);
dvander@659
   614
dvander@659
   615
		void *origentry = pSH->GetOrigVfnPtrEntry(vfnptr);
dvander@659
   616
		
dvander@659
   617
		return origentry ? origentry : *reinterpret_cast<void**>(vfnptr);
dvander@659
   618
	}
dvander@541
   619
}
dvander@541
   620
dvander@541
   621
/************************************************************************/
dvander@541
   622
/* High level interface                                                 */
dvander@541
   623
/************************************************************************/
dvander@541
   624
#define META_RESULT_STATUS					SH_GLOB_SHPTR->GetStatus()
dvander@541
   625
#define META_RESULT_PREVIOUS				SH_GLOB_SHPTR->GetPrevRes()
dvander@541
   626
#define META_RESULT_ORIG_RET(type)			*SourceHook::MacroRefHelpers<type>::GetOrigRet(SH_GLOB_SHPTR)
dvander@541
   627
#define META_RESULT_OVERRIDE_RET(type)		*SourceHook::MacroRefHelpers<type>::GetOverrideRet(SH_GLOB_SHPTR)
dvander@541
   628
#define META_IFACEPTR(type)					reinterpret_cast<type*>(SH_GLOB_SHPTR->GetIfacePtr())
dvander@541
   629
dvander@541
   630
#define SET_META_RESULT(result)				SH_GLOB_SHPTR->SetRes(result)
dvander@541
   631
#define RETURN_META(result)					do { SET_META_RESULT(result); return; } while(0)
dvander@541
   632
#define RETURN_META_VALUE(result, value)	do { SET_META_RESULT(result); return (value); } while(0)
dvander@541
   633
dvander@541
   634
// If a hook on a function which returns a reference does not want to specify a return value,
dvander@541
   635
// it can use this macro.
dvander@541
   636
//   ONLY USE THIS WITH MRES_IGNORED AND MRES_HANDLED !!!
dvander@541
   637
#define RETURN_META_NOREF(result, rettype)	do { SET_META_RESULT(result); return reinterpret_cast<rettype>(*SH_GLOB_SHPTR); } while(0)
dvander@541
   638
dvander@541
   639
// only call these from the hook handlers directly!
dvander@541
   640
// :TODO: enforce it ?
dvander@541
   641
dvander@541
   642
// Why take a memfuncptr instead of iface and func when we have to deduce the iface anyway now?
dvander@541
   643
// Well, without it, there'd be no way to specify which overloaded version we want in _VALUE
dvander@541
   644
dvander@541
   645
// SourceHook::SetOverrideRet is defined later.
dvander@541
   646
#define RETURN_META_NEWPARAMS(result, memfuncptr, newparams) \
dvander@541
   647
	do { \
dvander@541
   648
		SET_META_RESULT(result); \
dvander@541
   649
		SH_GLOB_SHPTR->DoRecall(); \
dvander@541
   650
		(SourceHook::RecallGetIface(SH_GLOB_SHPTR, memfuncptr)->*(memfuncptr)) newparams; \
dvander@541
   651
		RETURN_META(MRES_SUPERCEDE); \
dvander@541
   652
	} while (0)
dvander@541
   653
dvander@541
   654
#define RETURN_META_VALUE_NEWPARAMS(result, value, memfuncptr, newparams) \
dvander@541
   655
	do { \
dvander@541
   656
		SET_META_RESULT(result); \
dvander@541
   657
		SH_GLOB_SHPTR->DoRecall(); \
dvander@541
   658
		if ((result) >= MRES_OVERRIDE) \
dvander@541
   659
		{ \
dvander@541
   660
			/* meh, set the override result here because we don't get a chance to return */ \
dvander@541
   661
			/* before continuing the hook loop through the recall */ \
dvander@541
   662
			SourceHook::SetOverrideResult(memfuncptr)(SH_GLOB_SHPTR, value); \
dvander@541
   663
		} \
dvander@541
   664
		RETURN_META_VALUE(MRES_SUPERCEDE, \
dvander@541
   665
			(SourceHook::RecallGetIface(SH_GLOB_SHPTR, memfuncptr)->*(memfuncptr)) newparams); \
dvander@541
   666
	} while (0)
dvander@541
   667
dvander@541
   668
// :TODO: thisptroffs in MNEWPARAMS ??
dvander@541
   669
dvander@541
   670
#if SH_COMP == SH_COMP_MSVC
dvander@541
   671
dvander@541
   672
#define SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname) \
dvander@541
   673
	union \
dvander@541
   674
	{ \
dvander@541
   675
		SH_MFHCls(hookname)::ECMFP mfp; \
dvander@541
   676
		void *addr; \
dvander@541
   677
	} u; \
dvander@541
   678
	SourceHook::EmptyClass *thisptr = reinterpret_cast<SourceHook::EmptyClass*>(SH_GLOB_SHPTR->GetIfacePtr()); \
dvander@541
   679
	u.addr = (*reinterpret_cast<void***>(reinterpret_cast<char*>(thisptr) + SH_MFHCls(hookname)::ms_MFI.vtbloffs))[ \
dvander@541
   680
		SH_MFHCls(hookname)::ms_MFI.vtblindex];
dvander@541
   681
dvander@541
   682
#elif SH_COMP == SH_COMP_GCC
dvander@541
   683
dvander@541
   684
#define SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname) \
dvander@541
   685
	union \
dvander@541
   686
	{ \
dvander@541
   687
		SH_MFHCls(hookname)::ECMFP mfp; \
dvander@541
   688
		struct \
dvander@541
   689
		{ \
dvander@541
   690
			void *addr; \
dvander@541
   691
			intptr_t adjustor; \
dvander@541
   692
		} s; \
dvander@541
   693
	} u; \
dvander@541
   694
	SourceHook::EmptyClass *thisptr = reinterpret_cast<SourceHook::EmptyClass*>(SH_GLOB_SHPTR->GetIfacePtr()); \
dvander@541
   695
	u.s.addr = (*reinterpret_cast<void***>(reinterpret_cast<char*>(thisptr) + SH_MFHCls(hookname)::ms_MFI.vtbloffs))[ \
dvander@541
   696
		SH_MFHCls(hookname)::ms_MFI.vtblindex]; \
dvander@541
   697
	u.s.adjustor = 0;
dvander@541
   698
dvander@541
   699
#endif
dvander@541
   700
dvander@541
   701
#define RETURN_META_MNEWPARAMS(result, hookname, newparams) \
dvander@541
   702
	do { \
dvander@541
   703
		SET_META_RESULT(result); \
dvander@541
   704
		SH_GLOB_SHPTR->DoRecall(); \
dvander@541
   705
		SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname); \
dvander@541
   706
		(thisptr->*(u.mfp)) newparams; \
dvander@541
   707
		RETURN_META(MRES_SUPERCEDE); \
dvander@541
   708
	} while (0)
dvander@541
   709
dvander@541
   710
#define RETURN_META_VALUE_MNEWPARAMS(result, value, hookname, newparams) \
dvander@541
   711
	do { \
dvander@541
   712
		SET_META_RESULT(result); \
dvander@541
   713
		SH_GLOB_SHPTR->DoRecall(); \
dvander@541
   714
		if ((result) >= MRES_OVERRIDE) \
dvander@541
   715
		{ \
dvander@541
   716
			/* see RETURN_META_VALUE_NEWPARAMS */ \
dvander@541
   717
			SourceHook::SetOverrideResult<SH_MFHCls(hookname)::RetType>(SH_GLOB_SHPTR, value); \
dvander@541
   718
		} \
dvander@541
   719
		SOUREHOOK__MNEWPARAMS_PREPAREMFP(hookname); \
dvander@541
   720
		RETURN_META_VALUE(MRES_SUPERCEDE, (thisptr->*(u.mfp)) newparams); \
dvander@541
   721
	} while (0)
dvander@541
   722
dvander@541
   723
#define SH_MANUALHOOK_RECONFIGURE(hookname, pvtblindex, pvtbloffs, pthisptroffs) \
dvander@541
   724
	do { \
dvander@541
   725
		SH_GLOB_SHPTR->RemoveHookManager(SH_GLOB_PLUGPTR, SH_MFHCls(hookname)::HookManPubFunc); \
dvander@541
   726
		SH_MFHCls(hookname)::ms_MFI.thisptroffs = pthisptroffs; \
dvander@541
   727
		SH_MFHCls(hookname)::ms_MFI.vtblindex = pvtblindex; \
dvander@541
   728
		SH_MFHCls(hookname)::ms_MFI.vtbloffs = pvtbloffs; \
dvander@541
   729
	} while (0)
dvander@541
   730
dvander@659
   731
dvander@659
   732
#define SH_GET_ORIG_VFNPTR_ENTRY(inst, mfp) (SourceHook::GetOrigVfnPtrEntry(inst, mfp, SH_GLOB_SHPTR))
dvander@659
   733
dvander@659
   734
// For source-level compatibility
dvander@659
   735
dvander@659
   736
#define SH_GET_CALLCLASS(ptr) SourceHook::GetCallClass(ptr)
dvander@659
   737
#define SH_GET_MCALLCLASS(ptr, size) SourceHook::GetCallClass(reinterpret_cast<SourceHook::EmptyClass*>(ptr))
dvander@659
   738
#define SH_RELEASE_CALLCLASS(ptr) SourceHook::ReleaseCallClass(ptr)
dvander@659
   739
dvander@659
   740
// New ADD / REMOVE macros.
dvander@659
   741
#define SH_STATIC(func) fastdelegate::MakeDelegate(func)
dvander@659
   742
#define SH_MEMBER(inst, func) fastdelegate::MakeDelegate(inst, func)
dvander@541
   743
dvander@541
   744
#define SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
dvander@541
   745
	__SourceHook_FHAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
dvander@541
   746
	post, handler)
dvander@541
   747
dvander@541
   748
#define SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
dvander@541
   749
	__SourceHook_FHRemove##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
dvander@659
   750
	post, handler) 
dvander@541
   751
dvander@541
   752
#define SH_ADD_MANUALHOOK(hookname, ifaceptr, handler, post) \
dvander@541
   753
	__SourceHook_FHMAdd##hookname(reinterpret_cast<void*>(ifaceptr), post, handler)
dvander@541
   754
dvander@541
   755
#define SH_REMOVE_MANUALHOOK(hookname, ifaceptr, handler, post) \
dvander@659
   756
	__SourceHook_FHMRemove##hookname(reinterpret_cast<void*>(ifaceptr), post, handler) 
dvander@659
   757
dvander@659
   758
#define SH_ADD_VPHOOK(ifacetype, ifacefunc, ifaceptr, handler, post) \
dvander@659
   759
	__SourceHook_FHVPAdd##ifacetype##ifacefunc((void*)SourceHook::implicit_cast<ifacetype*>(ifaceptr), \
dvander@659
   760
	post, handler, false)
dvander@659
   761
dvander@659
   762
#define SH_ADD_DVPHOOK(ifacetype, ifacefunc, vtableptr, handler, post) \
dvander@659
   763
	__SourceHook_FHVPAdd##ifacetype##ifacefunc(reinterpret_cast<void*>(vtableptr), \
dvander@659
   764
	post, handler, true)
dvander@659
   765
dvander@659
   766
#define SH_ADD_MANUALVPHOOK(hookname, ifaceptr, handler, post) \
dvander@659
   767
	__SourceHook_FHMVPAdd##hookname(reinterpret_cast<void*>(ifaceptr), post, handler, false)
dvander@659
   768
dvander@659
   769
#define SH_ADD_MANUALDVPHOOK(hookname, vtableptr, handler, post) \
dvander@659
   770
	__SourceHook_FHMVPAdd##hookname(reinterpret_cast<void*>(vtableptr), post, handler, true)
dvander@659
   771
dvander@659
   772
#define SH_REMOVE_HOOK_ID(hookid) \
dvander@659
   773
	(SH_GLOB_SHPTR->RemoveHookByID(SH_GLOB_PLUGPTR, hookid))
dvander@659
   774
dvander@659
   775
// Old macros
dvander@659
   776
// !! These are now deprecated. Instead, use one of these:
dvander@659
   777
//  SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
dvander@659
   778
//  SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post)
dvander@659
   779
dvander@659
   780
#define SH_ADD_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \
dvander@659
   781
	SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
dvander@659
   782
#define SH_ADD_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \
dvander@659
   783
	SH_ADD_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
dvander@659
   784
dvander@659
   785
//  SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
dvander@659
   786
//  SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(inst, func), post)
dvander@659
   787
dvander@659
   788
#define SH_REMOVE_HOOK_STATICFUNC(ifacetype, ifacefunc, ifaceptr, handler, post) \
dvander@659
   789
	SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_STATIC(handler), post)
dvander@659
   790
#define SH_REMOVE_HOOK_MEMFUNC(ifacetype, ifacefunc, ifaceptr, handler_inst, handler_func, post) \
dvander@659
   791
	SH_REMOVE_HOOK(ifacetype, ifacefunc, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
dvander@659
   792
dvander@659
   793
//  SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
dvander@659
   794
//  SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post)
dvander@659
   795
dvander@659
   796
#define SH_ADD_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \
dvander@659
   797
	SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
dvander@659
   798
#define SH_ADD_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \
dvander@659
   799
	SH_ADD_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)
dvander@659
   800
dvander@659
   801
//  SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
dvander@659
   802
//  SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(inst, func), post)
dvander@659
   803
dvander@541
   804
#define SH_REMOVE_MANUALHOOK_STATICFUNC(hookname, ifaceptr, handler, post) \
dvander@659
   805
	SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_STATIC(handler), post)
dvander@541
   806
#define SH_REMOVE_MANUALHOOK_MEMFUNC(hookname, ifaceptr, handler_inst, handler_func, post) \
dvander@659
   807
	SH_REMOVE_MANUALHOOK(hookname, ifaceptr, SH_MEMBER(handler_inst, handler_func), post)  
dvander@541
   808
dvander@541
   809
#define SH_NOATTRIB
dvander@541
   810
dvander@541
   811
dvander@541
   812
dvander@541
   813
dvander@541
   814
#if SH_COMP == SH_COMP_MSVC
dvander@541
   815
# define SH_SETUP_MFP(mfp) \
dvander@541
   816
	reinterpret_cast<void**>(&mfp)[0] = vfnptr_origentry;
dvander@541
   817
#elif SH_COMP == SH_COMP_GCC
dvander@541
   818
# define SH_SETUP_MFP(mfp) \
dvander@541
   819
	reinterpret_cast<void**>(&mfp)[0] = vfnptr_origentry; \
dvander@541
   820
	reinterpret_cast<void**>(&mfp)[1] = 0;
dvander@541
   821
#else
dvander@541
   822
# error Not supported yet.
dvander@541
   823
#endif
dvander@541
   824
dvander@541
   825
//////////////////////////////////////////////////////////////////////////
dvander@541
   826
#define SH_FHCls(ift, iff, ov) __SourceHook_FHCls_##ift##iff##ov
dvander@541
   827
#define SH_MFHCls(hookname) __SourceHook_MFHCls_##hookname
dvander@541
   828
dvander@541
   829
#define SHINT_MAKE_HOOKMANPUBFUNC(ifacetype, ifacefunc, overload, funcptr) \
dvander@541
   830
	SH_FHCls(ifacetype,ifacefunc,overload)() \
dvander@541
   831
	{ \
dvander@541
   832
		GetFuncInfo(funcptr, ms_MFI); \
dvander@541
   833
	} \
dvander@541
   834
	\
dvander@541
   835
	static int HookManPubFunc(::SourceHook::HookManagerAction action, ::SourceHook::IHookManagerInfo *param) \
dvander@541
   836
	{ \
dvander@541
   837
		using namespace ::SourceHook; \
dvander@541
   838
		GetFuncInfo(funcptr, ms_MFI); \
dvander@541
   839
		/* Verify interface version */ \
dvander@541
   840
		if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \
dvander@541
   841
			return 1; \
dvander@659
   842
		if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \
dvander@659
   843
			return 1; \
dvander@541
   844
		\
dvander@541
   845
		if (action == HA_GetInfo) \
dvander@541
   846
		{ \
dvander@541
   847
			param->SetVersion(SH_HOOKMAN_VERSION); \
dvander@541
   848
			param->SetInfo(ms_MFI.vtbloffs, ms_MFI.vtblindex, \
dvander@541
   849
				reinterpret_cast<const char*>(&ms_Proto)); \
dvander@541
   850
			\
dvander@541
   851
			MemFuncInfo mfi = {true, -1, 0, 0}; \
dvander@541
   852
			GetFuncInfo(&SH_FHCls(ifacetype,ifacefunc,overload)::Func, mfi); \
dvander@541
   853
			param->SetHookfuncVfnptr( \
dvander@541
   854
				reinterpret_cast<void**>(reinterpret_cast<char*>(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex]); \
dvander@541
   855
			return 0; \
dvander@541
   856
		} \
dvander@541
   857
		else if (action == HA_Register) \
dvander@541
   858
		{ \
dvander@541
   859
			ms_HI = param; \
dvander@541
   860
			return 0; \
dvander@541
   861
		} \
dvander@541
   862
		else if (action == HA_Unregister) \
dvander@541
   863
		{ \
dvander@541
   864
			ms_HI = NULL; \
dvander@541
   865
			return 0; \
dvander@541
   866
		} \
dvander@541
   867
		else \
dvander@541
   868
			return 1; \
dvander@541
   869
	}
dvander@541
   870
dvander@541
   871
// It has to be possible to use the macros in namespaces
dvander@541
   872
// -> So we need to access and extend the global SourceHook namespace
dvander@541
   873
// We use a namespace alias for this
dvander@541
   874
#define SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, funcptr) \
dvander@541
   875
	struct SH_FHCls(ifacetype,ifacefunc,overload) \
dvander@541
   876
	{ \
dvander@541
   877
		static SH_FHCls(ifacetype,ifacefunc,overload) ms_Inst; \
dvander@541
   878
		static ::SourceHook::MemFuncInfo ms_MFI; \
dvander@541
   879
		static ::SourceHook::IHookManagerInfo *ms_HI; \
dvander@541
   880
		static ::SourceHook::ProtoInfo ms_Proto; \
dvander@541
   881
		SHINT_MAKE_HOOKMANPUBFUNC(ifacetype, ifacefunc, overload, funcptr)
dvander@541
   882
dvander@541
   883
#define SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, funcptr) \
dvander@541
   884
	}; \
dvander@541
   885
	SH_FHCls(ifacetype,ifacefunc,overload) SH_FHCls(ifacetype,ifacefunc,overload)::ms_Inst; \
dvander@541
   886
	::SourceHook::MemFuncInfo SH_FHCls(ifacetype,ifacefunc,overload)::ms_MFI; \
dvander@541
   887
	::SourceHook::IHookManagerInfo *SH_FHCls(ifacetype,ifacefunc,overload)::ms_HI; \
dvander@659
   888
	int __SourceHook_FHAdd##ifacetype##ifacefunc(void *iface, bool post, \
dvander@541
   889
		SH_FHCls(ifacetype,ifacefunc,overload)::FD handler) \
dvander@541
   890
	{ \
dvander@541
   891
		using namespace ::SourceHook; \
dvander@541
   892
		MemFuncInfo mfi = {true, -1, 0, 0}; \
dvander@541
   893
		GetFuncInfo(funcptr, mfi); \
dvander@541
   894
		if (mfi.thisptroffs < 0 || !mfi.isVirtual) \
dvander@541
   895
			return false; /* No non-virtual functions / virtual inheritance supported */ \
dvander@541
   896
		\
dvander@659
   897
		return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, ::SourceHook::ISourceHook::Hook_Normal, iface, mfi.thisptroffs, \
dvander@541
   898
			SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, \
dvander@541
   899
			new CSHDelegate<SH_FHCls(ifacetype,ifacefunc,overload)::FD>(handler), post); \
dvander@541
   900
	} \
dvander@659
   901
	int __SourceHook_FHVPAdd##ifacetype##ifacefunc(void *iface, bool post, \
dvander@659
   902
		SH_FHCls(ifacetype,ifacefunc,overload)::FD handler, bool direct) \
dvander@659
   903
	{ \
dvander@659
   904
		using namespace ::SourceHook; \
dvander@659
   905
		MemFuncInfo mfi = {true, -1, 0, 0}; \
dvander@659
   906
		GetFuncInfo(funcptr, mfi); \
dvander@659
   907
		if (mfi.thisptroffs < 0 || !mfi.isVirtual) \
dvander@659
   908
			return false; /* No non-virtual functions / virtual inheritance supported */ \
dvander@659
   909
		\
dvander@659
   910
		return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, \
dvander@659
   911
			direct ? ::SourceHook::ISourceHook::Hook_DVP : ::SourceHook::ISourceHook::Hook_VP, \
dvander@659
   912
			iface, mfi.thisptroffs, SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, \
dvander@659
   913
			new CSHDelegate<SH_FHCls(ifacetype,ifacefunc,overload)::FD>(handler), post); \
dvander@659
   914
	} \
dvander@541
   915
	bool __SourceHook_FHRemove##ifacetype##ifacefunc(void *iface, bool post, \
dvander@541
   916
		SH_FHCls(ifacetype,ifacefunc,overload)::FD handler) \
dvander@541
   917
	{ \
dvander@541
   918
		using namespace ::SourceHook; \
dvander@541
   919
		MemFuncInfo mfi = {true, -1, 0, 0}; \
dvander@541
   920
		GetFuncInfo(funcptr, mfi); \
dvander@541
   921
		if (mfi.thisptroffs < 0) \
dvander@541
   922
			return false; /* No virtual inheritance supported */ \
dvander@541
   923
		\
dvander@541
   924
		CSHDelegate<SH_FHCls(ifacetype,ifacefunc,overload)::FD> tmp(handler); \
dvander@541
   925
		return SH_GLOB_SHPTR->RemoveHook(SH_GLOB_PLUGPTR, iface, mfi.thisptroffs, \
dvander@541
   926
			SH_FHCls(ifacetype,ifacefunc,overload)::HookManPubFunc, &tmp, post); \
dvander@541
   927
	} \
dvander@541
   928
dvander@541
   929
#define SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, pvtbloffs, pvtblidx, pthisptroffs) \
dvander@541
   930
	struct SH_MFHCls(hookname) \
dvander@541
   931
	{ \
dvander@541
   932
		static SH_MFHCls(hookname) ms_Inst; \
dvander@541
   933
		static ::SourceHook::MemFuncInfo ms_MFI; \
dvander@541
   934
		static ::SourceHook::IHookManagerInfo *ms_HI; \
dvander@541
   935
		static ::SourceHook::ProtoInfo ms_Proto; \
dvander@541
   936
		\
dvander@541
   937
		SH_MFHCls(hookname)() \
dvander@541
   938
		{ \
dvander@541
   939
			ms_MFI.isVirtual = true; \
dvander@541
   940
			ms_MFI.thisptroffs = pthisptroffs; \
dvander@541
   941
			ms_MFI.vtblindex = pvtblidx; \
dvander@541
   942
			ms_MFI.vtbloffs = pvtbloffs; \
dvander@541
   943
		} \
dvander@541
   944
		static int HookManPubFunc(::SourceHook::HookManagerAction action, ::SourceHook::IHookManagerInfo *param) \
dvander@541
   945
		{ \
dvander@541
   946
			using namespace ::SourceHook; \
dvander@541
   947
			/* we don't set ms_MFI here because manual hookmans can be reconfigured */ \
dvander@541
   948
			/* :FIXME: possible problem: someone adding a hook from a constructor of a global entity */ \
dvander@541
   949
			/* which is construced before SH_MFHCls(hookname)() gets called? */ \
dvander@541
   950
			/* Verify interface version */ \
dvander@541
   951
			if (SH_GLOB_SHPTR->GetIfaceVersion() != SH_IFACE_VERSION) \
dvander@541
   952
				return 1; \
dvander@659
   953
			if (SH_GLOB_SHPTR->GetImplVersion() < SH_IMPL_VERSION) \
dvander@659
   954
				return 1; \
dvander@541
   955
			\
dvander@541
   956
			if (action == HA_GetInfo) \
dvander@541
   957
			{ \
dvander@541
   958
				param->SetVersion(SH_HOOKMAN_VERSION); \
dvander@541
   959
				param->SetInfo(ms_MFI.vtbloffs, ms_MFI.vtblindex, \
dvander@541
   960
					reinterpret_cast<const char*>(&ms_Proto)); \
dvander@541
   961
				\
dvander@541
   962
				MemFuncInfo mfi = {true, -1, 0, 0}; \
dvander@541
   963
				GetFuncInfo(&SH_MFHCls(hookname)::Func, mfi); \
dvander@541
   964
				param->SetHookfuncVfnptr( \
dvander@541
   965
					reinterpret_cast<void**>(reinterpret_cast<char*>(&ms_Inst) + mfi.vtbloffs)[mfi.vtblindex]); \
dvander@541
   966
				return 0; \
dvander@541
   967
			} \
dvander@541
   968
			else if (action == HA_Register) \
dvander@541
   969
			{ \
dvander@541
   970
				ms_HI = param; \
dvander@541
   971
				return 0; \
dvander@541
   972
			} \
dvander@541
   973
			else if (action == HA_Unregister) \
dvander@541
   974
			{ \
dvander@541
   975
				ms_HI = NULL; \
dvander@541
   976
				return 0; \
dvander@541
   977
			} \
dvander@541
   978
			else \
dvander@541
   979
				return 1; \
dvander@541
   980
		}
dvander@541
   981
dvander@541
   982
#define SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, pvtbloffs, pvtblidx, pthisptroffs) \
dvander@541
   983
	}; \
dvander@541
   984
	SH_MFHCls(hookname) SH_MFHCls(hookname)::ms_Inst; \
dvander@541
   985
	::SourceHook::MemFuncInfo SH_MFHCls(hookname)::ms_MFI; \
dvander@541
   986
	::SourceHook::IHookManagerInfo *SH_MFHCls(hookname)::ms_HI; \
dvander@659
   987
	int __SourceHook_FHMAdd##hookname(void *iface, bool post, \
dvander@541
   988
		SH_MFHCls(hookname)::FD handler) \
dvander@541
   989
	{ \
dvander@659
   990
		return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, ::SourceHook::ISourceHook::Hook_Normal, iface, pthisptroffs, \
dvander@541
   991
			SH_MFHCls(hookname)::HookManPubFunc, \
dvander@541
   992
			new ::SourceHook::CSHDelegate<SH_MFHCls(hookname)::FD>(handler), post); \
dvander@541
   993
	} \
dvander@659
   994
	int __SourceHook_FHMVPAdd##hookname(void *iface, bool post, \
dvander@659
   995
		SH_MFHCls(hookname)::FD handler, bool direct) \
dvander@659
   996
	{ \
dvander@659
   997
		return SH_GLOB_SHPTR->AddHookNew(SH_GLOB_PLUGPTR, \
dvander@659
   998
			direct ? ::SourceHook::ISourceHook::Hook_DVP : ::SourceHook::ISourceHook::Hook_VP, \
dvander@659
   999
			iface, pthisptroffs, SH_MFHCls(hookname)::HookManPubFunc, \
dvander@659
  1000
			new ::SourceHook::CSHDelegate<SH_MFHCls(hookname)::FD>(handler), post); \
dvander@659
  1001
	} \
dvander@541
  1002
	bool __SourceHook_FHMRemove##hookname(void *iface, bool post, \
dvander@541
  1003
		SH_MFHCls(hookname)::FD handler) \
dvander@541
  1004
	{ \
dvander@541
  1005
		::SourceHook::CSHDelegate<SH_MFHCls(hookname)::FD> tmp(handler); \
dvander@541
  1006
		return SH_GLOB_SHPTR->RemoveHook(SH_GLOB_PLUGPTR, iface, pthisptroffs, \
dvander@541
  1007
			SH_MFHCls(hookname)::HookManPubFunc, &tmp, post); \
dvander@541
  1008
	} \
dvander@541
  1009
dvander@541
  1010
dvander@541
  1011
#define SH_SETUPCALLS(rettype, paramtypes, params) \
dvander@541
  1012
	/* 1) Find the vfnptr */ \
dvander@541
  1013
	using namespace ::SourceHook; \
dvander@541
  1014
	void *ourvfnptr = reinterpret_cast<void*>( \
dvander@541
  1015
		*reinterpret_cast<void***>(reinterpret_cast<char*>(this) + ms_MFI.vtbloffs) + ms_MFI.vtblindex); \
dvander@541
  1016
	IVfnPtr *vfnptr = ms_HI->FindVfnPtr(ourvfnptr); \
dvander@541
  1017
	SH_ASSERT(vfnptr, ("Called with vfnptr 0x%p which couldn't be found in the list", ourvfnptr)); \
dvander@541
  1018
	\
dvander@541
  1019
	void *vfnptr_origentry = vfnptr->GetOrigEntry(); \
dvander@541
  1020
	/* ... and the iface */ \
dvander@541
  1021
	IIface *ifinfo = vfnptr->FindIface(reinterpret_cast<void*>(this)); \
dvander@541
  1022
	if (!ifinfo) \
dvander@541
  1023
	{ \
dvander@541
  1024
		/* The iface info was not found. Redirect the call to the original function. */ \
dvander@541
  1025
		rettype (EmptyClass::*mfp)paramtypes; \
dvander@541
  1026
		SH_SETUP_MFP(mfp); \
dvander@541
  1027
		return (reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
dvander@541
  1028
	} \
dvander@541
  1029
	/* 2) Declare some vars and set it up */ \
dvander@541
  1030
	SH_GLOB_SHPTR->HookLoopBegin(ifinfo); \
dvander@541
  1031
	IHookList *prelist = ifinfo->GetPreHooks(); \
dvander@541
  1032
	IHookList *postlist = ifinfo->GetPostHooks(); \
dvander@541
  1033
	META_RES status = MRES_IGNORED; \
dvander@541
  1034
	META_RES prev_res; \
dvander@541
  1035
	META_RES cur_res; \
dvander@541
  1036
	typedef ReferenceCarrier<rettype>::type my_rettype; \
dvander@541
  1037
	my_rettype orig_ret; \
dvander@541
  1038
	my_rettype override_ret; \
dvander@541
  1039
	my_rettype plugin_ret; \
dvander@541
  1040
	void* ifptr; \
dvander@541
  1041
	my_rettype *pOverrideRet = reinterpret_cast<my_rettype*>(SH_GLOB_SHPTR->SetupHookLoop( \
dvander@541
  1042
		&status, &prev_res, &cur_res, &ifptr, &orig_ret, &override_ret));
dvander@541
  1043
dvander@541
  1044
#define SH_CALL_HOOKS(post, params) \
dvander@541
  1045
	if (SH_GLOB_SHPTR->ShouldContinue()) \
dvander@541
  1046
	{ \
dvander@541
  1047
		prev_res = MRES_IGNORED; \
dvander@541
  1048
		for (AutoHookIter iter(post##list); !iter.End(); iter.Next()) \
dvander@541
  1049
		{ \
dvander@541
  1050
			cur_res = MRES_IGNORED; \
dvander@541
  1051
			ifptr = reinterpret_cast<void*>(reinterpret_cast<char*>(this) - iter.ThisPtrOffs()); \
dvander@541
  1052
			plugin_ret = reinterpret_cast<CSHDelegate<FD>*>(iter.Handler())->GetDeleg() params; \
dvander@541
  1053
			prev_res = cur_res; \
dvander@541
  1054
			if (cur_res > status) \
dvander@541
  1055
				status = cur_res; \
dvander@541
  1056
			if (cur_res >= MRES_OVERRIDE) \
dvander@541
  1057
				*pOverrideRet = plugin_ret; \
dvander@541
  1058
			if (!SH_GLOB_SHPTR->ShouldContinue()) \
dvander@541
  1059
			{ \
dvander@541
  1060
				iter.SetToZero(); \
dvander@541
  1061
				break; \
dvander@541
  1062
			} \
dvander@541
  1063
		} \
dvander@541
  1064
	}
dvander@541
  1065
dvander@541
  1066
#define SH_CALL_ORIG(rettype, paramtypes, params) \
dvander@541
  1067
	if (status != MRES_SUPERCEDE) \
dvander@541
  1068
	{ \
dvander@541
  1069
		rettype (EmptyClass::*mfp)paramtypes; \
dvander@541
  1070
		SH_SETUP_MFP(mfp); \
dvander@541
  1071
		orig_ret = (reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
dvander@541
  1072
	} \
dvander@541
  1073
	else \
dvander@541
  1074
		orig_ret = override_ret; \
dvander@541
  1075
dvander@541
  1076
#define SH_RETURN() \
dvander@541
  1077
	SH_GLOB_SHPTR->HookLoopEnd(); \
dvander@541
  1078
	return status >= MRES_OVERRIDE ? *pOverrideRet : orig_ret;
dvander@541
  1079
dvander@541
  1080
#define SH_HANDLEFUNC(paramtypes, params, rettype) \
dvander@541
  1081
	SH_SETUPCALLS(rettype, paramtypes, params) \
dvander@541
  1082
	SH_CALL_HOOKS(pre, params) \
dvander@541
  1083
	SH_CALL_ORIG(rettype, paramtypes, params) \
dvander@541
  1084
	SH_CALL_HOOKS(post, params) \
dvander@541
  1085
	SH_RETURN()
dvander@541
  1086
dvander@541
  1087
//////////////////////////////////////////////////////////////////////////
dvander@541
  1088
#define SH_SETUPCALLS_void(paramtypes, params) \
dvander@541
  1089
	/* 1) Find the vfnptr */ \
dvander@541
  1090
	using namespace ::SourceHook; \
dvander@541
  1091
	void *ourvfnptr = reinterpret_cast<void*>( \
dvander@541
  1092
		*reinterpret_cast<void***>(reinterpret_cast<char*>(this) + ms_MFI.vtbloffs) + ms_MFI.vtblindex); \
dvander@541
  1093
	IVfnPtr *vfnptr = ms_HI->FindVfnPtr(ourvfnptr); \
dvander@541
  1094
	SH_ASSERT(vfnptr, ("Called with vfnptr 0x%p which couldn't be found in the list", ourvfnptr)); \
dvander@541
  1095
	\
dvander@541
  1096
	void *vfnptr_origentry = vfnptr->GetOrigEntry(); \
dvander@541
  1097
	/* ... and the iface */ \
dvander@541
  1098
	IIface *ifinfo = vfnptr->FindIface(reinterpret_cast<void*>(this)); \
dvander@541
  1099
	if (!ifinfo) \
dvander@541
  1100
	{ \
dvander@541
  1101
		/* The iface info was not found. Redirect the call to the original function. */ \
dvander@541
  1102
		void (EmptyClass::*mfp)paramtypes; \
dvander@541
  1103
		SH_SETUP_MFP(mfp); \
dvander@541
  1104
		(reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
dvander@541
  1105
		return; \
dvander@541
  1106
	} \
dvander@541
  1107
	/* 2) Declare some vars and set it up */ \
dvander@541
  1108
	SH_GLOB_SHPTR->HookLoopBegin(ifinfo); \
dvander@541
  1109
	IHookList *prelist = ifinfo->GetPreHooks(); \
dvander@541
  1110
	IHookList *postlist = ifinfo->GetPostHooks(); \
dvander@541
  1111
	META_RES status = MRES_IGNORED; \
dvander@541
  1112
	META_RES prev_res; \
dvander@541
  1113
	META_RES cur_res; \
dvander@541
  1114
	void* ifptr; \
dvander@541
  1115
	SH_GLOB_SHPTR->SetupHookLoop(&status, &prev_res, &cur_res, &ifptr, NULL, NULL); \
dvander@541
  1116
dvander@541
  1117
#define SH_CALL_HOOKS_void(post, params) \
dvander@541
  1118
	if (SH_GLOB_SHPTR->ShouldContinue()) \
dvander@541
  1119
	{ \
dvander@541
  1120
		prev_res = MRES_IGNORED; \
dvander@541
  1121
		for (AutoHookIter iter(post##list); !iter.End(); iter.Next()) \
dvander@541
  1122
		{ \
dvander@541
  1123
			cur_res = MRES_IGNORED; \
dvander@541
  1124
			ifptr = reinterpret_cast<void*>(reinterpret_cast<char*>(this) - iter.ThisPtrOffs()); \
dvander@541
  1125
			reinterpret_cast<CSHDelegate<FD>*>(iter.Handler())->GetDeleg() params; \
dvander@541
  1126
			prev_res = cur_res; \
dvander@541
  1127
			if (cur_res > status) \
dvander@541
  1128
				status = cur_res; \
dvander@541
  1129
			if (!SH_GLOB_SHPTR->ShouldContinue()) \
dvander@541
  1130
			{ \
dvander@541
  1131
				iter.SetToZero(); \
dvander@541
  1132
				break; \
dvander@541
  1133
			} \
dvander@541
  1134
		} \
dvander@541
  1135
	}
dvander@541
  1136
dvander@541
  1137
#define SH_CALL_ORIG_void(paramtypes, params) \
dvander@541
  1138
	if (status != MRES_SUPERCEDE) \
dvander@541
  1139
	{ \
dvander@541
  1140
		void (EmptyClass::*mfp)paramtypes; \
dvander@541
  1141
		SH_SETUP_MFP(mfp); \
dvander@541
  1142
		(reinterpret_cast<EmptyClass*>(this)->*mfp)params; \
dvander@541
  1143
	}
dvander@541
  1144
dvander@541
  1145
#define SH_RETURN_void() \
dvander@541
  1146
	SH_GLOB_SHPTR->HookLoopEnd();
dvander@541
  1147
dvander@541
  1148
#define SH_HANDLEFUNC_void(paramtypes, params) \
dvander@541
  1149
	SH_SETUPCALLS_void(paramtypes, params) \
dvander@541
  1150
	SH_CALL_HOOKS_void(pre, params) \
dvander@541
  1151
	SH_CALL_ORIG_void(paramtypes, params) \
dvander@541
  1152
	SH_CALL_HOOKS_void(post, params) \
dvander@541
  1153
	SH_RETURN_void()
dvander@541
  1154
dvander@541
  1155
dvander@541
  1156
// Special vafmt handlers
dvander@541
  1157
// :TODO: what
dvander@541
  1158
#define SH_HANDLEFUNC_vafmt(paramtypes, params_orig, params_plug, rettype) \
dvander@541
  1159
	SH_SETUPCALLS(rettype, paramtypes, params_orig) \
dvander@541
  1160
	SH_CALL_HOOKS(pre, params_plug) \
dvander@541
  1161
	SH_CALL_ORIG(rettype, paramtypes, params_orig) \
dvander@541
  1162
	SH_CALL_HOOKS(post, params_plug) \
dvander@541
  1163
	SH_RETURN()
dvander@541
  1164
dvander@541
  1165
#define SH_HANDLEFUNC_void_vafmt(paramtypes, params_orig, params_plug) \
dvander@541
  1166
	SH_SETUPCALLS_void(paramtypes, params_orig) \
dvander@541
  1167
	SH_CALL_HOOKS_void(pre, params_plug) \
dvander@541
  1168
	SH_CALL_ORIG_void(paramtypes, params_orig) \
dvander@541
  1169
	SH_CALL_HOOKS_void(post, params_plug) \
dvander@541
  1170
	SH_RETURN_void()
dvander@541
  1171
dvander@541
  1172
//////////////////////////////////////////////////////////////////////////
dvander@541
  1173
dvander@541
  1174
// :FIXME:
dvander@541
  1175
//  sizeof on references returns the size of the datatype, NOT the pointer size or something
dvander@541
  1176
//  -> one should probably flag references in __SourceHook_ParamSizes_* !
dvander@541
  1177
//		or simply assume that their size is sizeof(void*)=SH_PTRSIZE... could be doable through a simple template
dvander@541
  1178
dvander@541
  1179
@[$1,0,$a:
dvander@541
  1180
// ********* Support for $1 arguments *********
dvander@541
  1181
#define SH_DECL_HOOK$1(ifacetype, ifacefunc, attr, overload, rettype@[$2,1,$1:, param$2@]) \
dvander@541
  1182
	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(@[$2,1,$1|, :param$2@]) attr> \
dvander@541
  1183
		(&ifacetype::ifacefunc))) \
dvander@541
  1184
		typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> FD; \
dvander@541
  1185
		virtual rettype Func(@[$2,1,$1|, :param$2 p$2@]) \
dvander@541
  1186
		{ SH_HANDLEFUNC((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@]), rettype); } \
dvander@541
  1187
	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
dvander@541
  1188
		(static_cast<rettype (ifacetype::*)(@[$2,1,$1|, :param$2@]) attr>(&ifacetype::ifacefunc))) \
dvander@541
  1189
	\
dvander@541
  1190
	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0@[$2,1,$1:, sizeof(param$2)@] }; \
dvander@541
  1191
	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
dvander@541
  1192
		$1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
dvander@541
  1193
dvander@541
  1194
#define SH_DECL_HOOK$1_void(ifacetype, ifacefunc, attr, overload@[$2,1,$1:, param$2@]) \
dvander@541
  1195
	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(@[$2,1,$1|, :param$2@]) attr> \
dvander@541
  1196
		(&ifacetype::ifacefunc))) \
dvander@541
  1197
		typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> FD; \
dvander@541
  1198
		virtual void Func(@[$2,1,$1|, :param$2 p$2@]) \
dvander@541
  1199
		{ SH_HANDLEFUNC_void((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@])); } \
dvander@541
  1200
	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
dvander@541
  1201
		(static_cast<void (ifacetype::*)(@[$2,1,$1|, :param$2@]) attr>(&ifacetype::ifacefunc))) \
dvander@541
  1202
	\
dvander@541
  1203
	\
dvander@541
  1204
	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { 0@[$2,1,$1:, sizeof(param$2)@] }; \
dvander@541
  1205
	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
dvander@541
  1206
		$1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
dvander@541
  1207
dvander@541
  1208
#define SH_DECL_HOOK$1_vafmt(ifacetype, ifacefunc, attr, overload, rettype@[$2,1,$1:, param$2@]) \
dvander@541
  1209
	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<rettype (ifacetype::*)(@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, ...) attr> \
dvander@541
  1210
		(&ifacetype::ifacefunc))) \
dvander@541
  1211
		typedef fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, rettype> FD; \
dvander@541
  1212
		virtual rettype Func(@[$2,1,$1|, :param$2 p$2@]@[$1!=0:, @]const char *fmt, ...) \
dvander@541
  1213
		{ \
dvander@541
  1214
			char buf[::SourceHook::STRBUF_LEN]; \
dvander@541
  1215
			va_list ap; \
dvander@541
  1216
			va_start(ap, fmt); \
dvander@541
  1217
			vsnprintf(buf, sizeof(buf), fmt, ap); \
dvander@541
  1218
			va_end(ap); \
dvander@541
  1219
			SH_HANDLEFUNC_vafmt((@[$2,1,$1|, :param$2@]@[$1!=0:, @]...), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]"%s", buf), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]buf), rettype); \
dvander@541
  1220
		} \
dvander@541
  1221
	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
dvander@541
  1222
		(static_cast<rettype (ifacetype::*)(@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, ...) attr>(&ifacetype::ifacefunc))) \
dvander@541
  1223
	\
dvander@541
  1224
	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1@[$2,1,$1:, sizeof(param$2)@] }; \
dvander@541
  1225
	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(sizeof(rettype), \
dvander@541
  1226
		$1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
dvander@541
  1227
dvander@541
  1228
#define SH_DECL_HOOK$1_void_vafmt(ifacetype, ifacefunc, attr, overload@[$2,1,$1:, param$2@]) \
dvander@541
  1229
	SHINT_MAKE_GENERICSTUFF_BEGIN(ifacetype, ifacefunc, overload, (static_cast<void (ifacetype::*)(@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, ...) attr> \
dvander@541
  1230
		(&ifacetype::ifacefunc))) \
dvander@541
  1231
		typedef fastdelegate::FastDelegate@($1+1)<@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *> FD; \
dvander@541
  1232
		virtual void Func(@[$2,1,$1|, :param$2 p$2@]@[$1!=0:, @]const char *fmt, ...) \
dvander@541
  1233
		{ \
dvander@541
  1234
			char buf[::SourceHook::STRBUF_LEN]; \
dvander@541
  1235
			va_list ap; \
dvander@541
  1236
			va_start(ap, fmt); \
dvander@541
  1237
			vsnprintf(buf, sizeof(buf), fmt, ap); \
dvander@541
  1238
			va_end(ap); \
dvander@541
  1239
			SH_HANDLEFUNC_void_vafmt((@[$2,1,$1|, :param$2@]@[$1!=0:, @]...), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]"%s", buf), (@[$2,1,$1|, :p$2@]@[$1!=0:, @]buf)); \
dvander@541
  1240
		} \
dvander@541
  1241
	SHINT_MAKE_GENERICSTUFF_END(ifacetype, ifacefunc, overload, \
dvander@541
  1242
		(static_cast<void (ifacetype::*)(@[$2,1,$1|, :param$2@]@[$1!=0:, @]const char *, ...) attr>(&ifacetype::ifacefunc))) \
dvander@541
  1243
	\
dvander@541
  1244
	const int __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload[] = { -1@[$2,1,$1:, sizeof(param$2)@] }; \
dvander@541
  1245
	::SourceHook::ProtoInfo SH_FHCls(ifacetype, ifacefunc, overload)::ms_Proto(0, \
dvander@541
  1246
		$1, __SourceHook_ParamSizes_##ifacetype##ifacefunc##overload);
dvander@541
  1247
dvander@541
  1248
#define SH_DECL_MANUALHOOK$1(hookname, vtblidx, vtbloffs, thisptroffs, rettype@[$2,1,$1:, param$2@]) \
dvander@541
  1249
	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
dvander@541
  1250
		typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]@[$1!=0:, @]rettype> FD; \
dvander@541
  1251
		virtual rettype Func(@[$2,1,$1|, :param$2 p$2@]) \
dvander@541
  1252
		{ SH_HANDLEFUNC((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@]), rettype); } \
dvander@541
  1253
		typedef rettype(::SourceHook::EmptyClass::*ECMFP)(@[$2,1,$1|, :param$2@]); \
dvander@541
  1254
		typedef rettype RetType; \
dvander@541
  1255
	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
dvander@541
  1256
	\
dvander@541
  1257
	const int __SourceHook_ParamSizesM_##hookname[] = { 0@[$2,1,$1:, sizeof(param$2)@] }; \
dvander@541
  1258
	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(sizeof(rettype), \
dvander@541
  1259
		$1, __SourceHook_ParamSizesM_##hookname); \
dvander@541
  1260
dvander@541
  1261
#define SH_DECL_MANUALHOOK$1_void(hookname, vtblidx, vtbloffs, thisptroffs@[$2,1,$1:, param$2@]) \
dvander@541
  1262
	SHINT_MAKE_GENERICSTUFF_BEGIN_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
dvander@541
  1263
		typedef fastdelegate::FastDelegate$1<@[$2,1,$1|, :param$2@]> FD; \
dvander@541
  1264
		virtual void Func(@[$2,1,$1|, :param$2 p$2@]) \
dvander@541
  1265
		{ SH_HANDLEFUNC_void((@[$2,1,$1|, :param$2@]), (@[$2,1,$1|, :p$2@])); } \
dvander@541
  1266
		typedef void(::SourceHook::EmptyClass::*ECMFP)(@[$2,1,$1|, :param$2@]); \
dvander@541
  1267
	SHINT_MAKE_GENERICSTUFF_END_MANUAL(hookname, vtbloffs, vtblidx, thisptroffs) \
dvander@541
  1268
	\
dvander@541
  1269
	const int __SourceHook_ParamSizesM_##hookname[] = { 0@[$2,1,$1:, sizeof(param$2)@] }; \
dvander@541
  1270
	::SourceHook::ProtoInfo SH_MFHCls(hookname)::ms_Proto(0, \
dvander@541
  1271
		$1, __SourceHook_ParamSizesM_##hookname); \
dvander@541
  1272
dvander@541
  1273
@]
dvander@541
  1274
dvander@541
  1275
dvander@541
  1276
//////////////////////////////////////////////////////////////////////////
dvander@541
  1277
// SH_CALL
dvander@541
  1278
dvander@659
  1279
#define SH_MAKE_EXECUTABLECLASS_OB(call, prms) \
dvander@541
  1280
{ \
dvander@541
  1281
	using namespace ::SourceHook; \
dvander@541
  1282
	\
dvander@659
  1283
	m_pSH->SetIgnoreHooks(m_Plug, m_VfnPtr); \
dvander@659
  1284
	RetType tmpret = (m_ThisPtr->*m_MFP)call; \
dvander@659
  1285
	m_pSH->ResetIgnoreHooks(m_Plug, m_VfnPtr); \
dvander@659
  1286
	return tmpret; \
dvander@541
  1287
}
dvander@541
  1288
dvander@659
  1289
#define SH_MAKE_EXECUTABLECLASS_OB_void(call, prms) \
dvander@541
  1290
{ \
dvander@541
  1291
	using namespace ::SourceHook; \
dvander@541
  1292
	\
dvander@659
  1293
	m_pSH->SetIgnoreHooks(m_Plug, m_VfnPtr); \
dvander@659
  1294
	(m_ThisPtr->*m_MFP)call; \
dvander@659
  1295
	m_pSH->ResetIgnoreHooks(m_Plug, m_VfnPtr); \
dvander@541
  1296
}
dvander@541
  1297
dvander@541
  1298
namespace SourceHook
dvander@541
  1299
{
dvander@659
  1300
	// Call Class Wrapper!
dvander@659
  1301
	template <class T> struct CCW
dvander@541
  1302
	{
dvander@659
  1303
		typedef T type;
dvander@659
  1304
dvander@659
  1305
		// Get Real Pointer!
dvander@659
  1306
		static inline T *GRP(T *p)
dvander@659
  1307
		{
dvander@659
  1308
			return p;
dvander@659
  1309
		}
dvander@659
  1310
	};
dvander@659
  1311
dvander@659
  1312
	template <class T> struct CCW< CallClass<T> >
dvander@659
  1313
	{
dvander@659
  1314
		typedef T type;
dvander@659
  1315
dvander@659
  1316
		// Get Real Pointer!
dvander@659
  1317
		static inline T *GRP(CallClass<T> *p)
dvander@659
  1318
		{
dvander@659
  1319
			return p->ptr;
dvander@659
  1320
		}
dvander@541
  1321
	};
dvander@541
  1322
dvander@659
  1323
@[$1,0,$a:
dvander@659
  1324
	// Support for $1 arguments
dvander@659
  1325
	template<class ObjType, class MFP, class RetType@[$2,1,$1:, class Param$2@]> class ExecutableClass$1
dvander@541
  1326
	{
dvander@659
  1327
		ObjType *m_ThisPtr;
dvander@659
  1328
		void *m_VfnPtr;
dvander@659
  1329
		MFP m_MFP;
dvander@659
  1330
		ISourceHook *m_pSH;
dvander@659
  1331
		Plugin m_Plug;
dvander@541
  1332
	public:
dvander@659
  1333
		ExecutableClass$1(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
dvander@659
  1334
			m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
dvander@659
  1335
	
dvander@541
  1336
		RetType operator()(@[$2,1,$1|, :Param$2 p$2@]) const
dvander@659
  1337
			SH_MAKE_EXECUTABLECLASS_OB((@[$2,1,$1|, :p$2@]), (@[$2,1,$1|, :Param$2@]))
dvander@659
  1338
	         
dvander@541
  1339
		@[$2,$1+1,$a:
dvander@541
  1340
		template <@[$3,$1+1,$2|, :class Param$3@]> RetType operator()(@[$3,1,$2|, :Param$3 p$3@]) const
dvander@659
  1341
			SH_MAKE_EXECUTABLECLASS_OB((@[$3,1,$2|, :p$3@]), (@[$3,1,$2|, :Param$3@]))
dvander@541
  1342
		@]
dvander@541
  1343
	};
dvander@659
  1344
dvander@659
  1345
	template<class ObjType, class MFP@[$2,1,$1:, class Param$2@]> class ExecutableClass$1<ObjType, MFP, void@[$2,1,$1:, Param$2@]>
dvander@659
  1346
	{
dvander@659
  1347
	   ObjType *m_ThisPtr;
dvander@659
  1348
	   void *m_VfnPtr;
dvander@659
  1349
	   MFP m_MFP;
dvander@659
  1350
	   ISourceHook *m_pSH;
dvander@659
  1351
	   Plugin m_Plug;
dvander@659
  1352
	public:
dvander@659
  1353
	   ExecutableClass$1(ObjType *tp, MFP mfp, void *vp, ISourceHook *pSH, Plugin plug) : m_ThisPtr(tp),
dvander@659
  1354
		   m_VfnPtr(vp), m_MFP(mfp), m_pSH(pSH), m_Plug(plug) { }
dvander@659
  1355
	
dvander@659
  1356
	   void operator()(@[$2,1,$1|, :Param$2 p$2@]) const
dvander@659
  1357
	      SH_MAKE_EXECUTABLECLASS_OB_void((@[$2,1,$1|, :p$2@]), (@[$2,1,$1|, :Param$2@]))
dvander@659
  1358
	         
dvander@659
  1359
	   @[$2,$1+1,$a:
dvander@659
  1360
	   template <@[$3,$1+1,$2|, :class Param$3@]> void operator()(@[$3,1,$2|, :Param$3 p$3@]) const
dvander@659
  1361
	      SH_MAKE_EXECUTABLECLASS_OB_void((@[$3,1,$2|, :p$3@]), (@[$3,1,$2|, :Param$3@]))
dvander@659
  1362
	   @]
dvander@659
  1363
	};
dvander@541
  1364
@]
dvander@541
  1365
dvander@541
  1366
}
dvander@541
  1367
dvander@659
  1368
#define SH__CALL_GET_VFNPTR_NORMAL \
dvander@659
  1369
	using namespace ::SourceHook; \
dvander@659
  1370
	MemFuncInfo mfi = {true, -1, 0, 0}; \
dvander@659
  1371
	GetFuncInfo(CCW<Y>::GRP(ptr), mfp, mfi); \
dvander@659
  1372
	void *vfnptr = reinterpret_cast<void*>( \
dvander@696
  1373
		*reinterpret_cast<void***>(reinterpret_cast<char*>(CCW<Y>::GRP(ptr)) + mfi.thisptroffs + mfi.vtbloffs) + mfi.vtblindex);
dvander@659
  1374
dvander@659
  1375
#define SH__CALL_GET_VFNPTR_MANUAL \
dvander@659
  1376
	using namespace ::SourceHook; \
dvander@659
  1377
	void *vfnptr = reinterpret_cast<void*>( \
dvander@659
  1378
		*reinterpret_cast<void***>( (reinterpret_cast<char*>(CCW<Y>::GRP(ptr)) + thisptroffs + vtbloffs) ) + vtblidx); \
dvander@659
  1379
	/* patch mfp */ \
dvander@659
  1380
	*reinterpret_cast<void**>(&mfp) = *reinterpret_cast<void**>(vfnptr);
dvander@659
  1381
dvander@541
  1382
// SH_CALL needs to deduce the return type -> it uses templates and function overloading
dvander@541
  1383
// That's why SH_CALL takes two parameters: "mfp2" of type RetType(X::*mfp)(params), and "mfp" of type MFP
dvander@541
  1384
// The only purpose of the mfp2 parameter is to extract the return type
dvander@541
  1385
dvander@541
  1386
@[$1,0,$a:
dvander@541
  1387
// Support for $1 arguments
dvander@541
  1388
template <class X, class Y, class MFP, class RetType@[$2,1,$1:, class Param$2@]>
dvander@659
  1389
SourceHook::ExecutableClass$1<typename SourceHook::CCW<Y>::type, MFP, RetType@[$2,1,$1:, Param$2@]>
dvander@659
  1390
SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
dvander@541
  1391
{
dvander@659
  1392
	SH__CALL_GET_VFNPTR_NORMAL
dvander@659
  1393
	return SourceHook::ExecutableClass$1<typename CCW<Y>::type, MFP, RetType@[$2,1,$1:, Param$2@]>(CCW<Y>::GRP(ptr),
dvander@659
  1394
		mfp, vfnptr, shptr, plug);
dvander@541
  1395
}
dvander@541
  1396
dvander@541
  1397
template <class X, class Y, class MFP, class RetType@[$2,1,$1:, class Param$2@]>
dvander@659
  1398
SourceHook::ExecutableClass$1<typename SourceHook::CCW<Y>::type, MFP, RetType@[$2,1,$1:, Param$2@]>
dvander@659
  1399
SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@])const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
dvander@541
  1400
{
dvander@659
  1401
	SH__CALL_GET_VFNPTR_NORMAL
dvander@659
  1402
	return SourceHook::ExecutableClass$1<typename CCW<Y>::type, MFP, RetType@[$2,1,$1:, Param$2@]>(CCW<Y>::GRP(ptr),
dvander@659
  1403
		mfp, vfnptr, shptr, plug);
dvander@541
  1404
}
dvander@541
  1405
dvander@659
  1406
template <class X, class Y, class MFP, class RetType@[$2,1,$1:, class Param$2@]>
dvander@659
  1407
SourceHook::ExecutableClass$1<SourceHook::EmptyClass, MFP, RetType@[$2,1,$1:, Param$2@]>
dvander@659
  1408
SH_MCALL3(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]), int vtblidx, int vtbloffs, int thisptroffs, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
dvander@541
  1409
{
dvander@659
  1410
	SH__CALL_GET_VFNPTR_MANUAL
dvander@659
  1411
	return SourceHook::ExecutableClass$1<EmptyClass, MFP, RetType@[$2,1,$1:, Param$2@]>(
dvander@659
  1412
		reinterpret_cast<SourceHook::EmptyClass*>(CCW<Y>::GRP(ptr)), mfp, vfnptr, shptr, plug);
dvander@541
  1413
}
dvander@541
  1414
@]
dvander@541
  1415
dvander@541
  1416
#if SH_COMP != SH_COMP_MSVC || _MSC_VER > 1300
dvander@541
  1417
// GCC & MSVC 7.1 need this, MSVC 7.0 doesn't like it
dvander@541
  1418
dvander@541
  1419
@[$1,0,$a:
dvander@541
  1420
// Support for $1 arguments
dvander@541
  1421
template <class X, class Y, class MFP, class RetType@[$2,1,$1:, class Param$2@]>
dvander@659
  1422
SourceHook::ExecutableClass$1<typename SourceHook::CCW<Y>::type, MFP, RetType@[$2,1,$1:, Param$2@]>
dvander@659
  1423
SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]@[$1!=0:, @]...), SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
dvander@541
  1424
{
dvander@659
  1425
	SH__CALL_GET_VFNPTR_NORMAL
dvander@659
  1426
	return SourceHook::ExecutableClass$1<typename CCW<Y>::type, MFP, RetType@[$2,1,$1:, Param$2@]>(CCW<Y>::GRP(ptr),
dvander@659
  1427
		mfp, vfnptr, shptr, plug);
dvander@541
  1428
}
dvander@541
  1429
dvander@541
  1430
template <class X, class Y, class MFP, class RetType@[$2,1,$1:, class Param$2@]>
dvander@659
  1431
SourceHook::ExecutableClass$1<typename SourceHook::CCW<Y>::type, MFP, RetType@[$2,1,$1:, Param$2@]>
dvander@659
  1432
SH_CALL2(Y *ptr, MFP mfp, RetType(X::*mfp2)(@[$2,1,$1|, :Param$2@]@[$1!=0:, @]...)const, SourceHook::ISourceHook *shptr, SourceHook::Plugin plug)
dvander@541
  1433
{
dvander@659
  1434
	SH__CALL_GET_VFNPTR_NORMAL
dvander@659
  1435
	return SourceHook::ExecutableClass$1<typename CCW<Y>::type, MFP, RetType@[$2,1,$1:, Param$2@]>(CCW<Y>::GRP(ptr),
dvander@659
  1436
		mfp, vfnptr, shptr, plug);
dvander@541
  1437
}
dvander@541
  1438
dvander@541
  1439
@]
dvander@541
  1440
dvander@541
  1441
#endif
dvander@541
  1442
dvander@659
  1443
#define SH_CALL(ptr, mfp) SH_CALL2((ptr), (mfp), (mfp), SH_GLOB_SHPTR, SH_GLOB_PLUGPTR)
dvander@659
  1444
#define SH_MCALL2(ptr, mfp, vtblidx, vtbloffs, thisptroffs) SH_MCALL3((ptr), (mfp), (mfp), (vtblidx), (vtbloffs), (thisptroffs), SH_GLOB_SHPTR, SH_GLOB_PLUGPTR)
dvander@541
  1445
#define SH_MCALL(ptr, mhookname) SH_MCALL2((ptr), SH_MFHCls(mhookname)::ECMFP(), SH_MFHCls(mhookname)::ms_MFI.vtblindex, \
dvander@541
  1446
	SH_MFHCls(mhookname)::ms_MFI.vtbloffs, SH_MFHCls(mhookname)::ms_MFI.thisptroffs)
dvander@541
  1447
dvander@541
  1448
#undef SH_MAKE_EXECUTABLECLASS_OB
dvander@541
  1449
dvander@541
  1450
//////////////////////////////////////////////////////////////////////////
dvander@541
  1451
// SetOverrideRet and RecallGetIface for recalls
dvander@541
  1452
// These take a ISourceHook pointer instead of using SH_GLOB_SHPTR directly
dvander@541
  1453
// The reason is that the user may want to redefine SH_GLOB_SHPTR - then the macros
dvander@541
  1454
// (META_RETURN_VALUE_NEWPARAMS) should obey the new pointer.
dvander@541
  1455
dvander@541
  1456
namespace SourceHook
dvander@541
  1457
{
dvander@541
  1458
	template <class RetType>
dvander@541
  1459
	void SetOverrideResult(ISourceHook *shptr, const RetType res)
dvander@541
  1460
	{
dvander@541
  1461
		*reinterpret_cast<RetType*>(shptr->GetOverrideRetPtr()) = res;
dvander@541
  1462
	}
dvander@541
  1463
dvander@541
  1464
	// SetOverrideResult used to be implemented like this:
dvander@541
  1465
	//  SetOverrideResult(shptr, memfuncptr, return);
dvander@541
  1466
	//  normally the compiler can deduce the return type from memfuncptr, but (at least msvc8) failed when it was a reference
dvander@541
  1467
	//  (it thought it was ambigous - the ref and non-ref type)
dvander@541
  1468
	//  so now SetOverrideResult(memfuncptr) deduces the ret type, and returns a functor which does the work
dvander@541
  1469
	//  new syntax: SetOverrideResult(memfuncptr)(shptr, return)
dvander@541
  1470
	// This also allows us to create a special version for references which respects ReferenceCarrier.
dvander@541
  1471
dvander@541
  1472
	template <class T> struct OverrideFunctor
dvander@541
  1473
	{
dvander@541
  1474
		void operator()(ISourceHook *shptr, T res)
dvander@541
  1475
		{
dvander@541
  1476
			*reinterpret_cast<T*>(shptr->GetOverrideRetPtr()) = res;
dvander@541
  1477
		}
dvander@541
  1478
	};
dvander@541
  1479
	template <class T> struct OverrideFunctor<T&>
dvander@541
  1480
	{
dvander@541
  1481
		void operator()(ISourceHook *shptr, T &res)
dvander@541
  1482
		{
dvander@541
  1483
			// overrideretptr points to ReferenceCarrier<T&>
dvander@541
  1484
			*reinterpret_cast<typename ReferenceCarrier<T&>::type *>(shptr->GetOverrideRetPtr()) = res;
dvander@541
  1485
		}
dvander@541
  1486
	};
dvander@541
  1487
@[$1,0,$a:
dvander@541
  1488
	template <class Iface, class RetType@[$2,1,$1:, class Param$2@]>
dvander@541
  1489
	OverrideFunctor<RetType> SetOverrideResult(RetType (Iface::*mfp)(@[$2,1,$1|, :Param$2@]))
dvander@541
  1490
	{
dvander@541
  1491
		return OverrideFunctor<RetType>();
dvander@541
  1492
	}
dvander@541
  1493
dvander@541
  1494
	template <class Iface, class RetType@[$2,1,$1:, class Param$2@]>
dvander@541
  1495
	Iface *RecallGetIface(ISourceHook *shptr, RetType (Iface::*mfp)(@[$2,1,$1|, :Param$2@]))
dvander@541
  1496
	{
dvander@541
  1497
		return reinterpret_cast<Iface*>(shptr->GetIfacePtr());
dvander@541
  1498
	}
dvander@541
  1499
@]
dvander@541
  1500
}
dvander@541
  1501
dvander@541
  1502
#endif
dvander@541
  1503
	// The pope is dead. -> :(