(SOLVED) Advanced macro/preprocessor help on g++

#include <iostream>using namespace std;// Commonly used pre-defined characters to seperate repeating code.// For exmple, the comma seperate is used when repeating function // arguments (ie, Function(A1 a1, A2 a2, A3 a3, ...) )// // The empty seperator is used when there doesn't need to be any// characters between repeating code, such as repeating functions.#define MACRO_EMPTY_SEPERATOR_DISPLAY #define MACRO_COMMA_SEPERATOR_DISPLAY ,// Commonly used pre-defined code to be repeated.  For example, the// MACRO_FUNCTION_PARAMETER is used to repeat function parameters// (ie, Function(A1 a1, A2 a2, A3 a3, ...) ).#define MACRO_TEMPLATE_PARAMETER(num) typename A##num#define MACRO_FUNCTION_PARAMETER(num) A##num a##num#define MACRO_FUNCTION_ARGUMENT(num) a##num// The perform the actual repetition.  Each macro will continuously// call the preceding macro until the MACRO_REPEAT_0 is called, at// which point each macro will write the seperator followed by the// macro, passing the repitition number.#define MACRO_REPEAT_0(begin_seperator, seperator, macro) #define MACRO_REPEAT_1(begin_seperator, seperator, macro) begin_seperator##_DISPLAY macro(0)#define MACRO_REPEAT_2(begin_seperator, seperator, macro) MACRO_REPEAT_1(begin_seperator, seperator, macro) seperator##_DISPLAY macro(1)#define MACRO_REPEAT_3(begin_seperator, seperator, macro) MACRO_REPEAT_2(begin_seperator, seperator, macro) seperator##_DISPLAY macro(2)#define MACRO_REPEAT_4(begin_seperator, seperator, macro) MACRO_REPEAT_3(begin_seperator, seperator, macro) seperator##_DISPLAY macro(3)// User called macros that uses the above macros to perform the// desired work.  MACRO_LIST is primarily used to list template// or function arguments, where each argument is seperated by// a comma (ie, Function(A1 a1, A2 a2, A3 a3, ...) ).// MACRO_LIST_APPEND does the same as MACRO_LIST, except it is// used to append arguments onto an existing argument, thus all// code is preceded by a comma (ie, Function(int x, A1 a1, A2 a2, ...) ).// MACRO_REPEAT simply repeats code not using any seperating// characters.#define MACRO_LIST(num, macro) MACRO_REPEAT_##num(MACRO_EMPTY_SEPERATOR, MACRO_COMMA_SEPERATOR, macro)#define MACRO_LIST_APPEND(num, macro) MACRO_REPEAT_##num(MACRO_COMMA_SEPERATOR, MACRO_COMMA_SEPERATOR, macro)#define MACRO_REPEAT(num, macro) MACRO_REPEAT_##num(MACRO_EMPTY_SEPERATOR, MACRO_EMPTY_SEPERATOR, macro)// This creates a multiple CreateObject function using function// template overloading.  Basically, it allows a user to specify// the object the function will create as well as any number// of parameters to pass to that objects constructor.  When the// macros unroll this function, it will look similar to this:// // template<typename ClassType>// ClassType *CreateObject()// {//    return new ClassType();// }// // template<typename ClassType, typename A1>;// ClassType *CreateObject(A1 a1)// {//    return new ClassType(a1);// }// // template<typename ClassType, typename A1, typename A2>// ClassType *CreateObject(A1 a1, A2 a2)// {//    return new ClassType(a1, a2);// }// ...//// Note the macro below uses the \ to span multiple lines,// but the source tags are removing them.  To compile you MUST// re-add these \ tags#define CREATEOBJECT(num)   template<typename ClassType MACRO_LIST_APPEND(num, MACRO_TEMPLATE_PARAMETER)>   ClassType *CreateObject(MACRO_LIST(num, MACRO_FUNCTION_PARAMETER))   {      return new ClassType( MACRO_LIST(num, MACRO_FUNCTION_ARGUMENT) );   }// Generate 3 instances of this function, one which takes no// constructor params, one which takes one param, and the// last which takes two constructor parameters.                                                                                              MACRO_REPEAT(3, CREATEOBJECT) int main (int argc, char *argv[]){	// Create an integer, passing 42 as a constructor parameter	int *ptr = CreateObject<int>(42);	return(0);}

#define MRF_INTERNAL_USE_ONLY__CREATE_OVERLOAD(z, i, data)template <typename R BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i, typename T)>static boost::shared_ptr<R> create(BOOST_PP_ENUM_BINARY_PARAMS(i, T, t)) {boost::shared_ptr<R> nrv(new R(BOOST_PP_ENUM_PARAMS(i, t)));return nrv; }#define MRF_INTERNAL_USE_ONLY__CREATE_DEFINITIONS(num)BOOST_PP_REPEAT(BOOST_PP_ADD(num, 1), MRF_INTERNAL_USE_ONLY__CREATE_OVERLOAD, ~)class SomeClass{public:	// Support arg lists from 0-10 arguments	MRF_INTERNAL_USE_ONLY__CREATE_DEFINITIONS(10);private:};