core/sourcehook/generate/FastDelegate.hxx
author Scott Ehlert <ds@alliedmods.net>
Thu Dec 10 00:59:50 2009 -0600 (2009-12-10)
changeset 689 4065ba5e9155
parent 539 db914129ae01
permissions -rw-r--r--
Rewrote user message caching code to always use IServerGameDLL::GetUserMessageInfo (bug 4117, r=dvander).

Games where the above function can crash are handled by detouring tier0's Error() function and jumping back to our own code. So in theory this should work on all games now.
     1 //						FastDelegate.h
     2 //	Efficient delegates in C++ that generate only two lines of asm code!
     3 //  Documentation is found at http://www.codeproject.com/cpp/FastDelegate.asp
     4 //
     5 //						- Don Clugston, Mar 2004.
     6 //		Major contributions were made by Jody Hagins.
     7 // History:
     8 // 24-Apr-04 1.0  * Submitted to CodeProject.
     9 // 28-Apr-04 1.1  * Prevent most unsafe uses of evil static function hack.
    10 //				  * Improved syntax for horrible_cast (thanks Paul Bludov).
    11 //				  * Tested on Metrowerks MWCC and Intel ICL (IA32)
    12 //				  * Compiled, but not run, on Comeau C++ and Intel Itanium ICL.
    13 //	27-Jun-04 1.2 * Now works on Borland C++ Builder 5.5
    14 //				  * Now works on /clr "managed C++" code on VC7, VC7.1
    15 //				  * Comeau C++ now compiles without warnings.
    16 //				  * Prevent the virtual inheritance case from being used on
    17 //					  VC6 and earlier, which generate incorrect code.
    18 //				  * Improved warning and error messages. Non-standard hacks
    19 //					 now have compile-time checks to make them safer.
    20 //				  * implicit_cast used instead of static_cast in many cases.
    21 //				  * If calling a const member function, a const class pointer can be used.
    22 //				  * MakeDelegate() global helper function added to simplify pass-by-value.
    23 //				  * Added fastdelegate.clear()
    24 // 16-Jul-04 1.2.1* Workaround for gcc bug (const member function pointers in templates)
    25 // 30-Oct-04 1.3  * Support for (non-void) return values.
    26 //				  * No more workarounds in client code!
    27 //					 MSVC and Intel now use a clever hack invented by John Dlugosz:
    28 //				     - The FASTDELEGATEDECLARE workaround is no longer necessary.
    29 //					 - No more warning messages for VC6
    30 //				  * Less use of macros. Error messages should be more comprehensible.
    31 //				  * Added include guards
    32 //				  * Added FastDelegate::empty() to test if invocation is safe (Thanks Neville Franks).
    33 //				  * Now tested on VS 2005 Express Beta, PGI C++
    34 // 24-Dec-04 1.4  * Added DelegateMemento, to allow collections of disparate delegates.
    35 //                * <,>,<=,>= comparison operators to allow storage in ordered containers.
    36 //				  * Substantial reduction of code size, especially the 'Closure' class.
    37 //				  * Standardised all the compiler-specific workarounds.
    38 //                * MFP conversion now works for CodePlay (but not yet supported in the full code).
    39 //                * Now compiles without warnings on _any_ supported compiler, including BCC 5.5.1
    40 //				  * New syntax: FastDelegate< int (char *, double) >.
    41 // 14-Feb-05 1.4.1* Now treats =0 as equivalent to .clear(), ==0 as equivalent to .empty(). (Thanks elfric).
    42 //				  * Now tested on Intel ICL for AMD64, VS2005 Beta for AMD64 and Itanium.
    43 // 30-Mar-05 1.5  * Safebool idiom: "if (dg)" is now equivalent to "if (!dg.empty())"
    44 //				  * Fully supported by CodePlay VectorC
    45 //                * Bugfix for Metrowerks: empty() was buggy because a valid MFP can be 0 on MWCC!
    46 //                * More optimal assignment,== and != operators for static function pointers.
    47 
    48 #ifndef FASTDELEGATE_H
    49 #define FASTDELEGATE_H
    50 
    51 #ifdef _MSC_VER
    52 # if _MSC_VER > 1000
    53 #  pragma once
    54 # endif // _MSC_VER > 1000
    55 #endif // #ifdef _MSC_VER
    56 
    57 #include <memory.h> // to allow <,> comparisons
    58 
    59 ////////////////////////////////////////////////////////////////////////////////
    60 //						Configuration options
    61 //
    62 ////////////////////////////////////////////////////////////////////////////////
    63 
    64 // Uncomment the following #define for optimally-sized delegates.
    65 // In this case, the generated asm code is almost identical to the code you'd get
    66 // if the compiler had native support for delegates.
    67 // It will not work on systems where sizeof(dataptr) < sizeof(codeptr).
    68 // Thus, it will not work for DOS compilers using the medium model.
    69 // It will also probably fail on some DSP systems.
    70 #define FASTDELEGATE_USESTATICFUNCTIONHACK
    71 
    72 // Uncomment the next line to allow function declarator syntax.
    73 // It is automatically enabled for those compilers where it is known to work.
    74 //#define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
    75 
    76 ////////////////////////////////////////////////////////////////////////////////
    77 //						Compiler identification for workarounds
    78 //
    79 ////////////////////////////////////////////////////////////////////////////////
    80 
    81 // Compiler identification. It's not easy to identify Visual C++ because
    82 // many vendors fraudulently define Microsoft's identifiers.
    83 #if defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__VECTOR_C) && !defined(__ICL) && !defined(__BORLANDC__)
    84 #define FASTDLGT_ISMSVC
    85 
    86 #if (_MSC_VER <1300) // Many workarounds are required for VC6.
    87 #define FASTDLGT_VC6
    88 #pragma warning(disable:4786) // disable this ridiculous warning
    89 #endif
    90 
    91 #endif
    92 
    93 // Does the compiler uses Microsoft's member function pointer structure?
    94 // If so, it needs special treatment.
    95 // Metrowerks CodeWarrior, Intel, and CodePlay fraudulently define Microsoft's
    96 // identifier, _MSC_VER. We need to filter Metrowerks out.
    97 #if defined(_MSC_VER) && !defined(__MWERKS__)
    98 #define FASTDLGT_MICROSOFT_MFP
    99 
   100 #if !defined(__VECTOR_C)
   101 // CodePlay doesn't have the __single/multi/virtual_inheritance keywords
   102 #define FASTDLGT_HASINHERITANCE_KEYWORDS
   103 #endif
   104 #endif
   105 
   106 // Does it allow function declarator syntax? The following compilers are known to work:
   107 #if defined(FASTDLGT_ISMSVC) && (_MSC_VER >=1310) // VC 7.1
   108 #define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
   109 #endif
   110 
   111 // Gcc(2.95+), and versions of Digital Mars, Intel and Comeau in common use.
   112 #if defined (__DMC__) || defined(__GNUC__) || defined(__ICL) || defined(__COMO__)
   113 #define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
   114 #endif
   115 
   116 // It works on Metrowerks MWCC 3.2.2. From boost.Config it should work on earlier ones too.
   117 #if defined (__MWERKS__)
   118 #define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
   119 #endif
   120 
   121 #ifdef __GNUC__ // Workaround GCC bug #8271
   122 	// At present, GCC doesn't recognize constness of MFPs in templates
   123 #define FASTDELEGATE_GCC_BUG_8271
   124 #endif
   125 
   126 
   127 
   128 ////////////////////////////////////////////////////////////////////////////////
   129 //						General tricks used in this code
   130 //
   131 // (a) Error messages are generated by typdefing an array of negative size to
   132 //     generate compile-time errors.
   133 // (b) Warning messages on MSVC are generated by declaring unused variables, and
   134 //	    enabling the "variable XXX is never used" warning.
   135 // (c) Unions are used in a few compiler-specific cases to perform illegal casts.
   136 // (d) For Microsoft and Intel, when adjusting the 'this' pointer, it's cast to
   137 //     (char *) first to ensure that the correct number of *bytes* are added.
   138 //
   139 ////////////////////////////////////////////////////////////////////////////////
   140 //						Helper templates
   141 //
   142 ////////////////////////////////////////////////////////////////////////////////
   143 
   144 
   145 namespace fastdelegate {
   146 namespace detail {	// we'll hide the implementation details in a nested namespace.
   147 
   148 //		implicit_cast< >
   149 // I believe this was originally going to be in the C++ standard but
   150 // was left out by accident. It's even milder than static_cast.
   151 // I use it instead of static_cast<> to emphasize that I'm not doing
   152 // anything nasty.
   153 // Usage is identical to static_cast<>
   154 template <class OutputClass, class InputClass>
   155 inline OutputClass implicit_cast(InputClass input){
   156 	return input;
   157 }
   158 
   159 //		horrible_cast< >
   160 // This is truly evil. It completely subverts C++'s type system, allowing you
   161 // to cast from any class to any other class. Technically, using a union
   162 // to perform the cast is undefined behaviour (even in C). But we can see if
   163 // it is OK by checking that the union is the same size as each of its members.
   164 // horrible_cast<> should only be used for compiler-specific workarounds.
   165 // Usage is identical to reinterpret_cast<>.
   166 
   167 // This union is declared outside the horrible_cast because BCC 5.5.1
   168 // can't inline a function with a nested class, and gives a warning.
   169 template <class OutputClass, class InputClass>
   170 union horrible_union{
   171 	OutputClass out;
   172 	InputClass in;
   173 };
   174 
   175 template <class OutputClass, class InputClass>
   176 inline OutputClass horrible_cast(const InputClass input){
   177 	horrible_union<OutputClass, InputClass> u;
   178 	// Cause a compile-time error if in, out and u are not the same size.
   179 	// If the compile fails here, it means the compiler has peculiar
   180 	// unions which would prevent the cast from working.
   181 	typedef int ERROR_CantUseHorrible_cast[sizeof(InputClass)==sizeof(u)
   182 		&& sizeof(InputClass)==sizeof(OutputClass) ? 1 : -1];
   183 	u.in = input;
   184 	return u.out;
   185 }
   186 
   187 ////////////////////////////////////////////////////////////////////////////////
   188 //						Workarounds
   189 //
   190 ////////////////////////////////////////////////////////////////////////////////
   191 
   192 // Backwards compatibility: This macro used to be necessary in the virtual inheritance
   193 // case for Intel and Microsoft. Now it just forward-declares the class.
   194 #define FASTDELEGATEDECLARE(CLASSNAME)	class CLASSNAME;
   195 
   196 // Prevent use of the static function hack with the DOS medium model.
   197 #ifdef __MEDIUM__
   198 #undef FASTDELEGATE_USESTATICFUNCTIONHACK
   199 #endif
   200 
   201 //			DefaultVoid - a workaround for 'void' templates in VC6.
   202 //
   203 //  (1) VC6 and earlier do not allow 'void' as a default template argument.
   204 //  (2) They also doesn't allow you to return 'void' from a function.
   205 //
   206 // Workaround for (1): Declare a dummy type 'DefaultVoid' which we use
   207 //   when we'd like to use 'void'. We convert it into 'void' and back
   208 //   using the templates DefaultVoidToVoid<> and VoidToDefaultVoid<>.
   209 // Workaround for (2): On VC6, the code for calling a void function is
   210 //   identical to the code for calling a non-void function in which the
   211 //   return value is never used, provided the return value is returned
   212 //   in the EAX register, rather than on the stack.
   213 //   This is true for most fundamental types such as int, enum, void *.
   214 //   Const void * is the safest option since it doesn't participate
   215 //   in any automatic conversions. But on a 16-bit compiler it might
   216 //   cause extra code to be generated, so we disable it for all compilers
   217 //   except for VC6 (and VC5).
   218 #ifdef FASTDLGT_VC6
   219 // VC6 workaround
   220 typedef const void * DefaultVoid;
   221 #else
   222 // On any other compiler, just use a normal void.
   223 typedef void DefaultVoid;
   224 #endif
   225 
   226 // Translate from 'DefaultVoid' to 'void'.
   227 // Everything else is unchanged
   228 template <class T>
   229 struct DefaultVoidToVoid { typedef T type; };
   230 
   231 template <>
   232 struct DefaultVoidToVoid<DefaultVoid> {	typedef void type; };
   233 
   234 // Translate from 'void' into 'DefaultVoid'
   235 // Everything else is unchanged
   236 template <class T>
   237 struct VoidToDefaultVoid { typedef T type; };
   238 
   239 template <>
   240 struct VoidToDefaultVoid<void> { typedef DefaultVoid type; };
   241 
   242 
   243 
   244 ////////////////////////////////////////////////////////////////////////////////
   245 //						Fast Delegates, part 1:
   246 //
   247 //		Conversion of member function pointer to a standard form
   248 //
   249 ////////////////////////////////////////////////////////////////////////////////
   250 
   251 // GenericClass is a fake class, ONLY used to provide a type.
   252 // It is vitally important that it is never defined, so that the compiler doesn't
   253 // think it can optimize the invocation. For example, Borland generates simpler
   254 // code if it knows the class only uses single inheritance.
   255 
   256 // Compilers using Microsoft's structure need to be treated as a special case.
   257 #ifdef  FASTDLGT_MICROSOFT_MFP
   258 
   259 #ifdef FASTDLGT_HASINHERITANCE_KEYWORDS
   260 	// For Microsoft and Intel, we want to ensure that it's the most efficient type of MFP
   261 	// (4 bytes), even when the /vmg option is used. Declaring an empty class
   262 	// would give 16 byte pointers in this case....
   263 	class __single_inheritance GenericClass;
   264 #endif
   265 	// ...but for Codeplay, an empty class *always* gives 4 byte pointers.
   266 	// If compiled with the /clr option ("managed C++"), the JIT compiler thinks
   267 	// it needs to load GenericClass before it can call any of its functions,
   268 	// (compiles OK but crashes at runtime!), so we need to declare an
   269 	// empty class to make it happy.
   270 	// Codeplay and VC4 can't cope with the unknown_inheritance case either.
   271 	class GenericClass {};
   272 #else
   273 	class GenericClass;
   274 #endif
   275 
   276 // The size of a single inheritance member function pointer.
   277 const int SINGLE_MEMFUNCPTR_SIZE = sizeof(void (GenericClass::*)());
   278 
   279 //						SimplifyMemFunc< >::Convert()
   280 //
   281 //	A template function that converts an arbitrary member function pointer into the
   282 //	simplest possible form of member function pointer, using a supplied 'this' pointer.
   283 //  According to the standard, this can be done legally with reinterpret_cast<>.
   284 //	For (non-standard) compilers which use member function pointers which vary in size
   285 //  depending on the class, we need to use	knowledge of the internal structure of a
   286 //  member function pointer, as used by the compiler. Template specialization is used
   287 //  to distinguish between the sizes. Because some compilers don't support partial
   288 //	template specialisation, I use full specialisation of a wrapper struct.
   289 
   290 // general case -- don't know how to convert it. Force a compile failure
   291 template <int N>
   292 struct SimplifyMemFunc {
   293 	template <class X, class XFuncType, class GenericMemFuncType>
   294 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   295 		GenericMemFuncType &bound_func) {
   296 		// Unsupported member function type -- force a compile failure.
   297 	    // (it's illegal to have a array with negative size).
   298 		typedef char ERROR_Unsupported_member_function_pointer_on_this_compiler[N-100];
   299 		return 0;
   300 	}
   301 };
   302 
   303 // For compilers where all member func ptrs are the same size, everything goes here.
   304 // For non-standard compilers, only single_inheritance classes go here.
   305 template <>
   306 struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE>  {
   307 	template <class X, class XFuncType, class GenericMemFuncType>
   308 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   309 			GenericMemFuncType &bound_func) {
   310 #if defined __DMC__
   311 		// Digital Mars doesn't allow you to cast between abitrary PMF's,
   312 		// even though the standard says you can. The 32-bit compiler lets you
   313 		// static_cast through an int, but the DOS compiler doesn't.
   314 		bound_func = horrible_cast<GenericMemFuncType>(function_to_bind);
   315 #else
   316         bound_func = reinterpret_cast<GenericMemFuncType>(function_to_bind);
   317 #endif
   318         return reinterpret_cast<GenericClass *>(pthis);
   319 	}
   320 };
   321 
   322 ////////////////////////////////////////////////////////////////////////////////
   323 //						Fast Delegates, part 1b:
   324 //
   325 //					Workarounds for Microsoft and Intel
   326 //
   327 ////////////////////////////////////////////////////////////////////////////////
   328 
   329 
   330 // Compilers with member function pointers which violate the standard (MSVC, Intel, Codeplay),
   331 // need to be treated as a special case.
   332 #ifdef FASTDLGT_MICROSOFT_MFP
   333 
   334 // We use unions to perform horrible_casts. I would like to use #pragma pack(push, 1)
   335 // at the start of each function for extra safety, but VC6 seems to ICE
   336 // intermittently if you do this inside a template.
   337 
   338 // __multiple_inheritance classes go here
   339 // Nasty hack for Microsoft and Intel (IA32 and Itanium)
   340 template<>
   341 struct SimplifyMemFunc< SINGLE_MEMFUNCPTR_SIZE + sizeof(int) >  {
   342 	template <class X, class XFuncType, class GenericMemFuncType>
   343 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   344 		GenericMemFuncType &bound_func) {
   345 		// We need to use a horrible_cast to do this conversion.
   346 		// In MSVC, a multiple inheritance member pointer is internally defined as:
   347         union {
   348 			XFuncType func;
   349 			struct {
   350 				GenericMemFuncType funcaddress; // points to the actual member function
   351 				int delta;	     // #BYTES to be added to the 'this' pointer
   352 			}s;
   353         } u;
   354 		// Check that the horrible_cast will work
   355 		typedef int ERROR_CantUsehorrible_cast[sizeof(function_to_bind)==sizeof(u.s)? 1 : -1];
   356         u.func = function_to_bind;
   357 		bound_func = u.s.funcaddress;
   358 		return reinterpret_cast<GenericClass *>(reinterpret_cast<char *>(pthis) + u.s.delta);
   359 	}
   360 };
   361 
   362 // virtual inheritance is a real nuisance. It's inefficient and complicated.
   363 // On MSVC and Intel, there isn't enough information in the pointer itself to
   364 // enable conversion to a closure pointer. Earlier versions of this code didn't
   365 // work for all cases, and generated a compile-time error instead.
   366 // But a very clever hack invented by John M. Dlugosz solves this problem.
   367 // My code is somewhat different to his: I have no asm code, and I make no
   368 // assumptions about the calling convention that is used.
   369 
   370 // In VC++ and ICL, a virtual_inheritance member pointer
   371 // is internally defined as:
   372 struct MicrosoftVirtualMFP {
   373 	void (GenericClass::*codeptr)(); // points to the actual member function
   374 	int delta;		// #bytes to be added to the 'this' pointer
   375 	int vtable_index; // or 0 if no virtual inheritance
   376 };
   377 // The CRUCIAL feature of Microsoft/Intel MFPs which we exploit is that the
   378 // m_codeptr member is *always* called, regardless of the values of the other
   379 // members. (This is *not* true for other compilers, eg GCC, which obtain the
   380 // function address from the vtable if a virtual function is being called).
   381 // Dlugosz's trick is to make the codeptr point to a probe function which
   382 // returns the 'this' pointer that was used.
   383 
   384 // Define a generic class that uses virtual inheritance.
   385 // It has a trival member function that returns the value of the 'this' pointer.
   386 struct GenericVirtualClass : virtual public GenericClass
   387 {
   388 	typedef GenericVirtualClass * (GenericVirtualClass::*ProbePtrType)();
   389 	GenericVirtualClass * GetThis() { return this; }
   390 };
   391 
   392 // __virtual_inheritance classes go here
   393 template <>
   394 struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 2*sizeof(int) >
   395 {
   396 
   397 	template <class X, class XFuncType, class GenericMemFuncType>
   398 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   399 		GenericMemFuncType &bound_func) {
   400 		union {
   401 			XFuncType func;
   402 			GenericClass* (X::*ProbeFunc)();
   403 			MicrosoftVirtualMFP s;
   404 		} u;
   405 		u.func = function_to_bind;
   406 		bound_func = reinterpret_cast<GenericMemFuncType>(u.s.codeptr);
   407 		union {
   408 			GenericVirtualClass::ProbePtrType virtfunc;
   409 			MicrosoftVirtualMFP s;
   410 		} u2;
   411 		// Check that the horrible_cast<>s will work
   412 		typedef int ERROR_CantUsehorrible_cast[sizeof(function_to_bind)==sizeof(u.s)
   413 			&& sizeof(function_to_bind)==sizeof(u.ProbeFunc)
   414 			&& sizeof(u2.virtfunc)==sizeof(u2.s) ? 1 : -1];
   415    // Unfortunately, taking the address of a MF prevents it from being inlined, so
   416    // this next line can't be completely optimised away by the compiler.
   417 		u2.virtfunc = &GenericVirtualClass::GetThis;
   418 		u.s.codeptr = u2.s.codeptr;
   419 		return (pthis->*u.ProbeFunc)();
   420 	}
   421 };
   422 
   423 #if (_MSC_VER <1300)
   424 
   425 // Nasty hack for Microsoft Visual C++ 6.0
   426 // unknown_inheritance classes go here
   427 // There is a compiler bug in MSVC6 which generates incorrect code in this case!!
   428 template <>
   429 struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 3*sizeof(int) >
   430 {
   431 	template <class X, class XFuncType, class GenericMemFuncType>
   432 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   433 		GenericMemFuncType &bound_func) {
   434 		// There is an apalling but obscure compiler bug in MSVC6 and earlier:
   435 		// vtable_index and 'vtordisp' are always set to 0 in the
   436 		// unknown_inheritance case!
   437 		// This means that an incorrect function could be called!!!
   438 		// Compiling with the /vmg option leads to potentially incorrect code.
   439 		// This is probably the reason that the IDE has a user interface for specifying
   440 		// the /vmg option, but it is disabled -  you can only specify /vmg on
   441 		// the command line. In VC1.5 and earlier, the compiler would ICE if it ever
   442 		// encountered this situation.
   443 		// It is OK to use the /vmg option if /vmm or /vms is specified.
   444 
   445 		// Fortunately, the wrong function is only called in very obscure cases.
   446 		// It only occurs when a derived class overrides a virtual function declared
   447 		// in a virtual base class, and the member function
   448 		// points to the *Derived* version of that function. The problem can be
   449 		// completely averted in 100% of cases by using the *Base class* for the
   450 		// member fpointer. Ie, if you use the base class as an interface, you'll
   451 		// stay out of trouble.
   452 		// Occasionally, you might want to point directly to a derived class function
   453 		// that isn't an override of a base class. In this case, both vtable_index
   454 		// and 'vtordisp' are zero, but a virtual_inheritance pointer will be generated.
   455 		// We can generate correct code in this case. To prevent an incorrect call from
   456 		// ever being made, on MSVC6 we generate a warning, and call a function to
   457 		// make the program crash instantly.
   458 		typedef char ERROR_VC6CompilerBug[-100];
   459 		return 0;
   460 	}
   461 };
   462 
   463 
   464 #else
   465 
   466 // Nasty hack for Microsoft and Intel (IA32 and Itanium)
   467 // unknown_inheritance classes go here
   468 // This is probably the ugliest bit of code I've ever written. Look at the casts!
   469 // There is a compiler bug in MSVC6 which prevents it from using this code.
   470 template <>
   471 struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 3*sizeof(int) >
   472 {
   473 	template <class X, class XFuncType, class GenericMemFuncType>
   474 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   475 			GenericMemFuncType &bound_func) {
   476 		// The member function pointer is 16 bytes long. We can't use a normal cast, but
   477 		// we can use a union to do the conversion.
   478 		union {
   479 			XFuncType func;
   480 			// In VC++ and ICL, an unknown_inheritance member pointer
   481 			// is internally defined as:
   482 			struct {
   483 				GenericMemFuncType m_funcaddress; // points to the actual member function
   484 				int delta;		// #bytes to be added to the 'this' pointer
   485 				int vtordisp;		// #bytes to add to 'this' to find the vtable
   486 				int vtable_index; // or 0 if no virtual inheritance
   487 			} s;
   488 		} u;
   489 		// Check that the horrible_cast will work
   490 		typedef int ERROR_CantUsehorrible_cast[sizeof(XFuncType)==sizeof(u.s)? 1 : -1];
   491 		u.func = function_to_bind;
   492 		bound_func = u.s.funcaddress;
   493 		int virtual_delta = 0;
   494 		if (u.s.vtable_index) { // Virtual inheritance is used
   495 			// First, get to the vtable.
   496 			// It is 'vtordisp' bytes from the start of the class.
   497 			const int * vtable = *reinterpret_cast<const int *const*>(
   498 				reinterpret_cast<const char *>(pthis) + u.s.vtordisp );
   499 
   500 			// 'vtable_index' tells us where in the table we should be looking.
   501 			virtual_delta = u.s.vtordisp + *reinterpret_cast<const int *>(
   502 				reinterpret_cast<const char *>(vtable) + u.s.vtable_index);
   503 		}
   504 		// The int at 'virtual_delta' gives us the amount to add to 'this'.
   505         // Finally we can add the three components together. Phew!
   506         return reinterpret_cast<GenericClass *>(
   507 			reinterpret_cast<char *>(pthis) + u.s.delta + virtual_delta);
   508 	};
   509 };
   510 #endif // MSVC 7 and greater
   511 
   512 #endif // MS/Intel hacks
   513 
   514 }  // namespace detail
   515 
   516 ////////////////////////////////////////////////////////////////////////////////
   517 //						Fast Delegates, part 2:
   518 //
   519 //	Define the delegate storage, and cope with static functions
   520 //
   521 ////////////////////////////////////////////////////////////////////////////////
   522 
   523 // DelegateMemento -- an opaque structure which can hold an arbitary delegate.
   524 // It knows nothing about the calling convention or number of arguments used by
   525 // the function pointed to.
   526 // It supplies comparison operators so that it can be stored in STL collections.
   527 // It cannot be set to anything other than null, nor invoked directly:
   528 //   it must be converted to a specific delegate.
   529 
   530 // Implementation:
   531 // There are two possible implementations: the Safe method and the Evil method.
   532 //				DelegateMemento - Safe version
   533 //
   534 // This implementation is standard-compliant, but a bit tricky.
   535 // A static function pointer is stored inside the class.
   536 // Here are the valid values:
   537 // +-- Static pointer --+--pThis --+-- pMemFunc-+-- Meaning------+
   538 // |   0				|  0       |   0        | Empty          |
   539 // |   !=0              |(dontcare)|  Invoker   | Static function|
   540 // |   0                |  !=0     |  !=0*      | Method call    |
   541 // +--------------------+----------+------------+----------------+
   542 //  * For Metrowerks, this can be 0. (first virtual function in a 
   543 //       single_inheritance class).
   544 // When stored stored inside a specific delegate, the 'dontcare' entries are replaced
   545 // with a reference to the delegate itself. This complicates the = and == operators
   546 // for the delegate class.
   547 
   548 //				DelegateMemento - Evil version
   549 //
   550 // For compilers where data pointers are at least as big as code pointers, it is
   551 // possible to store the function pointer in the this pointer, using another
   552 // horrible_cast. In this case the DelegateMemento implementation is simple:
   553 // +--pThis --+-- pMemFunc-+-- Meaning---------------------+
   554 // |    0     |  0         | Empty                         |
   555 // |  !=0     |  !=0*      | Static function or method call|
   556 // +----------+------------+-------------------------------+
   557 //  * For Metrowerks, this can be 0. (first virtual function in a 
   558 //       single_inheritance class).
   559 // Note that the Sun C++ and MSVC documentation explicitly state that they 
   560 // support static_cast between void * and function pointers.
   561 
   562 class DelegateMemento {
   563 protected:
   564 	// the data is protected, not private, because many
   565 	// compilers have problems with template friends.
   566 	typedef void (detail::GenericClass::*GenericMemFuncType)(); // arbitrary MFP.
   567 	detail::GenericClass *m_pthis;
   568 	GenericMemFuncType m_pFunction;
   569 
   570 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   571 	typedef void (*GenericFuncPtr)(); // arbitrary code pointer
   572 	GenericFuncPtr m_pStaticFunction;
   573 #endif
   574 
   575 public:
   576 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   577 	DelegateMemento() : m_pthis(0), m_pFunction(0), m_pStaticFunction(0) {};
   578 	void clear() {
   579 		m_pthis=0; m_pFunction=0; m_pStaticFunction=0;
   580 	}
   581 #else
   582 	DelegateMemento() : m_pthis(0), m_pFunction(0) {};
   583 	void clear() {	m_pthis=0; m_pFunction=0;	}
   584 #endif
   585 public:
   586 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   587 	inline bool IsEqual (const DelegateMemento &x) const{
   588 	    // We have to cope with the static function pointers as a special case
   589 		if (m_pFunction!=x.m_pFunction) return false;
   590 		// the static function ptrs must either both be equal, or both be 0.
   591 		if (m_pStaticFunction!=x.m_pStaticFunction) return false;
   592 		if (m_pStaticFunction!=0) return m_pthis==x.m_pthis;
   593 		else return true;
   594 	}
   595 #else // Evil Method
   596 	inline bool IsEqual (const DelegateMemento &x) const{
   597 		return m_pthis==x.m_pthis && m_pFunction==x.m_pFunction;
   598 	}
   599 #endif
   600 	// Provide a strict weak ordering for DelegateMementos.
   601 	inline bool IsLess(const DelegateMemento &right) const {
   602 		// deal with static function pointers first
   603 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   604 		if (m_pStaticFunction !=0 || right.m_pStaticFunction!=0)
   605 				return m_pStaticFunction < right.m_pStaticFunction;
   606 #endif
   607 		if (m_pthis !=right.m_pthis) return m_pthis < right.m_pthis;
   608 	// There are no ordering operators for member function pointers,
   609 	// but we can fake one by comparing each byte. The resulting ordering is
   610 	// arbitrary (and compiler-dependent), but it permits storage in ordered STL containers.
   611 		return memcmp(&m_pFunction, &right.m_pFunction, sizeof(m_pFunction)) < 0;
   612 
   613 	}
   614 	// BUGFIX (Mar 2005):
   615 	// We can't just compare m_pFunction because on Metrowerks,
   616 	// m_pFunction can be zero even if the delegate is not empty!
   617 	inline bool operator ! () const		// Is it bound to anything?
   618 	{ return m_pthis==0 && m_pFunction==0; }
   619 	inline bool empty() const		// Is it bound to anything?
   620 	{ return m_pthis==0 && m_pFunction==0; }
   621 public:
   622 	DelegateMemento & operator = (const DelegateMemento &right)  {
   623 		SetMementoFrom(right);
   624 		return *this;
   625 	}
   626 	inline bool operator <(const DelegateMemento &right) {
   627 		return IsLess(right);
   628 	}
   629 	inline bool operator >(const DelegateMemento &right) {
   630 		return right.IsLess(*this);
   631 	}
   632 	DelegateMemento (const DelegateMemento &right)  :
   633 		m_pthis(right.m_pthis), m_pFunction(right.m_pFunction)
   634 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   635 		, m_pStaticFunction (right.m_pStaticFunction)
   636 #endif
   637 		{}
   638 protected:
   639 	void SetMementoFrom(const DelegateMemento &right)  {
   640 		m_pFunction = right.m_pFunction;
   641 		m_pthis = right.m_pthis;
   642 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   643 		m_pStaticFunction = right.m_pStaticFunction;
   644 #endif
   645 	}
   646 };
   647 
   648 
   649 //						ClosurePtr<>
   650 //
   651 // A private wrapper class that adds function signatures to DelegateMemento.
   652 // It's the class that does most of the actual work.
   653 // The signatures are specified by:
   654 // GenericMemFunc: must be a type of GenericClass member function pointer.
   655 // StaticFuncPtr:  must be a type of function pointer with the same signature
   656 //                 as GenericMemFunc.
   657 // UnvoidStaticFuncPtr: is the same as StaticFuncPtr, except on VC6
   658 //                 where it never returns void (returns DefaultVoid instead).
   659 
   660 // An outer class, FastDelegateN<>, handles the invoking and creates the
   661 // necessary typedefs.
   662 // This class does everything else.
   663 
   664 namespace detail {
   665 
   666 template < class GenericMemFunc, class StaticFuncPtr, class UnvoidStaticFuncPtr>
   667 class ClosurePtr : public DelegateMemento {
   668 public:
   669 	// These functions are for setting the delegate to a member function.
   670 
   671 	// Here's the clever bit: we convert an arbitrary member function into a
   672 	// standard form. XMemFunc should be a member function of class X, but I can't
   673 	// enforce that here. It needs to be enforced by the wrapper class.
   674 	template < class X, class XMemFunc >
   675 	inline void bindmemfunc(X *pthis, XMemFunc function_to_bind ) {
   676 		m_pthis = SimplifyMemFunc< sizeof(function_to_bind) >
   677 			::Convert(pthis, function_to_bind, m_pFunction);
   678 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   679 		m_pStaticFunction = 0;
   680 #endif
   681 	}
   682 	// For const member functions, we only need a const class pointer.
   683 	// Since we know that the member function is const, it's safe to
   684 	// remove the const qualifier from the 'this' pointer with a const_cast.
   685 	// VC6 has problems if we just overload 'bindmemfunc', so we give it a different name.
   686 	template < class X, class XMemFunc>
   687 	inline void bindconstmemfunc(const X *pthis, XMemFunc function_to_bind) {
   688 		m_pthis= SimplifyMemFunc< sizeof(function_to_bind) >
   689 			::Convert(const_cast<X*>(pthis), function_to_bind, m_pFunction);
   690 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   691 		m_pStaticFunction = 0;
   692 #endif
   693 	}
   694 #ifdef FASTDELEGATE_GCC_BUG_8271	// At present, GCC doesn't recognize constness of MFPs in templates
   695 	template < class X, class XMemFunc>
   696 	inline void bindmemfunc(const X *pthis, XMemFunc function_to_bind) {
   697 		bindconstmemfunc(pthis, function_to_bind);
   698 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   699 		m_pStaticFunction = 0;
   700 #endif
   701 	}
   702 #endif
   703 	// These functions are required for invoking the stored function
   704 	inline GenericClass *GetClosureThis() const { return m_pthis; }
   705 	inline GenericMemFunc GetClosureMemPtr() const { return reinterpret_cast<GenericMemFunc>(m_pFunction); }
   706 
   707 // There are a few ways of dealing with static function pointers.
   708 // There's a standard-compliant, but tricky method.
   709 // There's also a straightforward hack, that won't work on DOS compilers using the
   710 // medium memory model. It's so evil that I can't recommend it, but I've
   711 // implemented it anyway because it produces very nice asm code.
   712 
   713 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   714 
   715 //				ClosurePtr<> - Safe version
   716 //
   717 // This implementation is standard-compliant, but a bit tricky.
   718 // I store the function pointer inside the class, and the delegate then
   719 // points to itself. Whenever the delegate is copied, these self-references
   720 // must be transformed, and this complicates the = and == operators.
   721 public:
   722 	// The next two functions are for operator ==, =, and the copy constructor.
   723 	// We may need to convert the m_pthis pointers, so that
   724 	// they remain as self-references.
   725 	template< class DerivedClass >
   726 	inline void CopyFrom (DerivedClass *pParent, const DelegateMemento &x) {
   727 		SetMementoFrom(x);
   728 		if (m_pStaticFunction!=0) {
   729 			// transform self references...
   730 			m_pthis=reinterpret_cast<GenericClass *>(pParent);
   731 		}
   732 	}
   733 	// For static functions, the 'static_function_invoker' class in the parent
   734 	// will be called. The parent then needs to call GetStaticFunction() to find out
   735 	// the actual function to invoke.
   736 	template < class DerivedClass, class ParentInvokerSig >
   737 	inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker,
   738 				StaticFuncPtr function_to_bind ) {
   739 		if (function_to_bind==0) { // cope with assignment to 0
   740 			m_pFunction=0;
   741 		} else {
   742 			bindmemfunc(pParent, static_function_invoker);
   743         }
   744 		m_pStaticFunction=reinterpret_cast<GenericFuncPtr>(function_to_bind);
   745 	}
   746 	inline UnvoidStaticFuncPtr GetStaticFunction() const {
   747 		return reinterpret_cast<UnvoidStaticFuncPtr>(m_pStaticFunction);
   748 	}
   749 #else
   750 
   751 //				ClosurePtr<> - Evil version
   752 //
   753 // For compilers where data pointers are at least as big as code pointers, it is
   754 // possible to store the function pointer in the this pointer, using another
   755 // horrible_cast. Invocation isn't any faster, but it saves 4 bytes, and
   756 // speeds up comparison and assignment. If C++ provided direct language support
   757 // for delegates, they would produce asm code that was almost identical to this.
   758 // Note that the Sun C++ and MSVC documentation explicitly state that they
   759 // support static_cast between void * and function pointers.
   760 
   761 	template< class DerivedClass >
   762 	inline void CopyFrom (DerivedClass *pParent, const DelegateMemento &right) {
   763 		SetMementoFrom(right);
   764 	}
   765 	// For static functions, the 'static_function_invoker' class in the parent
   766 	// will be called. The parent then needs to call GetStaticFunction() to find out
   767 	// the actual function to invoke.
   768 	// ******** EVIL, EVIL CODE! *******
   769 	template < 	class DerivedClass, class ParentInvokerSig>
   770 	inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker,
   771 				StaticFuncPtr function_to_bind) {
   772 		if (function_to_bind==0) { // cope with assignment to 0
   773 			m_pFunction=0;
   774 		} else { 
   775 		   // We'll be ignoring the 'this' pointer, but we need to make sure we pass
   776 		   // a valid value to bindmemfunc().
   777 			bindmemfunc(pParent, static_function_invoker);
   778         }
   779 
   780 		// WARNING! Evil hack. We store the function in the 'this' pointer!
   781 		// Ensure that there's a compilation failure if function pointers
   782 		// and data pointers have different sizes.
   783 		// If you get this error, you need to #undef FASTDELEGATE_USESTATICFUNCTIONHACK.
   784 		typedef int ERROR_CantUseEvilMethod[sizeof(GenericClass *)==sizeof(function_to_bind) ? 1 : -1];
   785 		m_pthis = horrible_cast<GenericClass *>(function_to_bind);
   786 		// MSVC, SunC++ and DMC accept the following (non-standard) code:
   787 //		m_pthis = static_cast<GenericClass *>(static_cast<void *>(function_to_bind));
   788 		// BCC32, Comeau and DMC accept this method. MSVC7.1 needs __int64 instead of long
   789 //		m_pthis = reinterpret_cast<GenericClass *>(reinterpret_cast<long>(function_to_bind));
   790 	}
   791 	// ******** EVIL, EVIL CODE! *******
   792 	// This function will be called with an invalid 'this' pointer!!
   793 	// We're just returning the 'this' pointer, converted into
   794 	// a function pointer!
   795 	inline UnvoidStaticFuncPtr GetStaticFunction() const {
   796 		// Ensure that there's a compilation failure if function pointers
   797 		// and data pointers have different sizes.
   798 		// If you get this error, you need to #undef FASTDELEGATE_USESTATICFUNCTIONHACK.
   799 		typedef int ERROR_CantUseEvilMethod[sizeof(UnvoidStaticFuncPtr)==sizeof(this) ? 1 : -1];
   800 		return horrible_cast<UnvoidStaticFuncPtr>(this);
   801 	}
   802 #endif // !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   803 
   804 	// Does the closure contain this static function?
   805 	inline bool IsEqualToStaticFuncPtr(StaticFuncPtr funcptr){
   806 		if (funcptr==0) return empty();
   807 	// For the Evil method, if it doesn't actually contain a static function, this will return an arbitrary
   808 	// value that is not equal to any valid function pointer.
   809 		else return funcptr==reinterpret_cast<StaticFuncPtr>(GetStaticFunction());
   810 	}
   811 };
   812 
   813 
   814 } // namespace detail
   815 
   816 ////////////////////////////////////////////////////////////////////////////////
   817 //						Fast Delegates, part 3:
   818 //
   819 //				Wrapper classes to ensure type safety
   820 //
   821 ////////////////////////////////////////////////////////////////////////////////
   822 
   823 
   824 // Once we have the member function conversion templates, it's easy to make the
   825 // wrapper classes. So that they will work with as many compilers as possible,
   826 // the classes are of the form
   827 //   FastDelegate3<int, char *, double>
   828 // They can cope with any combination of parameters. The max number of parameters
   829 // allowed is 8, but it is trivial to increase this limit.
   830 // Note that we need to treat const member functions seperately.
   831 // All this class does is to enforce type safety, and invoke the delegate with
   832 // the correct list of parameters.
   833 
   834 // Because of the weird rule about the class of derived member function pointers,
   835 // you sometimes need to apply a downcast to the 'this' pointer.
   836 // This is the reason for the use of "implicit_cast<X*>(pthis)" in the code below.
   837 // If CDerivedClass is derived from CBaseClass, but doesn't override SimpleVirtualFunction,
   838 // without this trick you'd need to write:
   839 //		MyDelegate(static_cast<CBaseClass *>(&d), &CDerivedClass::SimpleVirtualFunction);
   840 // but with the trick you can write
   841 //		MyDelegate(&d, &CDerivedClass::SimpleVirtualFunction);
   842 
   843 // RetType is the type the compiler uses in compiling the template. For VC6,
   844 // it cannot be void. DesiredRetType is the real type which is returned from
   845 // all of the functions. It can be void.
   846 
   847 // Implicit conversion to "bool" is achieved using the safe_bool idiom,
   848 // using member data pointers (MDP). This allows "if (dg)..." syntax
   849 // Because some compilers (eg codeplay) don't have a unique value for a zero
   850 // MDP, an extra padding member is added to the SafeBool struct.
   851 // Some compilers (eg VC6) won't implicitly convert from 0 to an MDP, so
   852 // in that case the static function constructor is not made explicit; this
   853 // allows "if (dg==0) ..." to compile.
   854 
   855 @VARARGS
   856 template<@CLASSARGS, class RetType=detail::DefaultVoid>
   857 class FastDelegate@NUM {
   858 private:
   859 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
   860 	typedef DesiredRetType (*StaticFunctionPtr)(@FUNCARGS);
   861 	typedef RetType (*UnvoidStaticFunctionPtr)(@FUNCARGS);
   862 	typedef RetType (detail::GenericClass::*GenericMemFn)(@FUNCARGS);
   863 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   864 	ClosureType m_Closure;
   865 public:
   866 	// Typedefs to aid generic programming
   867 	typedef FastDelegate@NUM type;
   868 
   869 	// Construction and comparison functions
   870 	FastDelegate@NUM() { clear(); }
   871 	FastDelegate@NUM(const FastDelegate@NUM &x) {
   872 		m_Closure.CopyFrom(this, x.m_Closure); }
   873 	void operator = (const FastDelegate@NUM &x)  {
   874 		m_Closure.CopyFrom(this, x.m_Closure); }
   875 	bool operator ==(const FastDelegate@NUM &x) const {
   876 		return m_Closure.IsEqual(x.m_Closure);	}
   877 	bool operator !=(const FastDelegate@NUM &x) const {
   878 		return !m_Closure.IsEqual(x.m_Closure); }
   879 	bool operator <(const FastDelegate@NUM &x) const {
   880 		return m_Closure.IsLess(x.m_Closure);	}
   881 	bool operator >(const FastDelegate@NUM &x) const {
   882 		return x.m_Closure.IsLess(m_Closure);	}
   883 	// Binding to non-const member functions
   884 	template < class X, class Y >
   885 	FastDelegate@NUM(Y *pthis, DesiredRetType (X::* function_to_bind)(@FUNCARGS) ) {
   886 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
   887 	template < class X, class Y >
   888 	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(@FUNCARGS)) {
   889 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
   890 	// Binding to const member functions.
   891 	template < class X, class Y >
   892 	FastDelegate@NUM(const Y *pthis, DesiredRetType (X::* function_to_bind)(@FUNCARGS) const) {
   893 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
   894 	template < class X, class Y >
   895 	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(@FUNCARGS) const) {
   896 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   897 	// Static functions. We convert them into a member function call.
   898 	// This constructor also provides implicit conversion
   899 	FastDelegate@NUM(DesiredRetType (*function_to_bind)(@FUNCARGS) ) {
   900 		bind(function_to_bind);	}
   901 	// for efficiency, prevent creation of a temporary
   902 	void operator = (DesiredRetType (*function_to_bind)(@FUNCARGS) ) {
   903 		bind(function_to_bind);	}
   904 	inline void bind(DesiredRetType (*function_to_bind)(@FUNCARGS)) {
   905 		m_Closure.bindstaticfunc(this, &FastDelegate@NUM::InvokeStaticFunction,
   906 			function_to_bind); }
   907 	// Invoke the delegate
   908 	RetType operator() (@FUNCARGS) const {
   909 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(@INVOKEARGS); }
   910 	// Implicit conversion to "bool" using the safe_bool idiom
   911 private:
   912 	typedef struct SafeBoolStruct {
   913 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   914 		StaticFunctionPtr m_nonzero;
   915 	} UselessTypedef;
   916     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   917 public:
   918 	operator unspecified_bool_type() const {
   919         return empty()? 0: &SafeBoolStruct::m_nonzero;
   920     }
   921 	// necessary to allow ==0 to work despite the safe_bool idiom
   922 	inline bool operator==(StaticFunctionPtr funcptr) {
   923 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   924 	inline bool operator!=(StaticFunctionPtr funcptr) { 
   925 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   926 	inline bool operator ! () const	{	// Is it bound to anything?
   927 			return !m_Closure; }
   928 	inline bool empty() const	{
   929 			return !m_Closure; }
   930 	void clear() { m_Closure.clear();}
   931 	// Conversion to and from the DelegateMemento storage class
   932 	const DelegateMemento & GetMemento() { return m_Closure; }
   933 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
   934 
   935 private:	// Invoker for static functions
   936 	RetType InvokeStaticFunction(@FUNCARGS) const {
   937 	return (*(m_Closure.GetStaticFunction()))(@INVOKEARGS); }
   938 };
   939 
   940 @ENDVAR
   941 
   942 ////////////////////////////////////////////////////////////////////////////////
   943 //						Fast Delegates, part 4:
   944 //
   945 //				FastDelegate<> class (Original author: Jody Hagins)
   946 //	Allows boost::function style syntax like:
   947 //			FastDelegate< double (int, long) >
   948 // instead of:
   949 //			FastDelegate2< int, long, double >
   950 //
   951 ////////////////////////////////////////////////////////////////////////////////
   952 
   953 #ifdef FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
   954 
   955 // Declare FastDelegate as a class template.  It will be specialized
   956 // later for all number of arguments.
   957 template <typename Signature>
   958 class FastDelegate;
   959 
   960 @VARARGS
   961 // Specialization to allow use of
   962 // FastDelegate< R ( @SELARGS ) >
   963 // instead of
   964 // FastDelegate@NUM < @SELARGS, R >
   965 template<typename R, @CLASSARGS>
   966 class FastDelegate< R ( @SELARGS ) >
   967   // Inherit from FastDelegate@NUM so that it can be treated just like a FastDelegate@NUM
   968   : public FastDelegate@NUM < @SELARGS, R >
   969 {
   970 public:
   971   // Make using the base type a bit easier via typedef.
   972   typedef FastDelegate@NUM < @SELARGS, R > BaseType;
   973 
   974   // Allow users access to the specific type of this delegate.
   975   typedef FastDelegate SelfType;
   976 
   977   // Mimic the base class constructors.
   978   FastDelegate() : BaseType() { }
   979 
   980   template < class X, class Y >
   981   FastDelegate(Y * pthis,
   982     R (X::* function_to_bind)( @FUNCARGS ))
   983     : BaseType(pthis, function_to_bind)  { }
   984 
   985   template < class X, class Y >
   986   FastDelegate(const Y *pthis,
   987       R (X::* function_to_bind)( @FUNCARGS ) const)
   988     : BaseType(pthis, function_to_bind)
   989   {  }
   990 
   991   FastDelegate(R (*function_to_bind)( @FUNCARGS ))
   992     : BaseType(function_to_bind)  { }
   993   void operator = (const BaseType &x)  {
   994 		*static_cast<BaseType*>(this) = x; }
   995 };
   996 
   997 @ENDVAR
   998 
   999 #endif //FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
  1000 
  1001 ////////////////////////////////////////////////////////////////////////////////
  1002 //						Fast Delegates, part 5:
  1003 //
  1004 //				MakeDelegate() helper function
  1005 //
  1006 //			MakeDelegate(&x, &X::func) returns a fastdelegate of the type
  1007 //			necessary for calling x.func() with the correct number of arguments.
  1008 //			This makes it possible to eliminate many typedefs from user code.
  1009 //
  1010 ////////////////////////////////////////////////////////////////////////////////
  1011 
  1012 // Also declare overloads of a MakeDelegate() global function to
  1013 // reduce the need for typedefs.
  1014 // We need seperate overloads for const and non-const member functions.
  1015 // Also, because of the weird rule about the class of derived member function pointers,
  1016 // implicit downcasts may need to be applied later to the 'this' pointer.
  1017 // That's why two classes (X and Y) appear in the definitions. Y must be implicitly
  1018 // castable to X.
  1019 
  1020 // Workaround for VC6. VC6 needs void return types converted into DefaultVoid.
  1021 // GCC 3.2 and later won't compile this unless it's preceded by 'typename',
  1022 // but VC6 doesn't allow 'typename' in this context.
  1023 // So, I have to use a macro.
  1024 
  1025 #ifdef FASTDLGT_VC6
  1026 #define FASTDLGT_RETTYPE detail::VoidToDefaultVoid<RetType>::type
  1027 #else
  1028 #define FASTDLGT_RETTYPE RetType
  1029 #endif
  1030 
  1031 @VARARGS
  1032 template <class X, class Y, @CLASSARGS, class RetType>
  1033 FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(@FUNCARGS)) {
  1034 	return FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE>(x, func);
  1035 }
  1036 
  1037 template <class X, class Y, @CLASSARGS, class RetType>
  1038 FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(@FUNCARGS) const) {
  1039 	return FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE>(x, func);
  1040 }
  1041 
  1042 template <@CLASSARGS, class RetType>
  1043 FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(@FUNCARGS)) {
  1044 	return FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE>(func);
  1045 }
  1046 
  1047 @ENDVAR
  1048 
  1049  // clean up after ourselves...
  1050 #undef FASTDLGT_RETTYPE
  1051 
  1052 } // namespace fastdelegate
  1053 
  1054 #endif // !defined(FASTDELEGATE_H)