sourcehook/sh_memfuncinfo.h
author Pavol Marko <pavolmarko@gmail.com>
Thu May 05 14:43:40 2005 +0000 (2005-05-05)
changeset 61 f9b4e9ded36d
parent 59 8edcba00a103
child 62 90513b7e3d99
permissions -rw-r--r--
More verbosity, gcc/linux/amd64 compatibility
     1 /* ======== SourceHook ========
     2 * Copyright (C) 2004-2005 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 	template<class X, class Y, class RetType>
   293 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(), MemFuncInfo &out)
   294 	{
   295 		RetType(Y::*mfp2)() = mfp;
   296 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   297 	}
   298 
   299 	template<class X, class Y, class RetType>
   300 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)() const, MemFuncInfo &out)
   301 	{
   302 		RetType(Y::*mfp2)() const = mfp;
   303 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   304 	}
   305 
   306 	template<class X, class Y, class RetType, class Param1>
   307 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1), MemFuncInfo &out)
   308 	{
   309 		RetType(Y::*mfp2)(Param1) = mfp;
   310 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   311 	}
   312 
   313 	template<class X, class Y, class RetType, class Param1>
   314 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1) const, MemFuncInfo &out)
   315 	{
   316 		RetType(Y::*mfp2)(Param1) const = mfp;
   317 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   318 	}
   319 
   320 	template<class X, class Y, class RetType, class Param1, class Param2>
   321 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2), MemFuncInfo &out)
   322 	{
   323 		RetType(Y::*mfp2)(Param1, Param2) = mfp;
   324 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   325 	}
   326 
   327 	template<class X, class Y, class RetType, class Param1, class Param2>
   328 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2) const, MemFuncInfo &out)
   329 	{
   330 		RetType(Y::*mfp2)(Param1, Param2) const = mfp;
   331 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   332 	}
   333 
   334 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
   335 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3), MemFuncInfo &out)
   336 	{
   337 		RetType(Y::*mfp2)(Param1, Param2, Param3) = mfp;
   338 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   339 	}
   340 
   341 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
   342 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3) const, MemFuncInfo &out)
   343 	{
   344 		RetType(Y::*mfp2)(Param1, Param2, Param3) const = mfp;
   345 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   346 	}
   347 
   348 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
   349 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4), MemFuncInfo &out)
   350 	{
   351 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4) = mfp;
   352 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   353 	}
   354 
   355 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
   356 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4) const, MemFuncInfo &out)
   357 	{
   358 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4) const = mfp;
   359 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   360 	}
   361 
   362 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   363 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5), MemFuncInfo &out)
   364 	{
   365 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5) = mfp;
   366 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   367 	}
   368 
   369 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   370 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5) const, MemFuncInfo &out)
   371 	{
   372 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5) const = mfp;
   373 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   374 	}
   375 
   376 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   377 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6), MemFuncInfo &out)
   378 	{
   379 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6) = mfp;
   380 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   381 	}
   382 
   383 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   384 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6) const, MemFuncInfo &out)
   385 	{
   386 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6) const = mfp;
   387 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   388 	}
   389 
   390 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   391 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7), MemFuncInfo &out)
   392 	{
   393 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7) = mfp;
   394 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   395 	}
   396 
   397 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   398 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7) const, MemFuncInfo &out)
   399 	{
   400 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7) const = mfp;
   401 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   402 	}
   403 
   404 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   405 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8), MemFuncInfo &out)
   406 	{
   407 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8) = mfp;
   408 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   409 	}
   410 
   411 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   412 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8) const, MemFuncInfo &out)
   413 	{
   414 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8) const = mfp;
   415 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   416 	}
   417 
   418 	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>
   419 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9), MemFuncInfo &out)
   420 	{
   421 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9) = mfp;
   422 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   423 	}
   424 
   425 	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>
   426 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9) const, MemFuncInfo &out)
   427 	{
   428 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9) const = mfp;
   429 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   430 	}
   431 
   432 	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>
   433 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10), MemFuncInfo &out)
   434 	{
   435 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10) = mfp;
   436 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   437 	}
   438 
   439 	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>
   440 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10) const, MemFuncInfo &out)
   441 	{
   442 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10) const = mfp;
   443 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   444 	}
   445 
   446 	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>
   447 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11), MemFuncInfo &out)
   448 	{
   449 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11) = mfp;
   450 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   451 	}
   452 
   453 	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>
   454 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11) const, MemFuncInfo &out)
   455 	{
   456 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11) const = mfp;
   457 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   458 	}
   459 
   460 	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>
   461 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12), MemFuncInfo &out)
   462 	{
   463 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12) = mfp;
   464 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   465 	}
   466 
   467 	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>
   468 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12) const, MemFuncInfo &out)
   469 	{
   470 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12) const = mfp;
   471 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   472 	}
   473 
   474 	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>
   475 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13), MemFuncInfo &out)
   476 	{
   477 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13) = mfp;
   478 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   479 	}
   480 
   481 	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>
   482 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13) const, MemFuncInfo &out)
   483 	{
   484 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13) const = mfp;
   485 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   486 	}
   487 
   488 	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>
   489 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14), MemFuncInfo &out)
   490 	{
   491 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14) = mfp;
   492 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   493 	}
   494 
   495 	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>
   496 		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)
   497 	{
   498 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14) const = mfp;
   499 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   500 	}
   501 
   502 	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>
   503 	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)
   504 	{
   505 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15) = mfp;
   506 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   507 	}
   508 
   509 	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>
   510 		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)
   511 	{
   512 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15) const = mfp;
   513 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   514 	}
   515 
   516 	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>
   517 	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)
   518 	{
   519 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16) = mfp;
   520 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   521 	}
   522 
   523 	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>
   524 		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)
   525 	{
   526 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16) const = mfp;
   527 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   528 	}
   529 
   530 
   531 	// GCC needs this, MSVC doesn't like them
   532 #if SH_COMP != SH_COMP_MSVC
   533 
   534 	template<class X, class Y, class RetType>
   535 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(...), MemFuncInfo &out)
   536 	{
   537 		RetType(Y::*mfp2)(...) = mfp;
   538 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   539 	}
   540 
   541 	template<class X, class Y, class RetType>
   542 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(...) const, MemFuncInfo &out)
   543 	{
   544 		RetType(Y::*mfp2)(...) const = mfp;
   545 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   546 	}
   547 
   548 	template<class X, class Y, class RetType, class Param1>
   549 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, ...), MemFuncInfo &out)
   550 	{
   551 		RetType(Y::*mfp2)(Param1, ...) = mfp;
   552 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   553 	}
   554 
   555 	template<class X, class Y, class RetType, class Param1>
   556 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, ...) const, MemFuncInfo &out)
   557 	{
   558 		RetType(Y::*mfp2)(Param1, ...) const = mfp;
   559 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   560 	}
   561 
   562 	template<class X, class Y, class RetType, class Param1, class Param2>
   563 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, ...), MemFuncInfo &out)
   564 	{
   565 		RetType(Y::*mfp2)(Param1, Param2, ...) = mfp;
   566 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   567 	}
   568 
   569 	template<class X, class Y, class RetType, class Param1, class Param2>
   570 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, ...) const, MemFuncInfo &out)
   571 	{
   572 		RetType(Y::*mfp2)(Param1, Param2, ...) const = mfp;
   573 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   574 	}
   575 
   576 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
   577 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, ...), MemFuncInfo &out)
   578 	{
   579 		RetType(Y::*mfp2)(Param1, Param2, Param3, ...) = mfp;
   580 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   581 	}
   582 
   583 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
   584 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, ...) const, MemFuncInfo &out)
   585 	{
   586 		RetType(Y::*mfp2)(Param1, Param2, Param3, ...) const = mfp;
   587 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   588 	}
   589 
   590 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
   591 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, ...), MemFuncInfo &out)
   592 	{
   593 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, ...) = mfp;
   594 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   595 	}
   596 
   597 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
   598 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, ...) const, MemFuncInfo &out)
   599 	{
   600 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, ...) const = mfp;
   601 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   602 	}
   603 
   604 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   605 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, ...), MemFuncInfo &out)
   606 	{
   607 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...) = mfp;
   608 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   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, ...) const, MemFuncInfo &out)
   613 	{
   614 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...) const = 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, class Param6>
   619 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...), MemFuncInfo &out)
   620 	{
   621 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...) = mfp;
   622 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   623 	}
   624 
   625 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   626 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...) const, MemFuncInfo &out)
   627 	{
   628 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...) const = mfp;
   629 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   630 	}
   631 
   632 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   633 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...), MemFuncInfo &out)
   634 	{
   635 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...) = mfp;
   636 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   637 	}
   638 
   639 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   640 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...) const, MemFuncInfo &out)
   641 	{
   642 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...) const = mfp;
   643 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   644 	}
   645 
   646 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   647 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...), MemFuncInfo &out)
   648 	{
   649 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...) = mfp;
   650 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   651 	}
   652 
   653 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   654 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...) const, MemFuncInfo &out)
   655 	{
   656 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...) const = mfp;
   657 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   658 	}
   659 
   660 	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>
   661 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...), MemFuncInfo &out)
   662 	{
   663 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...) = mfp;
   664 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   665 	}
   666 
   667 	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>
   668 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...) const, MemFuncInfo &out)
   669 	{
   670 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...) const = mfp;
   671 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   672 	}
   673 
   674 	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>
   675 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...), MemFuncInfo &out)
   676 	{
   677 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...) = mfp;
   678 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   679 	}
   680 
   681 	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>
   682 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...) const, MemFuncInfo &out)
   683 	{
   684 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...) const = mfp;
   685 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   686 	}
   687 
   688 	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>
   689 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...), MemFuncInfo &out)
   690 	{
   691 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...) = mfp;
   692 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   693 	}
   694 
   695 	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>
   696 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...) const, MemFuncInfo &out)
   697 	{
   698 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...) const = mfp;
   699 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   700 	}
   701 
   702 	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>
   703 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...), MemFuncInfo &out)
   704 	{
   705 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...) = mfp;
   706 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   707 	}
   708 
   709 	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>
   710 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...) const, MemFuncInfo &out)
   711 	{
   712 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...) const = mfp;
   713 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   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, class Param13>
   717 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...), MemFuncInfo &out)
   718 	{
   719 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...) = 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, class Param13>
   724 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...) const, MemFuncInfo &out)
   725 	{
   726 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...) const = mfp;
   727 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   728 	}
   729 
   730 	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>
   731 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...), MemFuncInfo &out)
   732 	{
   733 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...) = mfp;
   734 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   735 	}
   736 
   737 	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>
   738 		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)
   739 	{
   740 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...) const = mfp;
   741 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   742 	}
   743 
   744 	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>
   745 	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)
   746 	{
   747 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...) = mfp;
   748 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   749 	}
   750 
   751 	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>
   752 		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)
   753 	{
   754 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...) const = mfp;
   755 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   756 	}
   757 
   758 	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>
   759 	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)
   760 	{
   761 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...) = mfp;
   762 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   763 	}
   764 
   765 	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>
   766 		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)
   767 	{
   768 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...) const = mfp;
   769 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   770 	}
   771 
   772 
   773 #endif
   774 
   775 }
   776 
   777 #endif
   778 
   779