Merge branch 'master' of git@scm.dev.nokia.troll.no:creator/mainline

4 files changed, 1524 insertions, 85 deletions

diff --git a/shared/cplusplus/AST.cpp b/shared/cplusplus/AST.cpp
index dcf3257361..9a8d41fe7a 100644
--- a/shared/cplusplus/AST.cpp
+++ b/shared/cplusplus/AST.cpp
@@ -408,6 +408,19 @@ unsigned AttributeSpecifierAST::lastToken() const
     return attribute_token + 1;
 }
 
+AttributeSpecifierAST *AttributeSpecifierAST::clone(MemoryPool *pool) const
+{
+    AttributeSpecifierAST *ast = new (pool) AttributeSpecifierAST;
+    ast->attribute_token = attribute_token;
+    ast->first_lparen_token = first_lparen_token;
+    ast->second_lparen_token = second_lparen_token;
+    if (attributes)
+        ast->attributes = attributes->clone(pool);
+    ast->first_rparen_token = first_rparen_token;
+    ast->second_rparen_token = second_rparen_token;
+    return ast;
+}
+
 void AttributeSpecifierAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -442,6 +455,20 @@ unsigned AttributeAST::lastToken() const
     return identifier_token + 1;
 }
 
+AttributeAST *AttributeAST::clone(MemoryPool *pool) const
+{
+    AttributeAST *ast = new (pool) AttributeAST;
+    ast->identifier_token = identifier_token;
+    ast->lparen_token = lparen_token;
+    ast->tag_token = tag_token;
+    if (expression_list)
+        ast->expression_list = expression_list->clone(pool);
+    ast->rparen_token = rparen_token;
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
+}
+
 void AttributeAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -450,6 +477,15 @@ void AttributeAST::accept0(ASTVisitor *visitor)
     }
 }
 
+AccessDeclarationAST *AccessDeclarationAST::clone(MemoryPool *pool) const
+{
+    AccessDeclarationAST *ast = new (pool) AccessDeclarationAST;
+    ast->access_specifier_token = access_specifier_token;
+    ast->slots_token = slots_token;
+    ast->colon_token = colon_token;
+    return ast;
+}
+
 void AccessDeclarationAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -470,6 +506,16 @@ unsigned AccessDeclarationAST::lastToken() const
     return access_specifier_token + 1;
 }
 
+ArrayAccessAST *ArrayAccessAST::clone(MemoryPool *pool) const
+{
+    ArrayAccessAST *ast = new (pool) ArrayAccessAST;
+    ast->lbracket_token = lbracket_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->rbracket_token = rbracket_token;
+    return ast;
+}
+
 void ArrayAccessAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -491,6 +537,16 @@ unsigned ArrayAccessAST::lastToken() const
     return lbracket_token + 1;
 }
 
+ArrayDeclaratorAST *ArrayDeclaratorAST::clone(MemoryPool *pool) const
+{
+    ArrayDeclaratorAST *ast = new (pool) ArrayDeclaratorAST;
+    ast->lbracket_token = lbracket_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->rbracket_token = rbracket_token;
+    return ast;
+}
+
 void ArrayDeclaratorAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -512,11 +568,20 @@ unsigned ArrayDeclaratorAST::lastToken() const
     return lbracket_token + 1;
 }
 
+ArrayInitializerAST *ArrayInitializerAST::clone(MemoryPool *pool) const
+{
+    ArrayInitializerAST *ast = new (pool) ArrayInitializerAST;
+    ast->lbrace_token = lbrace_token;
+    if (expression_list)
+        ast->expression_list = expression_list->clone(pool);
+    ast->rbrace_token = rbrace_token;
+    return ast;
+}
+
 void ArrayInitializerAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
-        for (ExpressionListAST *expr = expression_list;expr;
-                 expr = expr->next)
+        for (ExpressionListAST *expr = expression_list; expr; expr = expr->next)
             accept(expr->expression, visitor);
     }
 }
@@ -539,6 +604,18 @@ unsigned ArrayInitializerAST::lastToken() const
     return lbrace_token + 1;
 }
 
+AsmDefinitionAST *AsmDefinitionAST::clone(MemoryPool *pool) const
+{
+    AsmDefinitionAST *ast = new (pool) AsmDefinitionAST;
+    ast->asm_token = asm_token;
+    if (cv_qualifier_seq)
+        ast->cv_qualifier_seq = cv_qualifier_seq->clone(pool);
+    ast->lparen_token = lparen_token;
+    ast->rparen_token = rparen_token;
+    ast->semicolon_token = semicolon_token;
+    return ast;
+}
+
 void AsmDefinitionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -569,6 +646,18 @@ unsigned AsmDefinitionAST::lastToken() const
     return asm_token + 1;
 }
 
+BaseSpecifierAST *BaseSpecifierAST::clone(MemoryPool *pool) const
+{
+    BaseSpecifierAST *ast = new (pool) BaseSpecifierAST;
+    ast->token_virtual = token_virtual;
+    ast->token_access_specifier = token_access_specifier;
+    if (name)
+        ast->name = name->clone(pool);
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
+}
+
 void BaseSpecifierAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -611,6 +700,17 @@ unsigned QtMethodAST::lastToken() const
     return method_token + 1;
 }
 
+QtMethodAST *QtMethodAST::clone(MemoryPool *pool) const
+{
+    QtMethodAST *ast = new (pool) QtMethodAST;
+    ast->method_token = method_token;
+    ast->lparen_token = lparen_token;
+    if (declarator)
+        ast->declarator = declarator->clone(pool);
+    ast->rparen_token = rparen_token;
+    return ast;
+}
+
 void QtMethodAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -618,6 +718,17 @@ void QtMethodAST::accept0(ASTVisitor *visitor)
     }
 }
 
+BinaryExpressionAST *BinaryExpressionAST::clone(MemoryPool *pool) const
+{
+    BinaryExpressionAST *ast = new (pool) BinaryExpressionAST;
+    if (left_expression)
+        ast->left_expression = left_expression->clone(pool);
+    ast->binary_op_token = binary_op_token;
+    if (right_expression)
+        ast->right_expression = right_expression->clone(pool);
+    return ast;
+}
+
 void BinaryExpressionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -640,6 +751,13 @@ unsigned BinaryExpressionAST::lastToken() const
     return left_expression->lastToken();
 }
 
+BoolLiteralAST *BoolLiteralAST::clone(MemoryPool *pool) const
+{
+    BoolLiteralAST *ast = new (pool) BoolLiteralAST;
+    ast->token = token;
+    return ast;
+}
+
 void BoolLiteralAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -656,6 +774,14 @@ unsigned BoolLiteralAST::lastToken() const
     return token + 1;
 }
 
+BreakStatementAST *BreakStatementAST::clone(MemoryPool *pool) const
+{
+    BreakStatementAST *ast = new (pool) BreakStatementAST;
+    ast->break_token = break_token;
+    ast->semicolon_token = semicolon_token;
+    return ast;
+}
+
 void BreakStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -674,6 +800,16 @@ unsigned BreakStatementAST::lastToken() const
     return break_token + 1;
 }
 
+CallAST *CallAST::clone(MemoryPool *pool) const
+{
+    CallAST *ast = new (pool) CallAST;
+    ast->lparen_token = lparen_token;
+    if (expression_list)
+        ast->expression_list = expression_list;
+    ast->rparen_token = rparen_token;
+    return ast;
+}
+
 void CallAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -699,6 +835,18 @@ unsigned CallAST::lastToken() const
     return lparen_token + 1;
 }
 
+CaseStatementAST *CaseStatementAST::clone(MemoryPool *pool) const
+{
+    CaseStatementAST *ast = new (pool) CaseStatementAST;
+    ast->case_token = case_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->colon_token = colon_token;
+    if (statement)
+        ast->statement = statement->clone(pool);
+    return ast;
+}
+
 void CaseStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -721,6 +869,18 @@ unsigned CaseStatementAST::lastToken() const
     return case_token + 1;
 }
 
+CastExpressionAST *CastExpressionAST::clone(MemoryPool *pool) const
+{
+    CastExpressionAST *ast = new (pool) CastExpressionAST;
+    ast->lparen_token = lparen_token;
+    if (type_id)
+        ast->type_id = type_id->clone(pool);
+    ast->rparen_token = rparen_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    return ast;
+}
+
 void CastExpressionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -743,6 +903,21 @@ unsigned CastExpressionAST::lastToken() const
     return lparen_token + 1;
 }
 
+CatchClauseAST *CatchClauseAST::clone(MemoryPool *pool) const
+{
+    CatchClauseAST *ast = new (pool) CatchClauseAST;
+    ast->catch_token = catch_token;
+    ast->lparen_token = lparen_token;
+    if (exception_declaration)
+        ast->exception_declaration = exception_declaration->clone(pool);
+    ast->rparen_token = rparen_token;
+    if (statement)
+        ast->statement = statement->clone(pool);
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
+}
+
 void CatchClauseAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -772,6 +947,24 @@ unsigned CatchClauseAST::lastToken() const
     return catch_token + 1;
 }
 
+ClassSpecifierAST *ClassSpecifierAST::clone(MemoryPool *pool) const
+{
+    ClassSpecifierAST *ast = new (pool) ClassSpecifierAST;
+    ast->classkey_token = classkey_token;
+    if (attributes)
+        ast->attributes = attributes->clone(pool);
+    if (name)
+        ast->name = name->clone(pool);
+    ast->colon_token = colon_token;
+    if (base_clause)
+        ast->base_clause = base_clause->clone(pool);
+    ast->lbrace_token = lbrace_token;
+    if (member_specifiers)
+        ast->member_specifiers = member_specifiers->clone(pool);
+    ast->rbrace_token = rbrace_token;
+    return ast;
+}
+
 void ClassSpecifierAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -822,6 +1015,16 @@ unsigned ClassSpecifierAST::lastToken() const
     return classkey_token + 1;
 }
 
+CompoundStatementAST *CompoundStatementAST::clone(MemoryPool *pool) const
+{
+    CompoundStatementAST *ast = new (pool) CompoundStatementAST;
+    ast->lbrace_token = lbrace_token;
+    if (statements)
+        ast->statements = statements->clone(pool);
+    ast->rbrace_token = rbrace_token;
+    return ast;
+}
+
 void CompoundStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -848,6 +1051,16 @@ unsigned CompoundStatementAST::lastToken() const
     return lbrace_token + 1;
 }
 
+ConditionAST *ConditionAST::clone(MemoryPool *pool) const
+{
+    ConditionAST *ast = new (pool) ConditionAST;
+    if (type_specifier)
+        ast->type_specifier = type_specifier->clone(pool);
+    if (declarator)
+        ast->declarator = declarator->clone(pool);
+    return ast;
+}
+
 void ConditionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -879,6 +1092,20 @@ unsigned ConditionAST::lastToken() const
     return 0;
 }
 
+ConditionalExpressionAST *ConditionalExpressionAST::clone(MemoryPool *pool) const
+{
+    ConditionalExpressionAST *ast = new (pool) ConditionalExpressionAST;
+    if (condition)
+        ast->condition = condition->clone(pool);
+    ast->question_token = question_token;
+    if (left_expression)
+        ast->left_expression = left_expression->clone(pool);
+    ast->colon_token = colon_token;
+    if (right_expression)
+        ast->right_expression = right_expression->clone(pool);
+    return ast;
+}
+
 void ConditionalExpressionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -909,6 +1136,14 @@ unsigned ConditionalExpressionAST::lastToken() const
     return 0;
 }
 
+ContinueStatementAST *ContinueStatementAST::clone(MemoryPool *pool) const
+{
+    ContinueStatementAST *ast = new (pool) ContinueStatementAST;
+    ast->continue_token = continue_token;
+    ast->semicolon_token = semicolon_token;
+    return ast;
+}
+
 void ContinueStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -927,6 +1162,17 @@ unsigned ContinueStatementAST::lastToken() const
     return continue_token + 1;
 }
 
+ConversionFunctionIdAST *ConversionFunctionIdAST::clone(MemoryPool *pool) const
+{
+    ConversionFunctionIdAST *ast = new (pool) ConversionFunctionIdAST;
+    ast->operator_token = operator_token;
+    if (type_specifier)
+        ast->type_specifier = type_specifier->clone(pool);
+    if (ptr_operators)
+        ast->ptr_operators = ptr_operators->clone(pool);
+    return ast;
+}
+
 void ConversionFunctionIdAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -958,6 +1204,21 @@ unsigned ConversionFunctionIdAST::lastToken() const
     return operator_token + 1;
 }
 
+CppCastExpressionAST *CppCastExpressionAST::clone(MemoryPool *pool) const
+{
+    CppCastExpressionAST *ast = new (pool) CppCastExpressionAST;
+    ast->cast_token = cast_token;
+    ast->less_token = less_token;
+    if (type_id)
+        ast->type_id = type_id->clone(pool);
+    ast->greater_token = greater_token;
+    ast->lparen_token = lparen_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->rparen_token = rparen_token;
+    return ast;
+}
+
 void CppCastExpressionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -988,6 +1249,15 @@ unsigned CppCastExpressionAST::lastToken() const
     return cast_token + 1;
 }
 
+CtorInitializerAST *CtorInitializerAST::clone(MemoryPool *pool) const
+{
+    CtorInitializerAST *ast = new (pool) CtorInitializerAST;
+    ast->colon_token = colon_token;
+    if (member_initializers)
+        ast->member_initializers = member_initializers->clone(pool);
+    return ast;
+}
+
 void CtorInitializerAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1011,6 +1281,22 @@ unsigned CtorInitializerAST::lastToken() const
     return colon_token + 1;
 }
 
+DeclaratorAST *DeclaratorAST::clone(MemoryPool *pool) const
+{
+    DeclaratorAST *ast = new (pool) DeclaratorAST;
+    if (ptr_operators)
+        ast->ptr_operators = ptr_operators->clone(pool);
+    if (core_declarator)
+        ast->core_declarator = core_declarator->clone(pool);
+    if (postfix_declarators)
+        ast->postfix_declarators = postfix_declarators->clone(pool);
+    if (attributes)
+        ast->attributes = attributes->clone(pool);
+    if (initializer)
+        ast->initializer = initializer->clone(pool);
+    return ast;
+}
+
 void DeclaratorAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1069,6 +1355,14 @@ unsigned DeclaratorAST::lastToken() const
     return 0;
 }
 
+DeclarationStatementAST *DeclarationStatementAST::clone(MemoryPool *pool) const
+{
+    DeclarationStatementAST *ast = new (pool) DeclarationStatementAST;
+    if (declaration)
+        ast->declaration = declaration->clone(pool);
+    return ast;
+}
+
 void DeclarationStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1086,6 +1380,14 @@ unsigned DeclarationStatementAST::lastToken() const
     return declaration->lastToken();
 }
 
+DeclaratorIdAST *DeclaratorIdAST::clone(MemoryPool *pool) const
+{
+    DeclaratorIdAST *ast = new (pool) DeclaratorIdAST;
+    if (name)
+        ast->name = name->clone(pool);
+    return ast;
+}
+
 void DeclaratorIdAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1103,6 +1405,16 @@ unsigned DeclaratorIdAST::lastToken() const
     return name->lastToken();
 }
 
+DeclaratorListAST *DeclaratorListAST::clone(MemoryPool *pool) const
+{
+    DeclaratorListAST *ast = new (pool) DeclaratorListAST;
+    if (declarator)
+        ast->declarator = declarator->clone(pool);
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
+}
+
 void DeclaratorListAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1125,6 +1437,18 @@ unsigned DeclaratorListAST::lastToken() const
     return 0;
 }
 
+DeleteExpressionAST *DeleteExpressionAST::clone(MemoryPool *pool) const
+{
+    DeleteExpressionAST *ast = new (pool) DeleteExpressionAST;
+    ast->scope_token = scope_token;
+    ast->delete_token = delete_token;
+    ast->lbracket_token = lbracket_token;
+    ast->rbracket_token = rbracket_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    return ast;
+}
+
 void DeleteExpressionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1152,6 +1476,14 @@ unsigned DeleteExpressionAST::lastToken() const
     return scope_token + 1;
 }
 
+DestructorNameAST *DestructorNameAST::clone(MemoryPool *pool) const
+{
+    DestructorNameAST *ast = new (pool) DestructorNameAST;
+    ast->tilde_token = tilde_token;
+    ast->identifier_token = identifier_token;
+    return ast;
+}
+
 void DestructorNameAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1170,6 +1502,21 @@ unsigned DestructorNameAST::lastToken() const
     return tilde_token + 1;
 }
 
+DoStatementAST *DoStatementAST::clone(MemoryPool *pool) const
+{
+    DoStatementAST *ast = new (pool) DoStatementAST;
+    ast->do_token = do_token;
+    if (statement)
+        ast->statement = statement->clone(pool);
+    ast->while_token = while_token;
+    ast->lparen_token = lparen_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->rparen_token = rparen_token;
+    ast->semicolon_token = semicolon_token;
+    return ast;
+}
+
 void DoStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1200,6 +1547,15 @@ unsigned DoStatementAST::lastToken() const
     return do_token + 1;
 }
 
+ElaboratedTypeSpecifierAST *ElaboratedTypeSpecifierAST::clone(MemoryPool *pool) const
+{
+    ElaboratedTypeSpecifierAST *ast = new (pool) ElaboratedTypeSpecifierAST;
+    ast->classkey_token = classkey_token;
+    if (name)
+        ast->name = name->clone(pool);
+    return ast;
+}
+
 void ElaboratedTypeSpecifierAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1219,6 +1575,13 @@ unsigned ElaboratedTypeSpecifierAST::lastToken() const
     return classkey_token + 1;
 }
 
+EmptyDeclarationAST *EmptyDeclarationAST::clone(MemoryPool *pool) const
+{
+    EmptyDeclarationAST *ast = new (pool) EmptyDeclarationAST;
+    ast->semicolon_token = semicolon_token;
+    return ast;
+}
+
 void EmptyDeclarationAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1235,6 +1598,19 @@ unsigned EmptyDeclarationAST::lastToken() const
     return semicolon_token + 1;
 }
 
+EnumSpecifierAST *EnumSpecifierAST::clone(MemoryPool *pool) const
+{
+    EnumSpecifierAST *ast = new (pool) EnumSpecifierAST;
+    ast->enum_token = enum_token;
+    if (name)
+        ast->name = name->clone(pool);
+    ast->lbrace_token = lbrace_token;
+    if (enumerators)
+        ast->enumerators = enumerators->clone(pool);
+    ast->rbrace_token = rbrace_token;
+    return ast;
+}
+
 void EnumSpecifierAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1268,6 +1644,18 @@ unsigned EnumSpecifierAST::lastToken() const
     return enum_token + 1;
 }
 
+EnumeratorAST *EnumeratorAST::clone(MemoryPool *pool) const
+{
+    EnumeratorAST *ast = new (pool) EnumeratorAST;
+    ast->identifier_token = identifier_token;
+    ast->equal_token = equal_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
+}
+
 void EnumeratorAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1289,6 +1677,17 @@ unsigned EnumeratorAST::lastToken() const
     return identifier_token + 1;
 }
 
+ExceptionDeclarationAST *ExceptionDeclarationAST::clone(MemoryPool *pool) const
+{
+    ExceptionDeclarationAST *ast = new (pool) ExceptionDeclarationAST;
+    if (type_specifier)
+        ast->type_specifier = type_specifier->clone(pool);
+    if (declarator)
+        ast->declarator = declarator->clone(pool);
+    ast->dot_dot_dot_token = dot_dot_dot_token;
+    return ast;
+}
+
 void ExceptionDeclarationAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1320,6 +1719,18 @@ unsigned ExceptionDeclarationAST::lastToken() const
     return 0;
 }
 
+ExceptionSpecificationAST *ExceptionSpecificationAST::clone(MemoryPool *pool) const
+{
+    ExceptionSpecificationAST *ast = new (pool) ExceptionSpecificationAST;
+    ast->throw_token = throw_token;
+    ast->lparen_token = lparen_token;
+    ast->dot_dot_dot_token = dot_dot_dot_token;
+    if (type_ids)
+        ast->type_ids = type_ids->clone(pool);
+    ast->rparen_token = rparen_token;
+    return ast;
+}
+
 void ExceptionSpecificationAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1352,8 +1763,22 @@ unsigned ExceptionSpecificationAST::lastToken() const
     return throw_token + 1;
 }
 
-void ExpressionListAST::accept0(ASTVisitor *)
-{ assert(0); }
+ExpressionListAST *ExpressionListAST::clone(MemoryPool *pool) const
+{
+    ExpressionListAST *ast = new (pool) ExpressionListAST;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
+}
+
+void ExpressionListAST::accept0(ASTVisitor *visitor)
+{
+    for (const ExpressionListAST *it = this; it; it = it->next) {
+        accept(it->expression, visitor);
+    }
+}
 
 unsigned ExpressionListAST::firstToken() const
 {
@@ -1369,6 +1794,16 @@ unsigned ExpressionListAST::lastToken() const
     return 0;
 }
 
+ExpressionOrDeclarationStatementAST *ExpressionOrDeclarationStatementAST::clone(MemoryPool *pool) const
+{
+    ExpressionOrDeclarationStatementAST *ast = new (pool) ExpressionOrDeclarationStatementAST;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    if (declaration)
+        ast->declaration = declaration->clone(pool);
+    return ast;
+}
+
 void ExpressionOrDeclarationStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1387,6 +1822,15 @@ unsigned ExpressionOrDeclarationStatementAST::lastToken() const
     return declaration->lastToken();
 }
 
+ExpressionStatementAST *ExpressionStatementAST::clone(MemoryPool *pool) const
+{
+    ExpressionStatementAST *ast = new (pool) ExpressionStatementAST;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->semicolon_token = semicolon_token;
+    return ast;
+}
+
 void ExpressionStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1411,6 +1855,24 @@ unsigned ExpressionStatementAST::lastToken() const
     return 0;
 }
 
+ForStatementAST *ForStatementAST::clone(MemoryPool *pool) const
+{
+    ForStatementAST *ast = new (pool) ForStatementAST;
+    ast->for_token = for_token;
+    ast->lparen_token = lparen_token;
+    if (initializer)
+        ast->initializer = initializer->clone(pool);
+    if (condition)
+        ast->condition = condition->clone(pool);
+    ast->semicolon_token = semicolon_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->rparen_token = rparen_token;
+    if (statement)
+        ast->statement = statement->clone(pool);
+    return ast;
+}
+
 void ForStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1446,6 +1908,20 @@ unsigned ForStatementAST::lastToken() const
     return for_token + 1;
 }
 
+FunctionDeclaratorAST *FunctionDeclaratorAST::clone(MemoryPool *pool) const
+{
+    FunctionDeclaratorAST *ast = new (pool) FunctionDeclaratorAST;
+    ast->lparen_token = lparen_token;
+    if (parameters)
+        ast->parameters = parameters->clone(pool);
+    ast->rparen_token = rparen_token;
+    if (cv_qualifier_seq)
+        ast->cv_qualifier_seq = cv_qualifier_seq->clone(pool);
+    if (exception_specification)
+        ast->exception_specification = exception_specification->clone(pool);
+    return ast;
+}
+
 void FunctionDeclaratorAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1475,6 +1951,20 @@ unsigned FunctionDeclaratorAST::lastToken() const
     return lparen_token + 1;
 }
 
+FunctionDefinitionAST *FunctionDefinitionAST::clone(MemoryPool *pool) const
+{
+    FunctionDefinitionAST *ast = new (pool) FunctionDefinitionAST;
+    if (decl_specifier_seq)
+        ast->decl_specifier_seq = decl_specifier_seq->clone(pool);
+    if (declarator)
+        ast->declarator = declarator->clone(pool);
+    if (ctor_initializer)
+        ast->ctor_initializer = ctor_initializer->clone(pool);
+    if (function_body)
+        ast->function_body = function_body->clone(pool);
+    return ast;
+}
+
 void FunctionDefinitionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1516,6 +2006,15 @@ unsigned FunctionDefinitionAST::lastToken() const
     return 0;
 }
 
+GotoStatementAST *GotoStatementAST::clone(MemoryPool *pool) const
+{
+    GotoStatementAST *ast = new (pool) GotoStatementAST;
+    ast->goto_token = goto_token;
+    ast->identifier_token = identifier_token;
+    ast->semicolon_token = semicolon_token;
+    return ast;
+}
+
 void GotoStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1538,6 +2037,22 @@ unsigned GotoStatementAST::lastToken() const
     return 0;
 }
 
+IfStatementAST *IfStatementAST::clone(MemoryPool *pool) const
+{
+    IfStatementAST *ast = new (pool) IfStatementAST;
+    ast->if_token = if_token;
+    ast->lparen_token = lparen_token;
+    if (condition)
+        ast->condition = condition->clone(pool);
+    ast->rparen_token = rparen_token;
+    if (statement)
+        ast->statement = statement->clone(pool);
+    ast->else_token = else_token;
+    if (else_statement)
+        ast->else_statement = else_statement->clone(pool);
+    return ast;
+}
+
 void IfStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1569,6 +2084,16 @@ unsigned IfStatementAST::lastToken() const
     return if_token + 1;
 }
 
+LabeledStatementAST *LabeledStatementAST::clone(MemoryPool *pool) const
+{
+    LabeledStatementAST *ast = new (pool) LabeledStatementAST;
+    ast->label_token = label_token;
+    ast->colon_token = colon_token;
+    if (statement)
+        ast->statement = statement->clone(pool);
+    return ast;
+}
+
 void LabeledStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1590,6 +2115,16 @@ unsigned LabeledStatementAST::lastToken() const
     return label_token + 1;
 }
 
+LinkageBodyAST *LinkageBodyAST::clone(MemoryPool *pool) const
+{
+    LinkageBodyAST *ast = new (pool) LinkageBodyAST;
+    ast->lbrace_token = lbrace_token;
+    if (declarations)
+        ast->declarations = declarations->clone(pool);
+    ast->rbrace_token = rbrace_token;
+    return ast;
+}
+
 void LinkageBodyAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1617,6 +2152,16 @@ unsigned LinkageBodyAST::lastToken() const
     return lbrace_token + 1;
 }
 
+LinkageSpecificationAST *LinkageSpecificationAST::clone(MemoryPool *pool) const
+{
+    LinkageSpecificationAST *ast = new (pool) LinkageSpecificationAST;
+    ast->extern_token = extern_token;
+    ast->extern_type = extern_type;
+    if (declaration)
+        ast->declaration = declaration->clone(pool);
+    return ast;
+}
+
 void LinkageSpecificationAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1638,6 +2183,20 @@ unsigned LinkageSpecificationAST::lastToken() const
     return extern_token + 1;
 }
 
+MemInitializerAST *MemInitializerAST::clone(MemoryPool *pool) const
+{
+    MemInitializerAST *ast = new (pool) MemInitializerAST;
+    if (name)
+        ast->name = name->clone(pool);
+    ast->lparen_token = lparen_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->rparen_token = rparen_token;
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
+}
+
 void MemInitializerAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1661,6 +2220,16 @@ unsigned MemInitializerAST::lastToken() const
     return name->lastToken();
 }
 
+MemberAccessAST *MemberAccessAST::clone(MemoryPool *pool) const
+{
+    MemberAccessAST *ast = new (pool) MemberAccessAST;
+    ast->access_token = access_token;
+    ast->template_token = template_token;
+    if (member_name)
+        ast->member_name = member_name->clone(pool);
+    return ast;
+}
+
 void MemberAccessAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1682,6 +2251,14 @@ unsigned MemberAccessAST::lastToken() const
     return access_token + 1;
 }
 
+NamedTypeSpecifierAST *NamedTypeSpecifierAST::clone(MemoryPool *pool) const
+{
+    NamedTypeSpecifierAST *ast = new (pool) NamedTypeSpecifierAST;
+    if (name)
+        ast->name = name->clone(pool);
+    return ast;
+}
+
 void NamedTypeSpecifierAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1699,6 +2276,18 @@ unsigned NamedTypeSpecifierAST::lastToken() const
     return name->lastToken();
 }
 
+NamespaceAST *NamespaceAST::clone(MemoryPool *pool) const
+{
+    NamespaceAST *ast = new (pool) NamespaceAST;
+    ast->namespace_token = namespace_token;
+    ast->identifier_token = identifier_token;
+    if (attributes)
+        ast->attributes = attributes->clone(pool);
+    if (linkage_body)
+        ast->linkage_body = linkage_body->clone(pool);
+    return ast;
+}
+
 void NamespaceAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1730,6 +2319,18 @@ unsigned NamespaceAST::lastToken() const
     return namespace_token + 1;
 }
 
+NamespaceAliasDefinitionAST *NamespaceAliasDefinitionAST::clone(MemoryPool *pool) const
+{
+    NamespaceAliasDefinitionAST *ast = new (pool) NamespaceAliasDefinitionAST;
+    ast->namespace_token = namespace_token;
+    ast->namespace_name = namespace_name;
+    ast->equal_token = equal_token;
+    if (name)
+        ast->name = name->clone(pool);
+    ast->semicolon_token = semicolon_token;
+    return ast;
+}
+
 void NamespaceAliasDefinitionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1755,6 +2356,16 @@ unsigned NamespaceAliasDefinitionAST::lastToken() const
     return namespace_token + 1;
 }
 
+NestedDeclaratorAST *NestedDeclaratorAST::clone(MemoryPool *pool) const
+{
+    NestedDeclaratorAST *ast = new (pool) NestedDeclaratorAST;
+    ast->lparen_token = lparen_token;
+    if (declarator)
+        ast->declarator = declarator->clone(pool);
+    ast->rparen_token = rparen_token;
+    return ast;
+}
+
 void NestedDeclaratorAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1776,6 +2387,16 @@ unsigned NestedDeclaratorAST::lastToken() const
     return lparen_token + 1;
 }
 
+NestedExpressionAST *NestedExpressionAST::clone(MemoryPool *pool) const
+{
+    NestedExpressionAST *ast = new (pool) NestedExpressionAST;
+    ast->lparen_token = lparen_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->rparen_token = rparen_token;
+    return ast;
+}
+
 void NestedExpressionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1797,6 +2418,17 @@ unsigned NestedExpressionAST::lastToken() const
     return lparen_token + 1;
 }
 
+NestedNameSpecifierAST *NestedNameSpecifierAST::clone(MemoryPool *pool) const
+{
+    NestedNameSpecifierAST *ast = new (pool) NestedNameSpecifierAST;
+    if (class_or_namespace_name)
+        ast->class_or_namespace_name = class_or_namespace_name->clone(pool);
+    ast->scope_token = scope_token;
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
+}
+
 void NestedNameSpecifierAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1817,13 +2449,25 @@ unsigned NestedNameSpecifierAST::lastToken() const
     return class_or_namespace_name->lastToken();
 }
 
+NewDeclaratorAST *NewDeclaratorAST::clone(MemoryPool *pool) const
+{
+    NewDeclaratorAST *ast = new (pool) NewDeclaratorAST;
+    if (ptr_operators)
+        ast->ptr_operators = ptr_operators->clone(pool);
+    if (declarator)
+        ast->declarator = declarator->clone(pool);
+    return ast;
+}
+
 void NewDeclaratorAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
         for (PtrOperatorAST *ptr_op = ptr_operators; ptr_op;
-                 ptr_op = static_cast<PtrOperatorAST *>(ptr_op->next))
+                 ptr_op = static_cast<PtrOperatorAST *>(ptr_op->next)) {
             accept(ptr_op, visitor);
-        // ### TODO accept the brackets
+        }
+
+        accept(declarator, visitor);
     }
 }
 
@@ -1834,13 +2478,33 @@ unsigned NewDeclaratorAST::firstToken() const
 
 unsigned NewDeclaratorAST::lastToken() const
 {
-    assert(0 && "review me");
     if (declarator)
         return declarator->lastToken();
-    assert(0); // ### implement me
+
+    for (PtrOperatorAST *it = ptr_operators; it; it = it->next) {
+        if (! it->next)
+            return it->lastToken();
+    }
+
     return 0;
 }
 
+NewExpressionAST *NewExpressionAST::clone(MemoryPool *pool) const
+{
+    NewExpressionAST *ast = new (pool) NewExpressionAST;
+    ast->scope_token = scope_token;
+    ast->new_token = new_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    if (type_id)
+        ast->type_id = type_id->clone(pool);
+    if (new_type_id)
+        ast->new_type_id = new_type_id->clone(pool);
+    if (new_initializer)
+        ast->new_initializer = new_initializer->clone(pool);
+    return ast;
+}
+
 void NewExpressionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1860,7 +2524,6 @@ unsigned NewExpressionAST::firstToken() const
 
 unsigned NewExpressionAST::lastToken() const
 {
-    assert(0 && "review me");
     if (new_initializer)
         return new_initializer->lastToken();
     else if (new_type_id)
@@ -1869,7 +2532,22 @@ unsigned NewExpressionAST::lastToken() const
         return type_id->lastToken();
     else if (expression)
         return expression->lastToken();
-    return new_token + 1;
+    else if (new_token)
+        return new_token + 1;
+    else if (scope_token)
+        return scope_token + 1;
+    // ### assert?
+    return 0;
+}
+
+NewInitializerAST *NewInitializerAST::clone(MemoryPool *pool) const
+{
+    NewInitializerAST *ast = new (pool) NewInitializerAST;
+    ast->lparen_token = lparen_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->rparen_token = rparen_token;
+    return ast;
 }
 
 void NewInitializerAST::accept0(ASTVisitor *visitor)
@@ -1886,8 +2564,33 @@ unsigned NewInitializerAST::firstToken() const
 
 unsigned NewInitializerAST::lastToken() const
 {
-    assert(0 && "review me");
-    return rparen_token + 1;
+    if (rparen_token)
+        return rparen_token + 1;
+    else if (expression)
+        return expression->lastToken();
+    return lparen_token + 1;
+}
+
+TypeIdAST *TypeIdAST::clone(MemoryPool *pool) const
+{
+    TypeIdAST *ast = new (pool) TypeIdAST;
+    if (type_specifier)
+        ast->type_specifier = type_specifier->clone(pool);
+    if (declarator)
+        ast->declarator = declarator->clone(pool);
+    return ast;
+}
+
+NewTypeIdAST *NewTypeIdAST::clone(MemoryPool *pool) const
+{
+    NewTypeIdAST *ast = new (pool) NewTypeIdAST;
+    if (type_specifier)
+        ast->type_specifier = type_specifier->clone(pool);
+    if (new_initializer)
+        ast->new_initializer = new_initializer->clone(pool);
+    if (new_declarator)
+        ast->new_declarator = new_declarator->clone(pool);
+    return ast;
 }
 
 void NewTypeIdAST::accept0(ASTVisitor *visitor)
@@ -1907,7 +2610,6 @@ unsigned NewTypeIdAST::firstToken() const
 
 unsigned NewTypeIdAST::lastToken() const
 {
-    assert(0 && "review me");
     if (new_declarator)
         return new_declarator->lastToken();
     else if (new_initializer)
@@ -1916,9 +2618,18 @@ unsigned NewTypeIdAST::lastToken() const
         if (! it->next)
             return it->lastToken();
     }
+
+    // ### assert?
     return 0;
 }
 
+NumericLiteralAST *NumericLiteralAST::clone(MemoryPool *pool) const
+{
+    NumericLiteralAST *ast = new (pool) NumericLiteralAST;
+    ast->token = token;
+    return ast;
+}
+
 void NumericLiteralAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1932,10 +2643,18 @@ unsigned NumericLiteralAST::firstToken() const
 
 unsigned NumericLiteralAST::lastToken() const
 {
-    assert(0 && "review me");
     return token + 1;
 }
 
+OperatorAST *OperatorAST::clone(MemoryPool *pool) const
+{
+    OperatorAST *ast = new (pool) OperatorAST;
+    ast->op_token = op_token;
+    ast->open_token = open_token;
+    ast->close_token = close_token;
+    return ast;
+}
+
 void OperatorAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1949,12 +2668,22 @@ unsigned OperatorAST::firstToken() const
 
 unsigned OperatorAST::lastToken() const
 {
-    assert(0 && "review me");
     if (close_token)
         return close_token + 1;
+    else if (open_token)
+        return open_token + 1;
     return op_token + 1;
 }
 
+OperatorFunctionIdAST *OperatorFunctionIdAST::clone(MemoryPool *pool) const
+{
+    OperatorFunctionIdAST *ast = new (pool) OperatorFunctionIdAST;
+    ast->operator_token = operator_token;
+    if (op)
+        ast->op = op->clone(pool);
+    return ast;
+}
+
 void OperatorFunctionIdAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1969,12 +2698,24 @@ unsigned OperatorFunctionIdAST::firstToken() const
 
 unsigned OperatorFunctionIdAST::lastToken() const
 {
-    assert(0 && "review me");
     if (op)
         return op->lastToken();
     return operator_token + 1;
 }
 
+ParameterDeclarationAST *ParameterDeclarationAST::clone(MemoryPool *pool) const
+{
+    ParameterDeclarationAST *ast = new (pool) ParameterDeclarationAST;
+    if (type_specifier)
+        ast->type_specifier = type_specifier->clone(pool);
+    if (declarator)
+        ast->declarator = declarator->clone(pool);
+    ast->equal_token = equal_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    return ast;
+}
+
 void ParameterDeclarationAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1992,20 +2733,29 @@ unsigned ParameterDeclarationAST::firstToken() const
 
 unsigned ParameterDeclarationAST::lastToken() const
 {
-    assert(0 && "review me");
     if (expression)
         return expression->lastToken();
     else if (equal_token)
         return equal_token + 1;
     else if (declarator)
         return declarator->lastToken();
-        for (SpecifierAST *it = type_specifier; it; it = it->next) {
+    for (SpecifierAST *it = type_specifier; it; it = it->next) {
         if (! it->next)
             return it->lastToken();
     }
+    // ### assert?
     return 0;
 }
 
+ParameterDeclarationClauseAST *ParameterDeclarationClauseAST::clone(MemoryPool *pool) const
+{
+    ParameterDeclarationClauseAST *ast = new (pool) ParameterDeclarationClauseAST;
+    if (parameter_declarations)
+        ast->parameter_declarations = parameter_declarations;
+    ast->dot_dot_dot_token = dot_dot_dot_token;
+    return ast;
+}
+
 void ParameterDeclarationClauseAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2024,12 +2774,20 @@ unsigned ParameterDeclarationClauseAST::firstToken() const
 
 unsigned ParameterDeclarationClauseAST::lastToken() const
 {
-    assert(0 && "review me");
     if (dot_dot_dot_token)
         return dot_dot_dot_token + 1;
     return parameter_declarations->lastToken();
 }
 
+PointerAST *PointerAST::clone(MemoryPool *pool) const
+{
+    PointerAST *ast = new (pool) PointerAST;
+    ast->star_token = star_token;
+    if (cv_qualifier_seq)
+        ast->cv_qualifier_seq = cv_qualifier_seq->clone(pool);
+    return ast;
+}
+
 void PointerAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2046,7 +2804,6 @@ unsigned PointerAST::firstToken() const
 
 unsigned PointerAST::lastToken() const
 {
-    assert(0 && "review me");
     for (SpecifierAST *it = cv_qualifier_seq; it; it = it->next) {
         if (! it->next)
             return it->lastToken();
@@ -2054,6 +2811,18 @@ unsigned PointerAST::lastToken() const
     return star_token + 1;
 }
 
+PointerToMemberAST *PointerToMemberAST::clone(MemoryPool *pool) const
+{
+    PointerToMemberAST *ast = new (pool) PointerToMemberAST;
+    ast->global_scope_token = global_scope_token;
+    if (nested_name_specifier)
+        ast->nested_name_specifier = nested_name_specifier->clone(pool);
+    ast->star_token = star_token;
+    if (cv_qualifier_seq)
+        ast->cv_qualifier_seq = cv_qualifier_seq->clone(pool);
+    return ast;
+}
+
 void PointerToMemberAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2075,12 +2844,30 @@ unsigned PointerToMemberAST::firstToken() const
 
 unsigned PointerToMemberAST::lastToken() const
 {
-    assert(0 && "review me");
     for (SpecifierAST *it = cv_qualifier_seq; it; it = it->next) {
         if (! it->next)
             return it->lastToken();
     }
-    return star_token + 1;
+
+    if (star_token)
+        return star_token + 1;
+
+    for (NestedNameSpecifierAST *it = nested_name_specifier; it; it = it->next) {
+        if (! it->next)
+            return it->lastToken();
+    }
+
+    if (global_scope_token)
+        return global_scope_token + 1;
+
+    return 0;
+}
+
+PostIncrDecrAST *PostIncrDecrAST::clone(MemoryPool *pool) const
+{
+    PostIncrDecrAST *ast = new (pool) PostIncrDecrAST;
+    ast->incr_decr_token = incr_decr_token;
+    return ast;
 }
 
 void PostIncrDecrAST::accept0(ASTVisitor *visitor)
@@ -2096,10 +2883,19 @@ unsigned PostIncrDecrAST::firstToken() const
 
 unsigned PostIncrDecrAST::lastToken() const
 {
-    assert(0 && "review me");
     return incr_decr_token + 1;
 }
 
+PostfixExpressionAST *PostfixExpressionAST::clone(MemoryPool *pool) const
+{
+    PostfixExpressionAST *ast = new (pool) PostfixExpressionAST;
+    if (base_expression)
+        ast->base_expression = base_expression->clone(pool);
+    if (postfix_expressions)
+        ast->postfix_expressions = postfix_expressions->clone(pool);
+    return ast;
+}
+
 void PostfixExpressionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2116,7 +2912,6 @@ unsigned PostfixExpressionAST::firstToken() const
 
 unsigned PostfixExpressionAST::lastToken() const
 {
-    assert(0 && "review me");
     for (PostfixAST *it = postfix_expressions; it; it = it->next) {
         if (! it->next)
             return it->lastToken();
@@ -2124,6 +2919,17 @@ unsigned PostfixExpressionAST::lastToken() const
     return base_expression->lastToken();
 }
 
+QualifiedNameAST *QualifiedNameAST::clone(MemoryPool *pool) const
+{
+    QualifiedNameAST *ast = new (pool) QualifiedNameAST;
+    ast->global_scope_token = global_scope_token;
+    if (nested_name_specifier)
+        ast->nested_name_specifier = nested_name_specifier->clone(pool);
+    if (unqualified_name)
+        ast->unqualified_name = unqualified_name->clone(pool);
+    return ast;
+}
+
 void QualifiedNameAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2143,12 +2949,25 @@ unsigned QualifiedNameAST::firstToken() const
 
 unsigned QualifiedNameAST::lastToken() const
 {
-    assert(0 && "review me");
     if (unqualified_name)
         return unqualified_name->lastToken();
-    else if (nested_name_specifier)
-        return nested_name_specifier->lastToken();
-    return global_scope_token + 1;
+
+    for (NestedNameSpecifierAST *it = nested_name_specifier; it; it = it->next) {
+        if (! it->next)
+            return it->lastToken();
+    }
+
+    if (global_scope_token)
+        return global_scope_token + 1;
+
+    return 0;
+}
+
+ReferenceAST *ReferenceAST::clone(MemoryPool *pool) const
+{
+    ReferenceAST *ast = new (pool) ReferenceAST;
+    ast->amp_token = amp_token;
+    return ast;
 }
 
 void ReferenceAST::accept0(ASTVisitor *visitor)
@@ -2164,10 +2983,19 @@ unsigned ReferenceAST::firstToken() const
 
 unsigned ReferenceAST::lastToken() const
 {
-    assert(0 && "review me");
     return amp_token + 1;
 }
 
+ReturnStatementAST *ReturnStatementAST::clone(MemoryPool *pool) const
+{
+    ReturnStatementAST *ast = new (pool) ReturnStatementAST;
+    ast->return_token = return_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->semicolon_token = semicolon_token;
+    return ast;
+}
+
 void ReturnStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2182,8 +3010,22 @@ unsigned ReturnStatementAST::firstToken() const
 
 unsigned ReturnStatementAST::lastToken() const
 {
-    assert(0 && "review me");
-    return semicolon_token + 1;
+    if (semicolon_token)
+        return semicolon_token + 1;
+    else if (expression)
+        return expression->lastToken();
+    return return_token + 1;
+}
+
+SimpleDeclarationAST *SimpleDeclarationAST::clone(MemoryPool *pool) const
+{
+    SimpleDeclarationAST *ast = new (pool) SimpleDeclarationAST;
+    if (decl_specifier_seq)
+        ast->decl_specifier_seq = decl_specifier_seq->clone(pool);
+    if (declarators)
+        ast->declarators = declarators->clone(pool);
+    ast->semicolon_token = semicolon_token;
+    return ast;
 }
 
 void SimpleDeclarationAST::accept0(ASTVisitor *visitor)
@@ -2202,26 +3044,34 @@ unsigned SimpleDeclarationAST::firstToken() const
         return decl_specifier_seq->firstToken();
     else if (declarators)
         return declarators->firstToken();
-    else
-        return semicolon_token;
+    return semicolon_token;
 }
 
 unsigned SimpleDeclarationAST::lastToken() const
 {
-    assert(0 && "review me");
     if (semicolon_token)
         return semicolon_token + 1;
+
     for (DeclaratorListAST *it = declarators; it; it = it->next) {
         if (! it->next)
             return it->lastToken();
     }
+
     for (SpecifierAST *it = decl_specifier_seq; it; it = it->next) {
         if (! it->next)
             return it->lastToken();
     }
+
     return 0;
 }
 
+SimpleNameAST *SimpleNameAST::clone(MemoryPool *pool) const
+{
+    SimpleNameAST *ast = new (pool) SimpleNameAST;
+    ast->identifier_token = identifier_token;
+    return ast;
+}
+
 void SimpleNameAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2235,7 +3085,6 @@ unsigned SimpleNameAST::firstToken() const
 
 unsigned SimpleNameAST::lastToken() const
 {
-    assert(0 && "review me");
     return identifier_token + 1;
 }
 
@@ -2245,6 +3094,15 @@ void SimpleSpecifierAST::accept0(ASTVisitor *visitor)
     }
 }
 
+SimpleSpecifierAST *SimpleSpecifierAST::clone(MemoryPool *pool) const
+{
+    SimpleSpecifierAST *ast = new (pool) SimpleSpecifierAST;
+    ast->specifier_token = specifier_token;
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
+}
+
 unsigned SimpleSpecifierAST::firstToken() const
 {
     return specifier_token;
@@ -2252,10 +3110,20 @@ unsigned SimpleSpecifierAST::firstToken() const
 
 unsigned SimpleSpecifierAST::lastToken() const
 {
-    assert(0 && "review me");
     return specifier_token + 1;
 }
 
+TypeofSpecifierAST *TypeofSpecifierAST::clone(MemoryPool *pool) const
+{
+    TypeofSpecifierAST *ast = new (pool) TypeofSpecifierAST;
+    ast->typeof_token = typeof_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
+}
+
 void TypeofSpecifierAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2270,12 +3138,20 @@ unsigned TypeofSpecifierAST::firstToken() const
 
 unsigned TypeofSpecifierAST::lastToken() const
 {
-    assert(0 && "review me");
     if (expression)
         return expression->lastToken();
     return typeof_token + 1;
 }
 
+SizeofExpressionAST *SizeofExpressionAST::clone(MemoryPool *pool) const
+{
+    SizeofExpressionAST *ast = new (pool) SizeofExpressionAST;
+    ast->sizeof_token = sizeof_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    return ast;
+}
+
 void SizeofExpressionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2290,12 +3166,20 @@ unsigned SizeofExpressionAST::firstToken() const
 
 unsigned SizeofExpressionAST::lastToken() const
 {
-    assert(0 && "review me");
     if (expression)
         return expression->lastToken();
     return sizeof_token + 1;
 }
 
+StringLiteralAST *StringLiteralAST::clone(MemoryPool *pool) const
+{
+    StringLiteralAST *ast = new (pool) StringLiteralAST;
+    ast->token = token;
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
+}
+
 void StringLiteralAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2310,12 +3194,24 @@ unsigned StringLiteralAST::firstToken() const
 
 unsigned StringLiteralAST::lastToken() const
 {
-    assert(0 && "review me");
     if (next)
         return next->lastToken();
     return token + 1;
 }
 
+SwitchStatementAST *SwitchStatementAST::clone(MemoryPool *pool) const
+{
+    SwitchStatementAST *ast = new (pool) SwitchStatementAST;
+    ast->switch_token = switch_token;
+    ast->lparen_token = lparen_token;
+    if (condition)
+        ast->condition = condition->clone(pool);
+    ast->rparen_token = rparen_token;
+    if (statement)
+        ast->statement = statement->clone(pool);
+    return ast;
+}
+
 void SwitchStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2331,10 +3227,25 @@ unsigned SwitchStatementAST::firstToken() const
 
 unsigned SwitchStatementAST::lastToken() const
 {
-    assert(0 && "review me");
     if (statement)
         return statement->lastToken();
-    return rparen_token + 1;
+    else if (rparen_token)
+        return rparen_token + 1;
+    else if (condition)
+        return condition->lastToken();
+    else if (lparen_token)
+        return lparen_token + 1;
+    return switch_token + 1;
+}
+
+TemplateArgumentListAST *TemplateArgumentListAST::clone(MemoryPool *pool) const
+{
+    TemplateArgumentListAST *ast = new (pool) TemplateArgumentListAST;
+    if (template_argument)
+        ast->template_argument = template_argument->clone(pool);
+    if (next)
+        ast->next = next->clone(pool);
+    return ast;
 }
 
 void TemplateArgumentListAST::accept0(ASTVisitor *visitor)
@@ -2352,14 +3263,27 @@ unsigned TemplateArgumentListAST::firstToken() const
 
 unsigned TemplateArgumentListAST::lastToken() const
 {
-    assert(0 && "review me");
     for (const TemplateArgumentListAST *it = this; it; it = it->next) {
-        if (! it->next)
+        if (! it->next && it->template_argument)
             return it->template_argument->lastToken();
     }
     return 0;
 }
 
+TemplateDeclarationAST *TemplateDeclarationAST::clone(MemoryPool *pool) const
+{
+    TemplateDeclarationAST *ast = new (pool) TemplateDeclarationAST;
+    ast->export_token = export_token;
+    ast->template_token = template_token;
+    ast->less_token = less_token;
+    if (template_parameters)
+        ast->template_parameters = template_parameters->clone(pool);
+    ast->greater_token = greater_token;
+    if (declaration)
+        ast->declaration = declaration->clone(pool);
+    return ast;
+}
+
 void TemplateDeclarationAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2379,10 +3303,35 @@ unsigned TemplateDeclarationAST::firstToken() const
 
 unsigned TemplateDeclarationAST::lastToken() const
 {
-    assert(0 && "review me");
     if (declaration)
         return declaration->lastToken();
-    return greater_token + 1;
+    else if (greater_token)
+        return greater_token + 1;
+
+    for (DeclarationAST *it = template_parameters; it; it = it->next) {
+        if (! it->next)
+            return it->lastToken();
+    }
+
+    if (less_token)
+        return less_token + 1;
+    else if (template_token)
+        return template_token + 1;
+    else if (export_token)
+        return export_token + 1;
+
+    return 0;
+}
+
+TemplateIdAST *TemplateIdAST::clone(MemoryPool *pool) const
+{
+    TemplateIdAST *ast = new (pool) TemplateIdAST;
+    ast->identifier_token = identifier_token;
+    ast->less_token = less_token;
+    if (template_arguments)
+        ast->template_arguments = template_arguments->clone(pool);
+    ast->greater_token = greater_token;
+    return ast;
 }
 
 void TemplateIdAST::accept0(ASTVisitor *visitor)
@@ -2401,8 +3350,35 @@ unsigned TemplateIdAST::firstToken() const
 
 unsigned TemplateIdAST::lastToken() const
 {
-    assert(0 && "review me");
-    return greater_token + 1;
+    if (greater_token)
+        return greater_token + 1;
+
+    for (TemplateArgumentListAST *it = template_arguments; it; it = it->next) {
+        if (! it->next && it->template_argument)
+            return it->template_argument->lastToken();
+    }
+
+    if (less_token)
+        return less_token + 1;
+
+    return identifier_token + 1;
+}
+
+TemplateTypeParameterAST *TemplateTypeParameterAST::clone(MemoryPool *pool) const
+{
+    TemplateTypeParameterAST *ast = new (pool) TemplateTypeParameterAST;
+    ast->template_token = template_token;
+    ast->less_token = less_token;
+    if (template_parameters)
+        ast->template_parameters = template_parameters->clone(pool);
+    ast->greater_token = greater_token;
+    ast->class_token = class_token;
+    if (name)
+        ast->name = name->clone(pool);
+    ast->equal_token = equal_token;
+    if (type_id)
+        ast->type_id = type_id->clone(pool);
+    return ast;
 }
 
 void TemplateTypeParameterAST::accept0(ASTVisitor *visitor)
@@ -2418,7 +3394,6 @@ unsigned TemplateTypeParameterAST::firstToken() const
 
 unsigned TemplateTypeParameterAST::lastToken() const
 {
-    assert(0 && "review me");
     if (type_id)
         return type_id->lastToken();
     else if (equal_token)
@@ -2427,7 +3402,25 @@ unsigned TemplateTypeParameterAST::lastToken() const
         return name->lastToken();
     else if (class_token)
         return class_token + 1;
-    return greater_token + 1;
+    else if (greater_token)
+        return greater_token + 1;
+
+    for (DeclarationAST *it = template_parameters; it; it = it->next) {
+        if (! it->next)
+            return it->lastToken();
+    }
+
+    if (less_token)
+        return less_token + 1;
+
+    return template_token + 1;
+}
+
+ThisExpressionAST *ThisExpressionAST::clone(MemoryPool *pool) const
+{
+    ThisExpressionAST *ast = new (pool) ThisExpressionAST;
+    ast->this_token = this_token;
+    return ast;
 }
 
 void ThisExpressionAST::accept0(ASTVisitor *visitor)
@@ -2443,10 +3436,18 @@ unsigned ThisExpressionAST::firstToken() const
 
 unsigned ThisExpressionAST::lastToken() const
 {
-    assert(0 && "review me");
     return this_token + 1;
 }
 
+ThrowExpressionAST *ThrowExpressionAST::clone(MemoryPool *pool) const
+{
+    ThrowExpressionAST *ast = new (pool) ThrowExpressionAST;
+    ast->throw_token = throw_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    return ast;
+}
+
 void ThrowExpressionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2461,12 +3462,19 @@ unsigned ThrowExpressionAST::firstToken() const
 
 unsigned ThrowExpressionAST::lastToken() const
 {
-    assert(0 && "review me");
     if (expression)
         return expression->lastToken();
     return throw_token + 1;
 }
 
+TranslationUnitAST *TranslationUnitAST::clone(MemoryPool *pool) const
+{
+    TranslationUnitAST *ast = new (pool) TranslationUnitAST;
+    if (declarations)
+        ast->declarations = declarations->clone(pool);
+    return ast;
+}
+
 void TranslationUnitAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2483,7 +3491,6 @@ unsigned TranslationUnitAST::firstToken() const
 
 unsigned TranslationUnitAST::lastToken() const
 {
-    assert(0 && "review me");
     for (DeclarationAST *it = declarations; it; it = it->next) {
         if (! it->next)
             return it->lastToken();
@@ -2491,6 +3498,17 @@ unsigned TranslationUnitAST::lastToken() const
     return 0;
 }
 
+TryBlockStatementAST *TryBlockStatementAST::clone(MemoryPool *pool) const
+{
+    TryBlockStatementAST *ast = new (pool) TryBlockStatementAST;
+    ast->try_token = try_token;
+    if (statement)
+        ast->statement = statement->clone(pool);
+    if (catch_clause_seq)
+        ast->catch_clause_seq = catch_clause_seq->clone(pool);
+    return ast;
+}
+
 void TryBlockStatementAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2506,16 +3524,29 @@ unsigned TryBlockStatementAST::firstToken() const
 
 unsigned TryBlockStatementAST::lastToken() const
 {
-    assert(0 && "review me");
     for (CatchClauseAST *it = catch_clause_seq; it; it = it->next) {
         if (! it->next)
             return it->lastToken();
     }
+
     if (statement)
         return statement->lastToken();
+
     return try_token + 1;
 }
 
+TypeConstructorCallAST *TypeConstructorCallAST::clone(MemoryPool *pool) const
+{
+    TypeConstructorCallAST *ast = new (pool) TypeConstructorCallAST;
+    if (type_specifier)
+        ast->type_specifier = type_specifier->clone(pool);
+    ast->lparen_token = lparen_token;
+    if (expression_list)
+        ast->expression_list = expression_list;
+    ast->rparen_token = rparen_token;
+    return ast;
+}
+
 void TypeConstructorCallAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2534,8 +3565,24 @@ unsigned TypeConstructorCallAST::firstToken() const
 
 unsigned TypeConstructorCallAST::lastToken() const
 {
-    assert(0 && "review me");
-    return rparen_token + 1;
+    if (rparen_token)
+        return rparen_token + 1;
+
+    for (ExpressionListAST *it = expression_list; it; it = it->next) {
+        if (! it->next)
+            return it->lastToken();
+    }
+
+    if (lparen_token)
+        return lparen_token + 1;
+
+
+    for (SpecifierAST *it = type_specifier; it; it = it->next) {
+        if (! it->next)
+            return it->lastToken();
+    }
+
+    return 0;
 }
 
 void TypeIdAST::accept0(ASTVisitor *visitor)
@@ -2554,10 +3601,26 @@ unsigned TypeIdAST::firstToken() const
 
 unsigned TypeIdAST::lastToken() const
 {
-    assert(0 && "review me");
     if (declarator)
         return declarator->lastToken();
-    return type_specifier->lastToken();
+
+    for (SpecifierAST *it = type_specifier; it; it = it->next) {
+        if (! it->next)
+            return it->lastToken();
+    }
+
+    return 0;
+}
+
+TypeidExpressionAST *TypeidExpressionAST::clone(MemoryPool *pool) const
+{
+    TypeidExpressionAST *ast = new (pool) TypeidExpressionAST;
+    ast->typeid_token = typeid_token;
+    ast->lparen_token = lparen_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    ast->rparen_token = rparen_token;
+    return ast;
 }
 
 void TypeidExpressionAST::accept0(ASTVisitor *visitor)
@@ -2574,8 +3637,27 @@ unsigned TypeidExpressionAST::firstToken() const
 
 unsigned TypeidExpressionAST::lastToken() const
 {
-    assert(0 && "review me");
-    return rparen_token + 1;
+    if (rparen_token)
+        return rparen_token + 1;
+    else if (expression)
+        return expression->lastToken();
+    else if (lparen_token)
+        return lparen_token + 1;
+
+    return typeid_token + 1;
+}
+
+TypenameCallExpressionAST *TypenameCallExpressionAST::clone(MemoryPool *pool) const
+{
+    TypenameCallExpressionAST *ast = new (pool) TypenameCallExpressionAST;
+    ast->typename_token = typename_token;
+    if (name)
+        ast->name = name->clone(pool);
+    ast->lparen_token = lparen_token;
+    if (expression_list)
+        ast->expression_list = expression_list;
+    ast->rparen_token = rparen_token;
+    return ast;
 }
 
 void TypenameCallExpressionAST::accept0(ASTVisitor *visitor)
@@ -2595,8 +3677,32 @@ unsigned TypenameCallExpressionAST::firstToken() const
 
 unsigned TypenameCallExpressionAST::lastToken() const
 {
-    assert(0 && "review me");
-    return rparen_token + 1;
+    if (rparen_token)
+        return rparen_token + 1;
+
+    for (ExpressionListAST *it = expression_list; it; it = it->next) {
+        if (! it->next)
+            return it->lastToken();
+    }
+
+    if (lparen_token)
+        return lparen_token + 1;
+    else if (name)
+        return name->lastToken();
+
+    return typename_token + 1;
+}
+
+TypenameTypeParameterAST *TypenameTypeParameterAST::clone(MemoryPool *pool) const
+{
+    TypenameTypeParameterAST *ast = new (pool) TypenameTypeParameterAST;
+    ast->classkey_token = classkey_token;
+    if (name)
+        ast->name = name->clone(pool);
+    ast->equal_token = equal_token;
+    if (type_id)
+        ast->type_id = type_id->clone(pool);
+    return ast;
 }
 
 void TypenameTypeParameterAST::accept0(ASTVisitor *visitor)
@@ -2614,7 +3720,6 @@ unsigned TypenameTypeParameterAST::firstToken() const
 
 unsigned TypenameTypeParameterAST::lastToken() const
 {
-    assert(0 && "review me");
     if (type_id)
         return type_id->lastToken();
     else if (equal_token)
@@ -2624,6 +3729,15 @@ unsigned TypenameTypeParameterAST::lastToken() const
     return classkey_token + 1;
 }
 
+UnaryExpressionAST *UnaryExpressionAST::clone(MemoryPool *pool) const
+{
+    UnaryExpressionAST *ast = new (pool) UnaryExpressionAST;
+    ast->unary_op_token = unary_op_token;
+    if (expression)
+        ast->expression = expression->clone(pool);
+    return ast;
+}
+
 void UnaryExpressionAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2638,12 +3752,22 @@ unsigned UnaryExpressionAST::firstToken() const
 
 unsigned UnaryExpressionAST::lastToken() const
 {
-    assert(0 && "review me");
     if (expression)
         return expression->lastToken();
     return unary_op_token + 1;
 }
 
+UsingAST *UsingAST::clone(MemoryPool *pool) const
+{
+    UsingAST *ast = new (pool) UsingAST;
+    ast->using_token = using_token;
+    ast->typename_token = typename_token;
+    if (name)
+        ast->name = name->clone(pool);
+    ast->semicolon_token = semicolon_token;
+    return ast;
+}
+
 void UsingAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -2658,8 +3782,24 @@ unsigned UsingAST::firstToken() const
 
 unsigned UsingAST::lastToken() const
 {
-    assert(0 && "review me");
-    return semicolon_token + 1;
+    if (semicolon_token)
+        return semicolon_token + 1;
+    else if (name)
+        return name->lastToken();
+    else if (typename_token)
+        return typename_token + 1;
+    return using_token + 1;
+}
+
+UsingDirectiveAST *UsingDirectiveAST::clone(MemoryPool *pool) const
+{
+    UsingDirectiveAST *ast = new (pool) UsingDirectiveAST;
+    ast->using_token = using_token;
+    ast->namespace_token = namespace_token;
+    if (name)
+        ast->name = name->clone(pool);
+    ast->semicolon_token = semicolon_token;
+    return ast;
 }
 
 void UsingDirectiveAST::accept0(ASTVisitor *visitor)
@@ -2676,8 +3816,26 @@ unsigned UsingDirectiveAST::firstToken() const
 
 unsigned UsingDirectiveAST::lastToken() const
 {
-    assert(0 && "review me");
-    return semicolon_token + 1;
+    if (semicolon_token)
+        return semicolon_token + 1;
+    else if (name)
+        return name->lastToken();
+    else if (namespace_token)
+        return namespace_token + 1;
+    return using_token + 1;
+}
+
+WhileStatementAST *WhileStatementAST::clone(MemoryPool *pool) const
+{
+    WhileStatementAST *ast = new (pool) WhileStatementAST;
+    ast->while_token = while_token;
+    ast->lparen_token = lparen_token;
+    if (condition)
+        ast->condition = condition->clone(pool);
+    ast->rparen_token = rparen_token;
+    if (statement)
+        ast->statement = statement->clone(pool);
+    return ast;
 }
 
 void WhileStatementAST::accept0(ASTVisitor *visitor)
@@ -2695,10 +3853,15 @@ unsigned WhileStatementAST::firstToken() const
 
 unsigned WhileStatementAST::lastToken() const
 {
-    assert(0 && "review me");
     if (statement)
         return statement->lastToken();
-    return rparen_token + 1;
+    else if (rparen_token)
+        return rparen_token + 1;
+    else if (condition)
+        return condition->lastToken();
+    else if (lparen_token)
+        return lparen_token + 1;
+    return while_token + 1;
 }
 
 CPLUSPLUS_END_NAMESPACE
diff --git a/shared/cplusplus/AST.h b/shared/cplusplus/AST.h
index be4f26d9f9..ace137760f 100644
--- a/shared/cplusplus/AST.h
+++ b/shared/cplusplus/AST.h
@@ -183,6 +183,8 @@ public:
     UsingDirectiveAST *asUsingDirective();
     WhileStatementAST *asWhileStatement();
 
+    virtual AST *clone(MemoryPool *pool) const = 0;
+
 protected:
     virtual void accept0(ASTVisitor *visitor) = 0;
 };
@@ -191,6 +193,9 @@ class CPLUSPLUS_EXPORT SpecifierAST: public AST
 {
 public:
     SpecifierAST *next;
+
+public:
+    virtual SpecifierAST *clone(MemoryPool *pool) const = 0;
 };
 
 class CPLUSPLUS_EXPORT SimpleSpecifierAST: public SpecifierAST
@@ -202,6 +207,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual SimpleSpecifierAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -220,6 +227,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual AttributeSpecifierAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -238,6 +247,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual AttributeAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -252,6 +263,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TypeofSpecifierAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -260,28 +273,39 @@ class CPLUSPLUS_EXPORT StatementAST: public AST
 {
 public:
     StatementAST *next;
+
+public:
+    virtual StatementAST *clone(MemoryPool *pool) const = 0;
 };
 
 class CPLUSPLUS_EXPORT ExpressionAST: public AST
 {
 public:
+    virtual ExpressionAST *clone(MemoryPool *pool) const = 0;
 };
 
 class CPLUSPLUS_EXPORT DeclarationAST: public AST
 {
 public:
     DeclarationAST *next;
+
+public:
+    virtual DeclarationAST *clone(MemoryPool *pool) const = 0;
 };
 
 class CPLUSPLUS_EXPORT CoreDeclaratorAST: public AST
 {
 public:
+    virtual CoreDeclaratorAST *clone(MemoryPool *pool) const = 0;
 };
 
 class CPLUSPLUS_EXPORT PostfixDeclaratorAST: public AST
 {
 public:
     PostfixDeclaratorAST *next;
+
+public:
+    virtual PostfixDeclaratorAST *clone(MemoryPool *pool) const = 0;
 };
 
 class CPLUSPLUS_EXPORT DeclaratorAST: public AST
@@ -297,6 +321,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual DeclaratorAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -311,6 +337,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ExpressionListAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -326,6 +354,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual SimpleDeclarationAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -339,6 +369,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual EmptyDeclarationAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -354,6 +386,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual AccessDeclarationAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -371,6 +405,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual AsmDefinitionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -387,6 +423,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual BaseSpecifierAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -403,6 +441,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual QtMethodAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -418,6 +458,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual BinaryExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -434,6 +476,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual CastExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -454,6 +498,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ClassSpecifierAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -470,6 +516,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual CaseStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -485,6 +533,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual CompoundStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -499,6 +549,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ConditionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -516,6 +568,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ConditionalExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -535,6 +589,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual CppCastExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -549,6 +605,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual CtorInitializerAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -562,6 +620,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual DeclarationStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -575,6 +635,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual DeclaratorIdAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -590,6 +652,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual NestedDeclaratorAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -607,6 +671,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual FunctionDeclaratorAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -622,6 +688,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ArrayDeclaratorAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -636,6 +704,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual DeclaratorListAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -653,6 +723,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual DeleteExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -672,6 +744,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual DoStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -685,6 +759,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual NamedTypeSpecifierAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -699,6 +775,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ElaboratedTypeSpecifierAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -716,6 +794,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual EnumSpecifierAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -732,6 +812,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual EnumeratorAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -747,6 +829,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ExceptionDeclarationAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -764,6 +848,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ExceptionSpecificationAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -778,6 +864,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ExpressionOrDeclarationStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -792,6 +880,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ExpressionStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -808,6 +898,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual FunctionDefinitionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -828,6 +920,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ForStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -847,6 +941,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual IfStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -862,6 +958,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ArrayInitializerAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -877,6 +975,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual LabeledStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -892,6 +992,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual LinkageBodyAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -907,6 +1009,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual LinkageSpecificationAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -924,6 +1028,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual MemInitializerAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -931,6 +1037,7 @@ protected:
 class CPLUSPLUS_EXPORT NameAST: public ExpressionAST
 {
 public:
+    virtual NameAST *clone(MemoryPool *pool) const = 0;
 };
 
 class CPLUSPLUS_EXPORT NestedNameSpecifierAST: public AST
@@ -944,6 +1051,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual NestedNameSpecifierAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -959,6 +1068,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual QualifiedNameAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -973,6 +1084,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual OperatorFunctionIdAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -988,6 +1101,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ConversionFunctionIdAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1001,6 +1116,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual SimpleNameAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1015,6 +1132,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual DestructorNameAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1031,6 +1150,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TemplateIdAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1047,6 +1168,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual NamespaceAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1064,6 +1187,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual NamespaceAliasDefinitionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1078,6 +1203,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual NewDeclaratorAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1096,6 +1223,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual NewExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1111,6 +1240,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual NewInitializerAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1126,6 +1257,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual NewTypeIdAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1141,6 +1274,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual OperatorAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1157,6 +1292,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ParameterDeclarationAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1171,6 +1308,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ParameterDeclarationClauseAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1179,6 +1318,9 @@ class CPLUSPLUS_EXPORT PostfixAST: public AST
 {
 public:
     PostfixAST *next;
+
+public:
+    virtual PostfixAST *clone(MemoryPool *pool) const = 0;
 };
 
 class CPLUSPLUS_EXPORT CallAST: public PostfixAST
@@ -1192,6 +1334,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual CallAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1207,6 +1351,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ArrayAccessAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1220,6 +1366,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual PostIncrDecrAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1235,6 +1383,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual MemberAccessAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1251,6 +1401,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TypeidExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1268,6 +1420,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TypenameCallExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1284,6 +1438,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TypeConstructorCallAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1298,6 +1454,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual PostfixExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1306,6 +1464,9 @@ class CPLUSPLUS_EXPORT PtrOperatorAST: public AST
 {
 public:
     PtrOperatorAST *next;
+
+public:
+    virtual PtrOperatorAST *clone(MemoryPool *pool) const = 0;
 };
 
 class CPLUSPLUS_EXPORT PointerToMemberAST: public PtrOperatorAST
@@ -1320,6 +1481,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual PointerToMemberAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1334,6 +1497,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual PointerAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1347,6 +1512,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ReferenceAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1361,6 +1528,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual BreakStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1375,6 +1544,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ContinueStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1390,6 +1561,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual GotoStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1405,6 +1578,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ReturnStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1419,6 +1594,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual SizeofExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1432,6 +1609,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual NumericLiteralAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1445,6 +1624,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual BoolLiteralAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1458,6 +1639,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ThisExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1473,6 +1656,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual NestedExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1487,6 +1672,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual StringLiteralAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1504,6 +1691,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual SwitchStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1518,6 +1707,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TemplateArgumentListAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1536,6 +1727,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TemplateDeclarationAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1550,6 +1743,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual ThrowExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1563,6 +1758,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TranslationUnitAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1578,6 +1775,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TryBlockStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1596,6 +1795,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual CatchClauseAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1610,6 +1811,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TypeIdAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1626,6 +1829,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TypenameTypeParameterAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1646,6 +1851,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual TemplateTypeParameterAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1660,6 +1867,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual UnaryExpressionAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1676,6 +1885,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual UsingAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1692,6 +1903,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual UsingDirectiveAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
@@ -1709,6 +1922,8 @@ public:
     virtual unsigned firstToken() const;
     virtual unsigned lastToken() const;
 
+    virtual WhileStatementAST *clone(MemoryPool *pool) const;
+
 protected:
     virtual void accept0(ASTVisitor *visitor);
 };
diff --git a/shared/cplusplus/PrettyPrinter.cpp b/shared/cplusplus/PrettyPrinter.cpp
index 7664d5b6d4..72338576b6 100644
--- a/shared/cplusplus/PrettyPrinter.cpp
+++ b/shared/cplusplus/PrettyPrinter.cpp
@@ -33,8 +33,10 @@
 
 #include "PrettyPrinter.h"
 #include "AST.h"
+#include "Token.h"
 #include <iostream>
 #include <string>
+#include <cassert>
 
 CPLUSPLUS_USE_NAMESPACE
 
@@ -144,12 +146,16 @@ bool PrettyPrinter::visit(AttributeAST *ast)
 bool PrettyPrinter::visit(BaseSpecifierAST *ast)
 {
     if (ast->token_virtual && ast->token_access_specifier) {
-        out << "virtual ";
+        out << "virtual";
+        out << ' ';
         out << spell(ast->token_access_specifier);
+        out << ' ';
     } else if (ast->token_virtual) {
         out << "virtual";
+        out << ' ';
     } else if (ast->token_access_specifier) {
         out << spell(ast->token_access_specifier);
+        out << ' ';
     }
     accept(ast->name);
     return false;
@@ -192,7 +198,24 @@ bool PrettyPrinter::visit(CaseStatementAST *ast)
     out << "case ";
     accept(ast->expression);
     out << ':';
-    accept(ast->statement);
+    if (! ast->statement) {
+        newline();
+        return false;
+    }
+
+    if (ast->statement->asCompoundStatement()) {
+        out << ' ';
+        accept(ast->statement);
+    } else if (ast->statement->asCaseStatement() || ast->statement->asLabeledStatement()) {
+        newline();
+        accept(ast->statement);
+    } else {
+        indent();
+        newline();
+        accept(ast->statement);
+        deindent();
+        newline();
+    }
     return false;
 }
 
@@ -233,6 +256,7 @@ bool PrettyPrinter::visit(ClassSpecifierAST *ast)
                 out << ", ";
         }
     }
+    newline();
     out << '{';
     if (ast->member_specifiers) {
         indent();
@@ -365,6 +389,7 @@ bool PrettyPrinter::visit(DeclaratorAST *ast)
             out << ' ';
     }
     if (ast->initializer) {
+        out << ' ';
         out << '=';
         out << ' ';
         accept(ast->initializer);
@@ -451,11 +476,20 @@ bool PrettyPrinter::visit(EnumSpecifierAST *ast)
         out << ' ';
         accept(ast->name);
     }
+    out << ' ';
     out << '{';
-    for (EnumeratorAST *it = ast->enumerators; it; it = it->next) {
-        accept(it);
-        if (it->next)
-            out << ", ";
+    if (ast->enumerators) {
+        indent();
+        newline();
+        for (EnumeratorAST *it = ast->enumerators; it; it = it->next) {
+            accept(it);
+            if (it->next) {
+                out << ", ";
+                newline();
+            }
+        }
+        deindent();
+        newline();
     }
     out << '}';
     return false;
@@ -550,9 +584,8 @@ bool PrettyPrinter::visit(FunctionDeclaratorAST *ast)
     accept(ast->parameters);
     out << ')';
     for (SpecifierAST *it = ast->cv_qualifier_seq; it; it = it->next) {
+        out << ' ';
         accept(it);
-        if (it->next)
-            out << ' ';
     }
     if (ast->exception_specification) {
         out << ' ';
@@ -597,9 +630,10 @@ bool PrettyPrinter::visit(IfStatementAST *ast)
     out << '(';
     accept(ast->condition);
     out << ')';
-    if (ast->statement->asCompoundStatement())
+    if (ast->statement->asCompoundStatement()) {
+        out << ' ';
         accept(ast->statement);
-    else {
+    } else {
         indent();
         newline();
         accept(ast->statement);
@@ -797,7 +831,17 @@ bool PrettyPrinter::visit(NewTypeIdAST *ast)
 
 bool PrettyPrinter::visit(NumericLiteralAST *ast)
 {
-    out << spell(ast->token);
+    switch (tokenKind(ast->token)) {
+    case T_CHAR_LITERAL:
+        out << '\'' << spell(ast->token) << '\'';
+        break;
+    case T_WIDE_CHAR_LITERAL:
+        out << "L\'" << spell(ast->token) << '\'';
+        break;
+
+    default:
+        out << spell(ast->token);
+    }
     return false;
 }
 
@@ -962,10 +1006,13 @@ bool PrettyPrinter::visit(SizeofExpressionAST *ast)
 
 bool PrettyPrinter::visit(StringLiteralAST *ast)
 {
-    out << '"' << spell(ast->token) << '"';
-    if (ast->next) {
-        out << ' ';
-        accept(ast->next);
+    for (StringLiteralAST *it = ast; it; it = it->next) {
+        if (tokenKind(ast->token) == T_STRING_LITERAL)
+            out << '"' << spell(ast->token) << '"';
+        else
+            out << "L\"" << spell(ast->token) << '"';
+        if (it->next)
+            out << ' ';
     }
     return false;
 }
@@ -1213,7 +1260,16 @@ bool PrettyPrinter::visit(WhileStatementAST *ast)
     out << '(';
     accept(ast->condition);
     out << ')';
-    accept(ast->statement);
+    out << ' ';
+    if (ast->statement && ast->statement->asCompoundStatement())
+        accept(ast->statement);
+    else {
+        indent();
+        newline();
+        accept(ast->statement);
+        deindent();
+        newline();
+    }
     return false;
 }
 
diff --git a/shared/proparser/profileevaluator.cpp b/shared/proparser/profileevaluator.cpp
index d5a88895cb..7f029f0018 100644
--- a/shared/proparser/profileevaluator.cpp
+++ b/shared/proparser/profileevaluator.cpp
@@ -770,6 +770,11 @@ bool ProFileEvaluator::Private::visitProValue(ProValue *value)
                     removeEach(&m_valuemap, varName, v);
                     removeEach(&m_filevaluemap[currentProFile()], varName, v);
                 }
+            } else if (!m_skipLevel) {
+                // this is a hack for the moment to fix the
+                // CONFIG -= app_bundle problem on Mac (add it to a variable -CONFIG as was done before)
+                insertUnique(&m_valuemap, QString("-%1").arg(varName), v);
+                insertUnique(&m_filevaluemap[currentProFile()], QString("-%1").arg(varName), v);
             } else {
                 // We are stingy with our values, too.
             }