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