sourcehook/sh_memfuncinfo.h
author Pavol Marko <pavolmarko@gmail.com>
Thu May 05 10:40:47 2005 +0000 (2005-05-05)
changeset 58 71016f952503
parent 49 ec95d7681407
child 59 8edcba00a103
permissions -rw-r--r--
Added code for proper handling of thisptr adjustors, added new test, version info, more options for GetFuncInfo
     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<8>   // All of these have size==8
    58 	{
    59 		struct GCC_MemFunPtr
    60 		{
    61 			union
    62 			{
    63 				void *funcadr;				// always even
    64 				int vtable_index_plus1;		//  = vindex+1, always odd
    65 			};
    66 			int 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) / 4;
    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<4>   // 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<8>   // 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<12>   // 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<16>   // 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 
   532 #endif
   533 
   534