class MyClass
{ 
  int A; 
};

int main( void )
{
 MyClass test;
 return 0;
}

    #define DECL_MUL(z, n, text) BOOST_PP_IF(n, * n, 1)
    #define FACTORIAL(n) BOOST_PP_REPEAT(BOOST_PP_INC(n), DECL_MUL, )

$ cvs -d:pserver:anonymous@chaos-pp.cvs.sourceforge.net:/cvsroot/chaos-pp login 
$ cvs -z3 -d:pserver:anonymous@chaos-pp.cvs.sourceforge.net:/cvsroot/chaos-pp co -P chaos-pp
$ cvs -z3 -d:pserver:anonymous@chaos-pp.cvs.sourceforge.net:/cvsroot/chaos-pp co -P order-pp
$ cd order-pp/example
$ grep -A 6 'int main' fibonacci.c
int main(void) {
   printf
     ("The 500th Fibonacci number is "
      ORDER_PP(8stringize(8to_lit(8fib(8nat(5,0,0)))))
      ".\n");
   return 0;
}
$ cpp -I../inc fibonacci.c 2>/dev/null | grep -A 6 'int main' 
int main(void) {
   printf
     ("The 500th Fibonacci number is "
      "139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125"
      ".\n");
   return 0;
}

if ( 4 == sizeof int ) ...

СМ>if ( 4 == sizeof int ) ...
СМ>

if (sizeof (void *) == 4)
{
    // x86-specific code
}

else if (sizeof (void *) == 8)
{
    // amd64-specific code
}

else
{
    // throw ?
}

extern struct CleanupStack * CurrentCleanupFrame;
extern struct CleanupStack * GlobalCleanupFrame;

#define FUNCTION_BEGIN(type)                                                                                    \
    type retValue;                                                                                                            \
    struct CleanupStack * CurrentCleanupFrame = CleanupStack_create()
    
#define FUNCTION_END()                                                                                                                                                \
    function_end:                                                                                                                                                                \
        if (CurrentCleanupFrame != GlobalCleanupFrame) CleanupStack_destroy(CurrentCleanupFrame);    \
        return retValue

#define RETURN(value)        \
    retValue = (value);        \
    goto function_end
    
#define MALLOC(size)    \
    CleanupStack_register(CurrentCleanupFrame, malloc(size))
    
int some_function()
{
    FUNCTION_BEGIN(int);
    
    FUNCTION_END();
}

struct test {
   test() { /*can throw*/ }
   ~test() { /*not throw*/ }
};

try {
   test x,y,z;
} catch (...) {
   //
}

#define TRY /*save context*/ if ( sigsetjmp(context, 0) == 0 ) { /*save context*/
#define CATCH } else {
#define END_TRY } /*restore context*/

typedef struct test {} test;

void construct_test ( sigjmp_buf * context, test * ptr ) { /* can throw */ }
void destruct_test ( test * ptr ) { /* not throw */ }

sigjmp_buf context;

TRY {
  test x, y, z;
  TRY {
    construct_test( &context, &x );
    TRY {
      construct_test( &context, &y );
      TRY {
//...
      } CATCH { } END_TRY;
      desctuct_test( &y );
    } CATCH { } END_TRY;
    desctuct_test( &x );
  } CATCH { } END_TRY;

} CATCH { } END_TRY;

//macro
#define getHashCode(T) hash(#T)
#define nuovo(T)(construct(sizeof(T),getHashCode(#T)),(T*)currentPointer) 
#define FUNCTION(f)(callPrologue(),f)
#define CALL(f) f##,##callEpilogue()

//base notions
int hash(char* values)
{
   int count = 0;
   char* p = values;
   while(*p!=0)
   {
      count += *p;
      p++;
   }
   return count;
}
typedef struct _Node
{
   int elementTypeHash;
   void* elementPointer;
   struct _Node* nextNode;
}Node;
typedef struct _NodeHolder
{
   Node* firstNode;
   Node* lastNode;
}NodeHolder;
//global state variables
NodeHolder holder;
Node* currentNode;
void* currentPointer;
Node* beforeCallNode;
//global functions;
void globalStateInit()
{
   currentNode = NULL;
   holder.firstNode = holder.lastNode = NULL;
}
//construct, destruct 
void construct(int size, int hashCode)
{
   currentPointer = malloc(size);
   currentNode = (Node*)malloc(sizeof(Node));
   currentNode->elementTypeHash = getHashCode(int);
   currentNode->elementPointer = currentPointer;
   currentNode->nextNode = 0;
   if(holder.firstNode == NULL)
   {
      holder.firstNode = holder.lastNode = currentNode;
   }
   else
   {
      holder.lastNode->nextNode = currentNode;
      holder.lastNode = currentNode;
   }
}
void destructElement(int code, void* pointer)
{
   //поиск детсруктора по хэш коду
   ;
   free(pointer);
}
//prologue epilogue to clean after quit
void callPrologue()
{
   beforeCallNode = holder.lastNode;
   //сохранение состояния для исключения.
   printf("we are int prologue \n");
}
void callEpilogue()
{
   int elementDeleted  = 0;
   if(NULL == beforeCallNode)
   {
      beforeCallNode = holder.firstNode;
   }
   
   while(beforeCallNode)
   {
      destructElement(beforeCallNode->elementTypeHash, beforeCallNode->elementPointer);
      beforeCallNode = beforeCallNode->nextNode;
      elementDeleted ++;
   }
   printf("epilogue %d \n", elementDeleted);
}
//test
int add(int a, int b)
{
   int v1 = *nuovo(int);
   char v2 = *nuovo(char);
   
   return a+b;
}
int _tmain(int argc, _TCHAR* argv[])
{
  int a = 52;
  int b = 25;
  int c = 0;
  globalStateInit();
  c  = CALL(FUNCTION(add)(a,b));

   return 0;
}

template <typename T>
struct type_array;
{
    char Array[sizeof (T)];
};