core/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 780 35f2a207badf
permissions -rw-r--r--
Trigger build for hl2sdk-l4d changes.
     1 /* ======== SourceHook ========
     2 * Copyright (C) 2004-2010 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 	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>
   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)
   533 	{
   534 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17) = mfp;
   535 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   536 	}
   537 
   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>
   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)
   540 	{
   541 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17) const = mfp;
   542 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   543 	}
   544 
   545 
   546 	// GCC & MSVC 7.1 need this, MSVC 7.0 doesn't like it
   547 #if SH_COMP != SH_COMP_MSVC || _MSC_VER > 1300
   548 
   549 
   550 	template<class X, class Y, class RetType>
   551 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(...), MemFuncInfo &out)
   552 	{
   553 		RetType(Y::*mfp2)(...) = mfp;
   554 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   555 	}
   556 
   557 	template<class X, class Y, class RetType>
   558 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(...) const, MemFuncInfo &out)
   559 	{
   560 		RetType(Y::*mfp2)(...) const = mfp;
   561 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   562 	}
   563 
   564 
   565 	template<class X, class Y, class RetType, class Param1>
   566 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, ...), MemFuncInfo &out)
   567 	{
   568 		RetType(Y::*mfp2)(Param1, ...) = mfp;
   569 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   570 	}
   571 
   572 	template<class X, class Y, class RetType, class Param1>
   573 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, ...) const, MemFuncInfo &out)
   574 	{
   575 		RetType(Y::*mfp2)(Param1, ...) const = mfp;
   576 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   577 	}
   578 
   579 
   580 	template<class X, class Y, class RetType, class Param1, class Param2>
   581 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, ...), MemFuncInfo &out)
   582 	{
   583 		RetType(Y::*mfp2)(Param1, Param2, ...) = mfp;
   584 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   585 	}
   586 
   587 	template<class X, class Y, class RetType, class Param1, class Param2>
   588 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, ...) const, MemFuncInfo &out)
   589 	{
   590 		RetType(Y::*mfp2)(Param1, Param2, ...) const = mfp;
   591 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   592 	}
   593 
   594 
   595 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
   596 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, ...), MemFuncInfo &out)
   597 	{
   598 		RetType(Y::*mfp2)(Param1, Param2, Param3, ...) = mfp;
   599 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   600 	}
   601 
   602 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
   603 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, ...) const, MemFuncInfo &out)
   604 	{
   605 		RetType(Y::*mfp2)(Param1, Param2, Param3, ...) const = mfp;
   606 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   607 	}
   608 
   609 
   610 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
   611 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, ...), MemFuncInfo &out)
   612 	{
   613 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, ...) = mfp;
   614 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   615 	}
   616 
   617 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
   618 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, ...) const, MemFuncInfo &out)
   619 	{
   620 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, ...) const = mfp;
   621 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   622 	}
   623 
   624 
   625 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
   626 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, ...), MemFuncInfo &out)
   627 	{
   628 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...) = 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>
   633 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, ...) const, MemFuncInfo &out)
   634 	{
   635 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, ...) const = mfp;
   636 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   637 	}
   638 
   639 
   640 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   641 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...), MemFuncInfo &out)
   642 	{
   643 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...) = mfp;
   644 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   645 	}
   646 
   647 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
   648 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, ...) const, MemFuncInfo &out)
   649 	{
   650 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, ...) const = mfp;
   651 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   652 	}
   653 
   654 
   655 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   656 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...), MemFuncInfo &out)
   657 	{
   658 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...) = mfp;
   659 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   660 	}
   661 
   662 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
   663 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...) const, MemFuncInfo &out)
   664 	{
   665 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, ...) const = mfp;
   666 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   667 	}
   668 
   669 
   670 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   671 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...), MemFuncInfo &out)
   672 	{
   673 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...) = mfp;
   674 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   675 	}
   676 
   677 	template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   678 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...) const, MemFuncInfo &out)
   679 	{
   680 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, ...) const = mfp;
   681 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   682 	}
   683 
   684 
   685 	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>
   686 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...), MemFuncInfo &out)
   687 	{
   688 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...) = mfp;
   689 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   690 	}
   691 
   692 	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>
   693 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...) const, MemFuncInfo &out)
   694 	{
   695 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, ...) const = mfp;
   696 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   697 	}
   698 
   699 
   700 	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>
   701 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...), MemFuncInfo &out)
   702 	{
   703 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...) = mfp;
   704 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   705 	}
   706 
   707 	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>
   708 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...) const, MemFuncInfo &out)
   709 	{
   710 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, ...) const = mfp;
   711 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   712 	}
   713 
   714 
   715 	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>
   716 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...), MemFuncInfo &out)
   717 	{
   718 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...) = mfp;
   719 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   720 	}
   721 
   722 	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>
   723 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...) const, MemFuncInfo &out)
   724 	{
   725 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, ...) const = mfp;
   726 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   727 	}
   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>
   731 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...), MemFuncInfo &out)
   732 	{
   733 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...) = 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>
   738 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...) const, MemFuncInfo &out)
   739 	{
   740 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, ...) const = mfp;
   741 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   742 	}
   743 
   744 
   745 	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>
   746 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...), MemFuncInfo &out)
   747 	{
   748 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...) = mfp;
   749 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   750 	}
   751 
   752 	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>
   753 		inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...) const, MemFuncInfo &out)
   754 	{
   755 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, ...) const = mfp;
   756 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   757 	}
   758 
   759 
   760 	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>
   761 	inline void GetFuncInfo(Y *ptr, RetType(X::*mfp)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...), MemFuncInfo &out)
   762 	{
   763 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...) = mfp;
   764 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   765 	}
   766 
   767 	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>
   768 		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)
   769 	{
   770 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, ...) const = mfp;
   771 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   772 	}
   773 
   774 
   775 	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>
   776 	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)
   777 	{
   778 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...) = mfp;
   779 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   780 	}
   781 
   782 	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>
   783 		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)
   784 	{
   785 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, ...) const = mfp;
   786 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   787 	}
   788 
   789 
   790 	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>
   791 	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)
   792 	{
   793 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...) = mfp;
   794 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   795 	}
   796 
   797 	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>
   798 		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)
   799 	{
   800 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, ...) const = mfp;
   801 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   802 	}
   803 
   804 
   805 	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>
   806 	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)
   807 	{
   808 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, ...) = mfp;
   809 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   810 	}
   811 
   812 	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>
   813 		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)
   814 	{
   815 		RetType(Y::*mfp2)(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, ...) const = mfp;
   816 		MFI_Impl<sizeof(mfp2)>::GetFuncInfo(mfp2, out);
   817 	}
   818 
   819 
   820 #endif
   821 
   822 }
   823 
   824 #endif