core-legacy/sourcehook/sh_memfuncinfo.h
author Nicholas Hastings <skamonkey@gmail.com>
Wed May 21 17:26:09 2014 -0400 (2014-05-21)
changeset 917 95639ee45d3d
parent 545 07e5df11f9fc
permissions -rw-r--r--
Trigger build for hl2sdk-l4d changes.
dvander@541
     1
/* ======== SourceHook ========
dvander@541
     2
* Copyright (C) 2004-2008 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
 * @brief This file provides a way for getting information about a member function.
dvander@541
    13
 * @file sh_memfuncinfo.h
dvander@541
    14
 */
dvander@541
    15
dvander@541
    16
#ifndef __SHINT_MEMFUNC_INFO_H__
dvander@541
    17
#define __SHINT_MEMFUNC_INFO_H__
dvander@541
    18
dvander@541
    19
namespace SourceHook
dvander@541
    20
{
dvander@541
    21
dvander@541
    22
	// Don Clugston:
dvander@541
    23
	//		implicit_cast< >
dvander@541
    24
	// I believe this was originally going to be in the C++ standard but 
dvander@541
    25
	// was left out by accident. It's even milder than static_cast.
dvander@541
    26
	// I use it instead of static_cast<> to emphasize that I'm not doing
dvander@541
    27
	// anything nasty. 
dvander@541
    28
	// Usage is identical to static_cast<>
dvander@541
    29
	template <class OutputClass, class InputClass>
dvander@541
    30
	inline OutputClass implicit_cast(InputClass input){
dvander@541
    31
		return input;
dvander@541
    32
	}
dvander@541
    33
dvander@541
    34
dvander@541
    35
	struct MemFuncInfo
dvander@541
    36
	{
dvander@541
    37
		bool isVirtual;		// Is the function virtual?
dvander@541
    38
		int thisptroffs;	// The this pointer the function expects to be called with
dvander@541
    39
							// If -1, you need to call the GetFuncInfo_GetThisPtr function
dvander@541
    40
		int vtblindex;		// The function's index in the vtable (0-based, 1=second entry, 2=third entry, ...)
dvander@541
    41
		int vtbloffs;		// The vtable pointer
dvander@541
    42
	};
dvander@541
    43
dvander@541
    44
	// Ideas by Don Clugston.
dvander@541
    45
	// Check out his excellent paper: http://www.codeproject.com/cpp/FastDelegate.asp
dvander@541
    46
dvander@541
    47
	template<int N> struct MFI_Impl
dvander@541
    48
	{
dvander@541
    49
		template<class MFP> static inline void GetFuncInfo(MFP *mfp, MemFuncInfo &out)
dvander@541
    50
		{
dvander@541
    51
			static char weird_memfunc_pointer_exclamation_mark_arrow_error[N-1000];
dvander@541
    52
		}
dvander@541
    53
	}; 
dvander@541
    54
dvander@541
    55
# if SH_COMP == SH_COMP_GCC
dvander@541
    56
dvander@541
    57
	template<> struct MFI_Impl<2*SH_PTRSIZE>   // All of these have size==8/16
dvander@541
    58
	{
dvander@541
    59
		struct GCC_MemFunPtr
dvander@541
    60
		{
dvander@541
    61
			union
dvander@541
    62
			{
dvander@541
    63
				void *funcadr;				// always even
dvander@541
    64
				intptr_t vtable_index_plus1;		//  = vindex+1, always odd
dvander@541
    65
			};
dvander@541
    66
			intptr_t delta;
dvander@541
    67
		};
dvander@541
    68
		template<class MFP> static inline void GetFuncInfo(MFP mfp, MemFuncInfo &out)
dvander@541
    69
		{
dvander@541
    70
			GCC_MemFunPtr *mfp_detail = (GCC_MemFunPtr*)&mfp;
dvander@541
    71
			out.thisptroffs = mfp_detail->delta;
dvander@541
    72
			if (mfp_detail->vtable_index_plus1 & 1)
dvander@541
    73
			{
dvander@541
    74
				out.vtblindex = (mfp_detail->vtable_index_plus1 - 1) / SH_PTRSIZE;
dvander@541
    75
				out.vtbloffs = 0;
dvander@541
    76
				out.isVirtual = true;
dvander@541
    77
			}
dvander@541
    78
			else
dvander@541
    79
				out.isVirtual = false;
dvander@541
    80
		}
dvander@541
    81
	}; 
dvander@541
    82
dvander@541
    83
# elif SH_COMP == SH_COMP_MSVC
dvander@541
    84
dvander@541
    85
	namespace
dvander@541
    86
	{
dvander@541
    87
		int MFI_GetVtblOffset(void *mfp)
dvander@541
    88
		{
dvander@541
    89
			unsigned char *addr = (unsigned char*)mfp;
dvander@541
    90
			if (*addr == 0xE9)		// Jmp
dvander@541
    91
			{
dvander@541
    92
				// May or may not be!
dvander@541
    93
				// Check where it'd jump
dvander@541
    94
				addr += 5 /*size of the instruction*/ + *(unsigned long*)(addr + 1);
dvander@541
    95
			}
dvander@541
    96
	
dvander@541
    97
			// Check whether it's a virtual function call
dvander@541
    98
			// They look like this:
dvander@541
    99
			// 004125A0 8B 01            mov         eax,dword ptr [ecx] 
dvander@541
   100
			// 004125A2 FF 60 04         jmp         dword ptr [eax+4]
dvander@541
   101
			//		==OR==
dvander@541
   102
			// 00411B80 8B 01            mov         eax,dword ptr [ecx] 
dvander@541
   103
			// 00411B82 FF A0 18 03 00 00 jmp         dword ptr [eax+318h]
dvander@541
   104
dvander@541
   105
			// However, for vararg functions, they look like this:
dvander@541
   106
			// 0048F0B0 8B 44 24 04      mov         eax,dword ptr [esp+4]
dvander@541
   107
			// 0048F0B4 8B 00            mov         eax,dword ptr [eax]
dvander@541
   108
			// 0048F0B6 FF 60 08         jmp         dword ptr [eax+8]
dvander@541
   109
			//		==OR==
dvander@541
   110
			// 0048F0B0 8B 44 24 04      mov         eax,dword ptr [esp+4]
dvander@541
   111
			// 0048F0B4 8B 00            mov         eax,dword ptr [eax]
dvander@541
   112
			// 00411B82 FF A0 18 03 00 00 jmp         dword ptr [eax+318h]
dvander@541
   113
			
dvander@541
   114
			// With varargs, the this pointer is passed as if it was the first argument
dvander@541
   115
dvander@541
   116
			bool ok = false;
dvander@541
   117
			if (addr[0] == 0x8B && addr[1] == 0x44 && addr[2] == 0x24 && addr[3] == 0x04 &&
dvander@541
   118
				addr[4] == 0x8B && addr[5] == 0x00)
dvander@541
   119
			{
dvander@541
   120
				addr += 6;
dvander@541
   121
				ok = true;
dvander@541
   122
			}
dvander@541
   123
			else if (addr[0] == 0x8B && addr[1] == 0x01)
dvander@541
   124
			{
dvander@541
   125
				addr += 2;
dvander@541
   126
				ok = true;
dvander@541
   127
			}
dvander@541
   128
			if (!ok)
dvander@541
   129
				return -1;
dvander@541
   130
dvander@541
   131
			if (*addr++ == 0xFF)
dvander@541
   132
			{
dvander@541
   133
				if (*addr == 0x60)
dvander@541
   134
				{
dvander@541
   135
					return *++addr / 4;
dvander@541
   136
				}
dvander@541
   137
				else if (*addr == 0xA0)
dvander@541
   138
				{
dvander@541
   139
					return *((unsigned int*)++addr) / 4;
dvander@541
   140
				}
dvander@541
   141
				else if (*addr == 0x20)
dvander@541
   142
					return 0;
dvander@541
   143
				else
dvander@541
   144
					return -1;
dvander@541
   145
			}
dvander@541
   146
			return -1;
dvander@541
   147
		}
dvander@541
   148
	}
dvander@541
   149
dvander@541
   150
	template<> struct MFI_Impl<1*SH_PTRSIZE>   // simple ones
dvander@541
   151
	{
dvander@541
   152
		template<class MFP> static inline void GetFuncInfo(MFP mfp, MemFuncInfo &out)
dvander@541
   153
		{
dvander@541
   154
			out.vtblindex = MFI_GetVtblOffset(*(void**)&mfp);
dvander@541
   155
			out.isVirtual = out.vtblindex >= 0 ? true : false;
dvander@541
   156
			out.thisptroffs = 0;
dvander@541
   157
			out.vtbloffs = 0;
dvander@541
   158
		}
dvander@541
   159
	};
dvander@541
   160
dvander@541
   161
	template<> struct MFI_Impl<2*SH_PTRSIZE>   // more complicated ones!
dvander@541
   162
	{
dvander@541
   163
		struct MSVC_MemFunPtr2
dvander@541
   164
		{
dvander@541
   165
			void *funcadr;
dvander@541
   166
			int delta;
dvander@541
   167
		};
dvander@541
   168
		template<class MFP> static inline void GetFuncInfo(MFP mfp, MemFuncInfo &out)
dvander@541
   169
		{
dvander@541
   170
			out.vtblindex = MFI_GetVtblOffset(*(void**)&mfp);
dvander@541
   171
			out.isVirtual = out.vtblindex >= 0 ? true : false;
dvander@541
   172
			out.thisptroffs = reinterpret_cast<MSVC_MemFunPtr2*>(&mfp)->delta;
dvander@541
   173
			out.vtbloffs = 0;
dvander@541
   174
		}
dvander@541
   175
	};
dvander@541
   176
dvander@541
   177
	// By Don Clugston, adapted
dvander@541
   178
	template<> struct MFI_Impl<3*SH_PTRSIZE>   // WOW IT"S GETTING BIGGER OMGOMOGMG
dvander@541
   179
	{
dvander@541
   180
		class __single_inheritance GenericClass;
dvander@541
   181
		class GenericClass {};
dvander@541
   182
dvander@541
   183
		struct MicrosoftVirtualMFP {
dvander@541
   184
			void (GenericClass::*codeptr)(); // points to the actual member function
dvander@541
   185
			int delta;		// #bytes to be added to the 'this' pointer
dvander@541
   186
			int vtable_index; // or 0 if no virtual inheritance
dvander@541
   187
		};
dvander@541
   188
dvander@541
   189
		struct GenericVirtualClass : virtual public GenericClass
dvander@541
   190
		{
dvander@541
   191
			typedef GenericVirtualClass * (GenericVirtualClass::*ProbePtrType)();
dvander@541
   192
			GenericVirtualClass * GetThis() { return this; }
dvander@541
   193
		};
dvander@541
   194
dvander@541
   195
		template<class MFP> static inline void GetFuncInfo(MFP mfp, MemFuncInfo &out)
dvander@541
   196
		{
dvander@541
   197
			out.vtblindex = MFI_GetVtblOffset(*(void**)&mfp);
dvander@541
   198
			out.isVirtual = out.vtblindex >= 0 ? true : false;
dvander@541
   199
			// This pointer
dvander@541
   200
			/*
dvander@541
   201
			union {
dvander@541
   202
				MFP func;
dvander@541
   203
				GenericClass* (T::*ProbeFunc)();
dvander@541
   204
				MicrosoftVirtualMFP s;
dvander@541
   205
			} u;
dvander@541
   206
			u.func = mfp;
dvander@541
   207
			union {
dvander@541
   208
				GenericVirtualClass::ProbePtrType virtfunc;
dvander@541
   209
				MicrosoftVirtualMFP s;
dvander@541
   210
			} u2;
dvander@541
   211
dvander@541
   212
			// Check that the horrible_cast<>s will work
dvander@541
   213
			typedef int ERROR_CantUsehorrible_cast[sizeof(mfp)==sizeof(u.s)
dvander@541
   214
				&& sizeof(mfp)==sizeof(u.ProbeFunc)
dvander@541
   215
				&& sizeof(u2.virtfunc)==sizeof(u2.s) ? 1 : -1];
dvander@541
   216
			// Unfortunately, taking the address of a MF prevents it from being inlined, so 
dvander@541
   217
			// this next line can't be completely optimised away by the compiler.
dvander@541
   218
			u2.virtfunc = &GenericVirtualClass::GetThis;
dvander@541
   219
			u.s.codeptr = u2.s.codeptr;
dvander@541
   220
			out.thisptroffs = (reinterpret_cast<T*>(NULL)->*u.ProbeFunc)();
dvander@541
   221
			*/
dvander@541
   222
			out.thisptroffs = -1;
dvander@541
   223
			out.vtbloffs = 0;
dvander@541
   224
		}
dvander@541
   225
	};
dvander@541
   226
dvander@541
   227
	// Don: Nasty hack for Microsoft and Intel (IA32 and Itanium)
dvander@541
   228
	// unknown_inheritance classes go here 
dvander@541
   229
	// This is probably the ugliest bit of code I've ever written. Look at the casts!
dvander@541
   230
	// There is a compiler bug in MSVC6 which prevents it from using this code.
dvander@541
   231
	template<> struct MFI_Impl<4*SH_PTRSIZE>   // THE BIGGEST ONE!!!1GABEN
dvander@541
   232
	{
dvander@541
   233
		template<class MFP> static inline void GetFuncInfo(MFP mfp, MemFuncInfo &out)
dvander@541
   234
		{
dvander@541
   235
			out.vtblindex = MFI_GetVtblOffset(*(void**)&mfp);
dvander@541
   236
			out.isVirtual = out.vtblindex >= 0 ? true : false;
dvander@541
   237
dvander@541
   238
			// The member function pointer is 16 bytes long. We can't use a normal cast, but
dvander@541
   239
			// we can use a union to do the conversion.
dvander@541
   240
			union {
dvander@541
   241
				MFP func;
dvander@541
   242
				// In VC++ and ICL, an unknown_inheritance member pointer 
dvander@541
   243
				// is internally defined as:
dvander@541
   244
				struct {
dvander@541
   245
					void *m_funcaddress; // points to the actual member function
dvander@541
   246
					int delta;		// #bytes to be added to the 'this' pointer
dvander@541
   247
					int vtordisp;		// #bytes to add to 'this' to find the vtable
dvander@541
   248
					int vtable_index; // or 0 if no virtual inheritance
dvander@541
   249
				} s;
dvander@541
   250
			} u;
dvander@541
   251
			// Check that the horrible_cast will work
dvander@541
   252
			typedef int ERROR_CantUsehorrible_cast[sizeof(u.func)==sizeof(u.s)? 1 : -1];
dvander@541
   253
			u.func = mfp;
dvander@541
   254
			int virtual_delta = 0;
dvander@541
   255
			if (u.s.vtable_index) { // Virtual inheritance is used
dvander@541
   256
				/*
dvander@541
   257
				// First, get to the vtable. 
dvander@541
   258
				// It is 'vtordisp' bytes from the start of the class.
dvander@541
   259
				int * vtable = *reinterpret_cast<int **>(
dvander@541
   260
					reinterpret_cast<char *>(thisptr) + u.s.vtordisp );
dvander@541
   261
dvander@541
   262
				// 'vtable_index' tells us where in the table we should be looking.
dvander@541
   263
				virtual_delta = u.s.vtordisp + *reinterpret_cast<const int *>( 
dvander@541
   264
					reinterpret_cast<const char *>(vtable) + u.s.vtable_index);
dvander@541
   265
			// The int at 'virtual_delta' gives us the amount to add to 'this'.
dvander@541
   266
			// Finally we can add the three components together. Phew!
dvander@541
   267
			out.thisptr = reinterpret_cast<void *>(
dvander@541
   268
				reinterpret_cast<char *>(thisptr) + u.s.delta + virtual_delta);
dvander@541
   269
				*/
dvander@541
   270
				out.vtbloffs = u.s.vtordisp;
dvander@541
   271
				out.thisptroffs = -1;
dvander@541
   272
			}
dvander@541
   273
			else
dvander@541
   274
			{
dvander@541
   275
				out.vtbloffs = out.vtblindex < 0 ? 0 : u.s.delta;
dvander@541
   276
				out.thisptroffs = u.s.delta;
dvander@541
   277
			}
dvander@541
   278
		};
dvander@541
   279
	};
dvander@541
   280
# else
dvander@541
   281
#  error Unsupported compiler
dvander@541
   282
# endif
dvander@541
   283
dvander@541
   284
	// This version does not take a this pointer
dvander@541
   285
	// Useful for hookdecls, as they ensure that mfp is correct through a static_cast
dvander@541
   286
	template<class X> inline void GetFuncInfo(X mfp, MemFuncInfo &out)
dvander@541
   287
	{
dvander@541
   288
		MFI_Impl<sizeof(mfp)>::GetFuncInfo(mfp, out);
dvander@541
   289
	}
dvander@541
   290
dvander@541
   291
	// Versions which do take a this
dvander@541
   292
dvander@541
   293
	template<class X, class Y, class RetType>
dvander@541
   294
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(), MemFuncInfo &out)
dvander@541
   295
	{
dvander@541
   296
		RetType(Y::*mfp2)() = mfp;
dvander@541
   297
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   298
	}
dvander@541
   299
dvander@541
   300
	template<class X, class Y, class RetType>
dvander@541
   301
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)() const, MemFuncInfo &out)
dvander@541
   302
	{
dvander@541
   303
		RetType(Y::*mfp2)() const = mfp;
dvander@541
   304
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   305
	}
dvander@541
   306
dvander@541
   307
	template<class X, class Y, class RetType, class Param1>
dvander@541
   308
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1), MemFuncInfo &out)
dvander@541
   309
	{
dvander@541
   310
		RetType(Y::*mfp2)(Param1) = mfp;
dvander@541
   311
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   312
	}
dvander@541
   313
dvander@541
   314
	template<class X, class Y, class RetType, class Param1>
dvander@541
   315
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1) const, MemFuncInfo &out)
dvander@541
   316
	{
dvander@541
   317
		RetType(Y::*mfp2)(Param1) const = mfp;
dvander@541
   318
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   319
	}
dvander@541
   320
dvander@541
   321
	template<class X, class Y, class RetType, class Param1, class Param2>
dvander@541
   322
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2), MemFuncInfo &out)
dvander@541
   323
	{
dvander@541
   324
		RetType(Y::*mfp2)(Param1, Param2) = mfp;
dvander@541
   325
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   326
	}
dvander@541
   327
dvander@541
   328
	template<class X, class Y, class RetType, class Param1, class Param2>
dvander@541
   329
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2) const, MemFuncInfo &out)
dvander@541
   330
	{
dvander@541
   331
		RetType(Y::*mfp2)(Param1, Param2) const = mfp;
dvander@541
   332
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   333
	}
dvander@541
   334
dvander@541
   335
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
dvander@541
   336
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3), MemFuncInfo &out)
dvander@541
   337
	{
dvander@541
   338
		RetType(Y::*mfp2)(Param1, Param2, Param3) = mfp;
dvander@541
   339
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   340
	}
dvander@541
   341
dvander@541
   342
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
dvander@541
   343
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3) const, MemFuncInfo &out)
dvander@541
   344
	{
dvander@541
   345
		RetType(Y::*mfp2)(Param1, Param2, Param3) const = mfp;
dvander@541
   346
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   347
	}
dvander@541
   348
dvander@541
   349
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
dvander@541
   350
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4), MemFuncInfo &out)
dvander@541
   351
	{
dvander@541
   352
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4) = mfp;
dvander@541
   353
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   354
	}
dvander@541
   355
dvander@541
   356
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
dvander@541
   357
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4) const, MemFuncInfo &out)
dvander@541
   358
	{
dvander@541
   359
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4) const = mfp;
dvander@541
   360
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   361
	}
dvander@541
   362
dvander@541
   363
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
dvander@541
   364
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5), MemFuncInfo &out)
dvander@541
   365
	{
dvander@541
   366
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5) = mfp;
dvander@541
   367
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   368
	}
dvander@541
   369
dvander@541
   370
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
dvander@541
   371
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5) const, MemFuncInfo &out)
dvander@541
   372
	{
dvander@541
   373
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5) const = mfp;
dvander@541
   374
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   375
	}
dvander@541
   376
dvander@541
   377
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
dvander@541
   378
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6), MemFuncInfo &out)
dvander@541
   379
	{
dvander@541
   380
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6) = mfp;
dvander@541
   381
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   382
	}
dvander@541
   383
dvander@541
   384
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
dvander@541
   385
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6) const, MemFuncInfo &out)
dvander@541
   386
	{
dvander@541
   387
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6) const = mfp;
dvander@541
   388
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   389
	}
dvander@541
   390
dvander@541
   391
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
dvander@541
   392
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7), MemFuncInfo &out)
dvander@541
   393
	{
dvander@541
   394
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7) = mfp;
dvander@541
   395
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   396
	}
dvander@541
   397
dvander@541
   398
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
dvander@541
   399
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7) const, MemFuncInfo &out)
dvander@541
   400
	{
dvander@541
   401
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7) const = mfp;
dvander@541
   402
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   403
	}
dvander@541
   404
dvander@541
   405
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
dvander@541
   406
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8), MemFuncInfo &out)
dvander@541
   407
	{
dvander@541
   408
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8) = mfp;
dvander@541
   409
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   410
	}
dvander@541
   411
dvander@541
   412
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
dvander@541
   413
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8) const, MemFuncInfo &out)
dvander@541
   414
	{
dvander@541
   415
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8) const = mfp;
dvander@541
   416
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   417
	}
dvander@541
   418
dvander@541
   419
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
dvander@541
   420
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9), MemFuncInfo &out)
dvander@541
   421
	{
dvander@541
   422
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9) = mfp;
dvander@541
   423
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   424
	}
dvander@541
   425
dvander@541
   426
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
dvander@541
   427
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9) const, MemFuncInfo &out)
dvander@541
   428
	{
dvander@541
   429
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9) const = mfp;
dvander@541
   430
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   431
	}
dvander@541
   432
dvander@541
   433
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
dvander@541
   434
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10), MemFuncInfo &out)
dvander@541
   435
	{
dvander@541
   436
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10) = mfp;
dvander@541
   437
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   438
	}
dvander@541
   439
dvander@541
   440
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
dvander@541
   441
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10) const, MemFuncInfo &out)
dvander@541
   442
	{
dvander@541
   443
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10) const = mfp;
dvander@541
   444
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   445
	}
dvander@541
   446
dvander@541
   447
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
dvander@541
   448
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11), MemFuncInfo &out)
dvander@541
   449
	{
dvander@541
   450
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11) = mfp;
dvander@541
   451
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   452
	}
dvander@541
   453
dvander@541
   454
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
dvander@541
   455
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11) const, MemFuncInfo &out)
dvander@541
   456
	{
dvander@541
   457
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11) const = mfp;
dvander@541
   458
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   459
	}
dvander@541
   460
dvander@541
   461
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
dvander@541
   462
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12), MemFuncInfo &out)
dvander@541
   463
	{
dvander@541
   464
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12) = mfp;
dvander@541
   465
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   466
	}
dvander@541
   467
dvander@541
   468
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
dvander@541
   469
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12) const, MemFuncInfo &out)
dvander@541
   470
	{
dvander@541
   471
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12) const = mfp;
dvander@541
   472
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   473
	}
dvander@541
   474
dvander@541
   475
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
dvander@541
   476
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13), MemFuncInfo &out)
dvander@541
   477
	{
dvander@541
   478
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13) = mfp;
dvander@541
   479
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   480
	}
dvander@541
   481
dvander@541
   482
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
dvander@541
   483
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13) const, MemFuncInfo &out)
dvander@541
   484
	{
dvander@541
   485
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13) const = mfp;
dvander@541
   486
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   487
	}
dvander@541
   488
dvander@541
   489
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
dvander@541
   490
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14), MemFuncInfo &out)
dvander@541
   491
	{
dvander@541
   492
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14) = mfp;
dvander@541
   493
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   494
	}
dvander@541
   495
dvander@541
   496
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
dvander@541
   497
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14) const, MemFuncInfo &out)
dvander@541
   498
	{
dvander@541
   499
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14) const = mfp;
dvander@541
   500
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   501
	}
dvander@541
   502
dvander@541
   503
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
dvander@541
   504
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15), MemFuncInfo &out)
dvander@541
   505
	{
dvander@541
   506
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15) = mfp;
dvander@541
   507
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   508
	}
dvander@541
   509
dvander@541
   510
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
dvander@541
   511
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15) const, MemFuncInfo &out)
dvander@541
   512
	{
dvander@541
   513
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15) const = mfp;
dvander@541
   514
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   515
	}
dvander@541
   516
dvander@541
   517
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
dvander@541
   518
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16), MemFuncInfo &out)
dvander@541
   519
	{
dvander@541
   520
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16) = mfp;
dvander@541
   521
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   522
	}
dvander@541
   523
dvander@541
   524
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
dvander@541
   525
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16) const, MemFuncInfo &out)
dvander@541
   526
	{
dvander@541
   527
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16) const = mfp;
dvander@541
   528
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   529
	}
dvander@541
   530
dvander@541
   531
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17>
dvander@541
   532
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17), MemFuncInfo &out)
dvander@541
   533
	{
dvander@541
   534
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17) = mfp;
dvander@541
   535
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   536
	}
dvander@541
   537
dvander@541
   538
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17>
dvander@541
   539
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17) const, MemFuncInfo &out)
dvander@541
   540
	{
dvander@541
   541
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17) const = mfp;
dvander@541
   542
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   543
	}
dvander@541
   544
dvander@541
   545
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18>
dvander@541
   546
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18), MemFuncInfo &out)
dvander@541
   547
	{
dvander@541
   548
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18) = mfp;
dvander@541
   549
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   550
	}
dvander@541
   551
dvander@541
   552
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18>
dvander@541
   553
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18) const, MemFuncInfo &out)
dvander@541
   554
	{
dvander@541
   555
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18) const = mfp;
dvander@541
   556
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   557
	}
dvander@541
   558
dvander@541
   559
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18, class Param19>
dvander@541
   560
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19), MemFuncInfo &out)
dvander@541
   561
	{
dvander@541
   562
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19) = mfp;
dvander@541
   563
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   564
	}
dvander@541
   565
dvander@541
   566
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18, class Param19>
dvander@541
   567
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19) const, MemFuncInfo &out)
dvander@541
   568
	{
dvander@541
   569
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19) const = mfp;
dvander@541
   570
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   571
	}
dvander@541
   572
dvander@541
   573
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18, class Param19, class Param20>
dvander@541
   574
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20), MemFuncInfo &out)
dvander@541
   575
	{
dvander@541
   576
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20) = mfp;
dvander@541
   577
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   578
	}
dvander@541
   579
dvander@541
   580
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18, class Param19, class Param20>
dvander@541
   581
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20) const, MemFuncInfo &out)
dvander@541
   582
	{
dvander@541
   583
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20) const = mfp;
dvander@541
   584
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   585
	}
dvander@541
   586
dvander@541
   587
dvander@541
   588
	// GCC & MSVC 7.1 need this, MSVC 7.0 doesn't like it
dvander@541
   589
#if SH_COMP != SH_COMP_MSVC || _MSC_VER > 1300
dvander@541
   590
dvander@541
   591
dvander@541
   592
	template<class X, class Y, class RetType>
dvander@541
   593
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(...), MemFuncInfo &out)
dvander@541
   594
	{
dvander@541
   595
		RetType(Y::*mfp2)(...) = mfp;
dvander@541
   596
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   597
	}
dvander@541
   598
dvander@541
   599
	template<class X, class Y, class RetType>
dvander@541
   600
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(...) const, MemFuncInfo &out)
dvander@541
   601
	{
dvander@541
   602
		RetType(Y::*mfp2)(...) const = mfp;
dvander@541
   603
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   604
	}
dvander@541
   605
dvander@541
   606
dvander@541
   607
	template<class X, class Y, class RetType, class Param1>
dvander@541
   608
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, ...), MemFuncInfo &out)
dvander@541
   609
	{
dvander@541
   610
		RetType(Y::*mfp2)(Param1, ...) = mfp;
dvander@541
   611
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   612
	}
dvander@541
   613
dvander@541
   614
	template<class X, class Y, class RetType, class Param1>
dvander@541
   615
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, ...) const, MemFuncInfo &out)
dvander@541
   616
	{
dvander@541
   617
		RetType(Y::*mfp2)(Param1, ...) const = mfp;
dvander@541
   618
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   619
	}
dvander@541
   620
dvander@541
   621
dvander@541
   622
	template<class X, class Y, class RetType, class Param1, class Param2>
dvander@541
   623
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, ...), MemFuncInfo &out)
dvander@541
   624
	{
dvander@541
   625
		RetType(Y::*mfp2)(Param1, Param2, ...) = mfp;
dvander@541
   626
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   627
	}
dvander@541
   628
dvander@541
   629
	template<class X, class Y, class RetType, class Param1, class Param2>
dvander@541
   630
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, ...) const, MemFuncInfo &out)
dvander@541
   631
	{
dvander@541
   632
		RetType(Y::*mfp2)(Param1, Param2, ...) const = mfp;
dvander@541
   633
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   634
	}
dvander@541
   635
dvander@541
   636
dvander@541
   637
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
dvander@541
   638
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, ...), MemFuncInfo &out)
dvander@541
   639
	{
dvander@541
   640
		RetType(Y::*mfp2)(Param1, Param2, Param3, ...) = mfp;
dvander@541
   641
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   642
	}
dvander@541
   643
dvander@541
   644
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
dvander@541
   645
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, ...) const, MemFuncInfo &out)
dvander@541
   646
	{
dvander@541
   647
		RetType(Y::*mfp2)(Param1, Param2, Param3, ...) const = mfp;
dvander@541
   648
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   649
	}
dvander@541
   650
dvander@541
   651
dvander@541
   652
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
dvander@541
   653
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, ...), MemFuncInfo &out)
dvander@541
   654
	{
dvander@541
   655
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, ...) = mfp;
dvander@541
   656
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   657
	}
dvander@541
   658
dvander@541
   659
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
dvander@541
   660
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, ...) const, MemFuncInfo &out)
dvander@541
   661
	{
dvander@541
   662
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, ...) const = mfp;
dvander@541
   663
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   664
	}
dvander@541
   665
dvander@541
   666
dvander@541
   667
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
dvander@541
   668
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, ...), MemFuncInfo &out)
dvander@541
   669
	{
dvander@541
   670
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...) = mfp;
dvander@541
   671
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   672
	}
dvander@541
   673
dvander@541
   674
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
dvander@541
   675
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, ...) const, MemFuncInfo &out)
dvander@541
   676
	{
dvander@541
   677
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...) const = mfp;
dvander@541
   678
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   679
	}
dvander@541
   680
dvander@541
   681
dvander@541
   682
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
dvander@541
   683
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...), MemFuncInfo &out)
dvander@541
   684
	{
dvander@541
   685
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...) = mfp;
dvander@541
   686
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   687
	}
dvander@541
   688
dvander@541
   689
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
dvander@541
   690
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...) const, MemFuncInfo &out)
dvander@541
   691
	{
dvander@541
   692
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...) const = mfp;
dvander@541
   693
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   694
	}
dvander@541
   695
dvander@541
   696
dvander@541
   697
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
dvander@541
   698
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...), MemFuncInfo &out)
dvander@541
   699
	{
dvander@541
   700
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...) = mfp;
dvander@541
   701
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   702
	}
dvander@541
   703
dvander@541
   704
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
dvander@541
   705
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...) const, MemFuncInfo &out)
dvander@541
   706
	{
dvander@541
   707
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...) const = mfp;
dvander@541
   708
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   709
	}
dvander@541
   710
dvander@541
   711
dvander@541
   712
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
dvander@541
   713
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...), MemFuncInfo &out)
dvander@541
   714
	{
dvander@541
   715
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...) = mfp;
dvander@541
   716
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   717
	}
dvander@541
   718
dvander@541
   719
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
dvander@541
   720
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...) const, MemFuncInfo &out)
dvander@541
   721
	{
dvander@541
   722
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...) const = mfp;
dvander@541
   723
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   724
	}
dvander@541
   725
dvander@541
   726
dvander@541
   727
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
dvander@541
   728
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...), MemFuncInfo &out)
dvander@541
   729
	{
dvander@541
   730
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...) = mfp;
dvander@541
   731
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   732
	}
dvander@541
   733
dvander@541
   734
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
dvander@541
   735
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...) const, MemFuncInfo &out)
dvander@541
   736
	{
dvander@541
   737
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...) const = mfp;
dvander@541
   738
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   739
	}
dvander@541
   740
dvander@541
   741
dvander@541
   742
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
dvander@541
   743
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...), MemFuncInfo &out)
dvander@541
   744
	{
dvander@541
   745
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...) = mfp;
dvander@541
   746
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   747
	}
dvander@541
   748
dvander@541
   749
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
dvander@541
   750
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...) const, MemFuncInfo &out)
dvander@541
   751
	{
dvander@541
   752
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...) const = mfp;
dvander@541
   753
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   754
	}
dvander@541
   755
dvander@541
   756
dvander@541
   757
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
dvander@541
   758
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...), MemFuncInfo &out)
dvander@541
   759
	{
dvander@541
   760
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...) = mfp;
dvander@541
   761
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   762
	}
dvander@541
   763
dvander@541
   764
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
dvander@541
   765
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...) const, MemFuncInfo &out)
dvander@541
   766
	{
dvander@541
   767
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...) const = mfp;
dvander@541
   768
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   769
	}
dvander@541
   770
dvander@541
   771
dvander@541
   772
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
dvander@541
   773
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...), MemFuncInfo &out)
dvander@541
   774
	{
dvander@541
   775
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...) = mfp;
dvander@541
   776
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   777
	}
dvander@541
   778
dvander@541
   779
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
dvander@541
   780
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...) const, MemFuncInfo &out)
dvander@541
   781
	{
dvander@541
   782
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...) const = mfp;
dvander@541
   783
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   784
	}
dvander@541
   785
dvander@541
   786
dvander@541
   787
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
dvander@541
   788
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...), MemFuncInfo &out)
dvander@541
   789
	{
dvander@541
   790
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...) = mfp;
dvander@541
   791
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   792
	}
dvander@541
   793
dvander@541
   794
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
dvander@541
   795
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...) const, MemFuncInfo &out)
dvander@541
   796
	{
dvander@541
   797
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...) const = mfp;
dvander@541
   798
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   799
	}
dvander@541
   800
dvander@541
   801
dvander@541
   802
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
dvander@541
   803
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...), MemFuncInfo &out)
dvander@541
   804
	{
dvander@541
   805
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...) = mfp;
dvander@541
   806
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   807
	}
dvander@541
   808
dvander@541
   809
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
dvander@541
   810
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...) const, MemFuncInfo &out)
dvander@541
   811
	{
dvander@541
   812
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...) const = mfp;
dvander@541
   813
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   814
	}
dvander@541
   815
dvander@541
   816
dvander@541
   817
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
dvander@541
   818
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...), MemFuncInfo &out)
dvander@541
   819
	{
dvander@541
   820
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...) = mfp;
dvander@541
   821
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   822
	}
dvander@541
   823
dvander@541
   824
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
dvander@541
   825
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...) const, MemFuncInfo &out)
dvander@541
   826
	{
dvander@541
   827
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...) const = mfp;
dvander@541
   828
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   829
	}
dvander@541
   830
dvander@541
   831
dvander@541
   832
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
dvander@541
   833
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...), MemFuncInfo &out)
dvander@541
   834
	{
dvander@541
   835
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...) = mfp;
dvander@541
   836
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   837
	}
dvander@541
   838
dvander@541
   839
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
dvander@541
   840
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...) const, MemFuncInfo &out)
dvander@541
   841
	{
dvander@541
   842
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...) const = mfp;
dvander@541
   843
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   844
	}
dvander@541
   845
dvander@541
   846
dvander@541
   847
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17>
dvander@541
   848
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, ...), MemFuncInfo &out)
dvander@541
   849
	{
dvander@541
   850
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, ...) = mfp;
dvander@541
   851
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   852
	}
dvander@541
   853
dvander@541
   854
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17>
dvander@541
   855
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, ...) const, MemFuncInfo &out)
dvander@541
   856
	{
dvander@541
   857
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, ...) const = mfp;
dvander@541
   858
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   859
	}
dvander@541
   860
dvander@541
   861
dvander@541
   862
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18>
dvander@541
   863
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, ...), MemFuncInfo &out)
dvander@541
   864
	{
dvander@541
   865
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, ...) = mfp;
dvander@541
   866
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   867
	}
dvander@541
   868
dvander@541
   869
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18>
dvander@541
   870
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, ...) const, MemFuncInfo &out)
dvander@541
   871
	{
dvander@541
   872
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, ...) const = mfp;
dvander@541
   873
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   874
	}
dvander@541
   875
dvander@541
   876
dvander@541
   877
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18, class Param19>
dvander@541
   878
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, ...), MemFuncInfo &out)
dvander@541
   879
	{
dvander@541
   880
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, ...) = mfp;
dvander@541
   881
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   882
	}
dvander@541
   883
dvander@541
   884
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18, class Param19>
dvander@541
   885
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, ...) const, MemFuncInfo &out)
dvander@541
   886
	{
dvander@541
   887
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, ...) const = mfp;
dvander@541
   888
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   889
	}
dvander@541
   890
dvander@541
   891
dvander@541
   892
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18, class Param19, class Param20>
dvander@541
   893
	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20, ...), MemFuncInfo &out)
dvander@541
   894
	{
dvander@541
   895
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20, ...) = mfp;
dvander@541
   896
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   897
	}
dvander@541
   898
dvander@541
   899
	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class Param17, class Param18, class Param19, class Param20>
dvander@541
   900
		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20, ...) const, MemFuncInfo &out)
dvander@541
   901
	{
dvander@541
   902
		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20, ...) const = mfp;
dvander@541
   903
		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
dvander@541
   904
	}
dvander@541
   905
dvander@541
   906
dvander@541
   907
dvander@541
   908
#endif
dvander@541
   909
dvander@541
   910
}
dvander@541
   911
dvander@541
   912
#endif