src/shared/cplusplus/ASTClone.cpp

   1 /**************************************************************************
   2 **
   3 ** This file is part of Qt Creator
   4 **
   5 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
   6 **
   7 ** Contact: Nokia Corporation (info@qt.nokia.com)
   8 **
   9 **
  10 ** GNU Lesser General Public License Usage
  11 **
  12 ** This file may be used under the terms of the GNU Lesser General Public
  13 ** License version 2.1 as published by the Free Software Foundation and
  14 ** appearing in the file LICENSE.LGPL included in the packaging of this file.
  15 ** Please review the following information to ensure the GNU Lesser General
  16 ** Public License version 2.1 requirements will be met:
  17 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  18 **
  19 ** In addition, as a special exception, Nokia gives you certain additional
  20 ** rights. These rights are described in the Nokia Qt LGPL Exception
  21 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  22 **
  23 ** Other Usage
  24 **
  25 ** Alternatively, this file may be used in accordance with the terms and
  26 ** conditions contained in a signed written agreement between you and Nokia.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **************************************************************************/
  32
  33 //
  34 //  W A R N I N G
  35 //  -------------
  36 //
  37 // This file is automatically generated.
  38 // Changes will be lost.
  39 //
  40
  41 #include "AST.h"
  42 #include "MemoryPool.h"
  43
  44 using namespace CPlusPlus;
  45
  46 ObjCSelectorArgumentAST *ObjCSelectorArgumentAST::clone(MemoryPool *pool) const
  47 {
  48     ObjCSelectorArgumentAST *ast = new (pool) ObjCSelectorArgumentAST;
  49     ast->name_token = name_token;
  50     ast->colon_token = colon_token;
  51     return ast;
  52 }
  53
  54 ObjCSelectorAST *ObjCSelectorAST::clone(MemoryPool *pool) const
  55 {
  56     ObjCSelectorAST *ast = new (pool) ObjCSelectorAST;
  57     for (ObjCSelectorArgumentListAST *iter = selector_argument_list, **ast_iter = &ast->selector_argument_list;
  58          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
  59         *ast_iter = new (pool) ObjCSelectorArgumentListAST((iter->value) ? iter->value->clone(pool) : 0);
  60     return ast;
  61 }
  62
  63 SimpleSpecifierAST *SimpleSpecifierAST::clone(MemoryPool *pool) const
  64 {
  65     SimpleSpecifierAST *ast = new (pool) SimpleSpecifierAST;
  66     ast->specifier_token = specifier_token;
  67     return ast;
  68 }
  69
  70 AttributeSpecifierAST *AttributeSpecifierAST::clone(MemoryPool *pool) const
  71 {
  72     AttributeSpecifierAST *ast = new (pool) AttributeSpecifierAST;
  73     ast->attribute_token = attribute_token;
  74     ast->first_lparen_token = first_lparen_token;
  75     ast->second_lparen_token = second_lparen_token;
  76     for (AttributeListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
  77          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
  78         *ast_iter = new (pool) AttributeListAST((iter->value) ? iter->value->clone(pool) : 0);
  79     ast->first_rparen_token = first_rparen_token;
  80     ast->second_rparen_token = second_rparen_token;
  81     return ast;
  82 }
  83
  84 AttributeAST *AttributeAST::clone(MemoryPool *pool) const
  85 {
  86     AttributeAST *ast = new (pool) AttributeAST;
  87     ast->identifier_token = identifier_token;
  88     ast->lparen_token = lparen_token;
  89     ast->tag_token = tag_token;
  90     for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
  91          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
  92         *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);
  93     ast->rparen_token = rparen_token;
  94     return ast;
  95 }
  96
  97 TypeofSpecifierAST *TypeofSpecifierAST::clone(MemoryPool *pool) const
  98 {
  99     TypeofSpecifierAST *ast = new (pool) TypeofSpecifierAST;
 100     ast->typeof_token = typeof_token;
 101     ast->lparen_token = lparen_token;
 102     if (expression)
 103         ast->expression = expression->clone(pool);
 104     ast->rparen_token = rparen_token;
 105     return ast;
 106 }
 107
 108 DeclaratorAST *DeclaratorAST::clone(MemoryPool *pool) const
 109 {
 110     DeclaratorAST *ast = new (pool) DeclaratorAST;
 111     for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
 112          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 113         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 114     for (PtrOperatorListAST *iter = ptr_operator_list, **ast_iter = &ast->ptr_operator_list;
 115          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 116         *ast_iter = new (pool) PtrOperatorListAST((iter->value) ? iter->value->clone(pool) : 0);
 117     if (core_declarator)
 118         ast->core_declarator = core_declarator->clone(pool);
 119     for (PostfixDeclaratorListAST *iter = postfix_declarator_list, **ast_iter = &ast->postfix_declarator_list;
 120          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 121         *ast_iter = new (pool) PostfixDeclaratorListAST((iter->value) ? iter->value->clone(pool) : 0);
 122     for (SpecifierListAST *iter = post_attribute_list, **ast_iter = &ast->post_attribute_list;
 123          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 124         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 125     ast->equal_token = equal_token;
 126     if (initializer)
 127         ast->initializer = initializer->clone(pool);
 128     return ast;
 129 }
 130
 131 SimpleDeclarationAST *SimpleDeclarationAST::clone(MemoryPool *pool) const
 132 {
 133     SimpleDeclarationAST *ast = new (pool) SimpleDeclarationAST;
 134     ast->qt_invokable_token = qt_invokable_token;
 135     for (SpecifierListAST *iter = decl_specifier_list, **ast_iter = &ast->decl_specifier_list;
 136          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 137         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 138     for (DeclaratorListAST *iter = declarator_list, **ast_iter = &ast->declarator_list;
 139          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 140         *ast_iter = new (pool) DeclaratorListAST((iter->value) ? iter->value->clone(pool) : 0);
 141     ast->semicolon_token = semicolon_token;
 142     return ast;
 143 }
 144
 145 EmptyDeclarationAST *EmptyDeclarationAST::clone(MemoryPool *pool) const
 146 {
 147     EmptyDeclarationAST *ast = new (pool) EmptyDeclarationAST;
 148     ast->semicolon_token = semicolon_token;
 149     return ast;
 150 }
 151
 152 AccessDeclarationAST *AccessDeclarationAST::clone(MemoryPool *pool) const
 153 {
 154     AccessDeclarationAST *ast = new (pool) AccessDeclarationAST;
 155     ast->access_specifier_token = access_specifier_token;
 156     ast->slots_token = slots_token;
 157     ast->colon_token = colon_token;
 158     return ast;
 159 }
 160
 161 QtObjectTagAST *QtObjectTagAST::clone(MemoryPool *pool) const
 162 {
 163     QtObjectTagAST *ast = new (pool) QtObjectTagAST;
 164     ast->q_object_token = q_object_token;
 165     return ast;
 166 }
 167
 168 QtPrivateSlotAST *QtPrivateSlotAST::clone(MemoryPool *pool) const
 169 {
 170     QtPrivateSlotAST *ast = new (pool) QtPrivateSlotAST;
 171     ast->q_private_slot_token = q_private_slot_token;
 172     ast->lparen_token = lparen_token;
 173     ast->dptr_token = dptr_token;
 174     ast->dptr_lparen_token = dptr_lparen_token;
 175     ast->dptr_rparen_token = dptr_rparen_token;
 176     ast->comma_token = comma_token;
 177     for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
 178          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 179         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 180     if (declarator)
 181         ast->declarator = declarator->clone(pool);
 182     ast->rparen_token = rparen_token;
 183     return ast;
 184 }
 185
 186 QtPropertyDeclarationItemAST *QtPropertyDeclarationItemAST::clone(MemoryPool *pool) const
 187 {
 188     QtPropertyDeclarationItemAST *ast = new (pool) QtPropertyDeclarationItemAST;
 189     ast->item_name_token = item_name_token;
 190     if (expression)
 191         ast->expression = expression->clone(pool);
 192     return ast;
 193 }
 194
 195 QtPropertyDeclarationAST *QtPropertyDeclarationAST::clone(MemoryPool *pool) const
 196 {
 197     QtPropertyDeclarationAST *ast = new (pool) QtPropertyDeclarationAST;
 198     ast->property_specifier_token = property_specifier_token;
 199     ast->lparen_token = lparen_token;
 200     if (expression)
 201         ast->expression = expression->clone(pool);
 202     ast->comma_token = comma_token;
 203     if (type_id)
 204         ast->type_id = type_id->clone(pool);
 205     if (property_name)
 206         ast->property_name = property_name->clone(pool);
 207     for (QtPropertyDeclarationItemListAST *iter = property_declaration_item_list, **ast_iter = &ast->property_declaration_item_list;
 208          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 209         *ast_iter = new (pool) QtPropertyDeclarationItemListAST((iter->value) ? iter->value->clone(pool) : 0);
 210     ast->rparen_token = rparen_token;
 211     return ast;
 212 }
 213
 214 QtEnumDeclarationAST *QtEnumDeclarationAST::clone(MemoryPool *pool) const
 215 {
 216     QtEnumDeclarationAST *ast = new (pool) QtEnumDeclarationAST;
 217     ast->enum_specifier_token = enum_specifier_token;
 218     ast->lparen_token = lparen_token;
 219     for (NameListAST *iter = enumerator_list, **ast_iter = &ast->enumerator_list;
 220          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 221         *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : 0);
 222     ast->rparen_token = rparen_token;
 223     return ast;
 224 }
 225
 226 QtFlagsDeclarationAST *QtFlagsDeclarationAST::clone(MemoryPool *pool) const
 227 {
 228     QtFlagsDeclarationAST *ast = new (pool) QtFlagsDeclarationAST;
 229     ast->flags_specifier_token = flags_specifier_token;
 230     ast->lparen_token = lparen_token;
 231     for (NameListAST *iter = flag_enums_list, **ast_iter = &ast->flag_enums_list;
 232          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 233         *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : 0);
 234     ast->rparen_token = rparen_token;
 235     return ast;
 236 }
 237
 238 QtInterfaceNameAST *QtInterfaceNameAST::clone(MemoryPool *pool) const
 239 {
 240     QtInterfaceNameAST *ast = new (pool) QtInterfaceNameAST;
 241     if (interface_name)
 242         ast->interface_name = interface_name->clone(pool);
 243     for (NameListAST *iter = constraint_list, **ast_iter = &ast->constraint_list;
 244          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 245         *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : 0);
 246     return ast;
 247 }
 248
 249 QtInterfacesDeclarationAST *QtInterfacesDeclarationAST::clone(MemoryPool *pool) const
 250 {
 251     QtInterfacesDeclarationAST *ast = new (pool) QtInterfacesDeclarationAST;
 252     ast->interfaces_token = interfaces_token;
 253     ast->lparen_token = lparen_token;
 254     for (QtInterfaceNameListAST *iter = interface_name_list, **ast_iter = &ast->interface_name_list;
 255          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 256         *ast_iter = new (pool) QtInterfaceNameListAST((iter->value) ? iter->value->clone(pool) : 0);
 257     ast->rparen_token = rparen_token;
 258     return ast;
 259 }
 260
 261 AsmDefinitionAST *AsmDefinitionAST::clone(MemoryPool *pool) const
 262 {
 263     AsmDefinitionAST *ast = new (pool) AsmDefinitionAST;
 264     ast->asm_token = asm_token;
 265     ast->volatile_token = volatile_token;
 266     ast->lparen_token = lparen_token;
 267     ast->rparen_token = rparen_token;
 268     ast->semicolon_token = semicolon_token;
 269     return ast;
 270 }
 271
 272 BaseSpecifierAST *BaseSpecifierAST::clone(MemoryPool *pool) const
 273 {
 274     BaseSpecifierAST *ast = new (pool) BaseSpecifierAST;
 275     ast->virtual_token = virtual_token;
 276     ast->access_specifier_token = access_specifier_token;
 277     if (name)
 278         ast->name = name->clone(pool);
 279     return ast;
 280 }
 281
 282 IdExpressionAST *IdExpressionAST::clone(MemoryPool *pool) const
 283 {
 284     IdExpressionAST *ast = new (pool) IdExpressionAST;
 285     if (name)
 286         ast->name = name->clone(pool);
 287     return ast;
 288 }
 289
 290 CompoundExpressionAST *CompoundExpressionAST::clone(MemoryPool *pool) const
 291 {
 292     CompoundExpressionAST *ast = new (pool) CompoundExpressionAST;
 293     ast->lparen_token = lparen_token;
 294     if (statement)
 295         ast->statement = statement->clone(pool);
 296     ast->rparen_token = rparen_token;
 297     return ast;
 298 }
 299
 300 CompoundLiteralAST *CompoundLiteralAST::clone(MemoryPool *pool) const
 301 {
 302     CompoundLiteralAST *ast = new (pool) CompoundLiteralAST;
 303     ast->lparen_token = lparen_token;
 304     if (type_id)
 305         ast->type_id = type_id->clone(pool);
 306     ast->rparen_token = rparen_token;
 307     if (initializer)
 308         ast->initializer = initializer->clone(pool);
 309     return ast;
 310 }
 311
 312 QtMethodAST *QtMethodAST::clone(MemoryPool *pool) const
 313 {
 314     QtMethodAST *ast = new (pool) QtMethodAST;
 315     ast->method_token = method_token;
 316     ast->lparen_token = lparen_token;
 317     if (declarator)
 318         ast->declarator = declarator->clone(pool);
 319     ast->rparen_token = rparen_token;
 320     return ast;
 321 }
 322
 323 QtMemberDeclarationAST *QtMemberDeclarationAST::clone(MemoryPool *pool) const
 324 {
 325     QtMemberDeclarationAST *ast = new (pool) QtMemberDeclarationAST;
 326     ast->q_token = q_token;
 327     ast->lparen_token = lparen_token;
 328     if (type_id)
 329         ast->type_id = type_id->clone(pool);
 330     ast->rparen_token = rparen_token;
 331     return ast;
 332 }
 333
 334 BinaryExpressionAST *BinaryExpressionAST::clone(MemoryPool *pool) const
 335 {
 336     BinaryExpressionAST *ast = new (pool) BinaryExpressionAST;
 337     if (left_expression)
 338         ast->left_expression = left_expression->clone(pool);
 339     ast->binary_op_token = binary_op_token;
 340     if (right_expression)
 341         ast->right_expression = right_expression->clone(pool);
 342     return ast;
 343 }
 344
 345 CastExpressionAST *CastExpressionAST::clone(MemoryPool *pool) const
 346 {
 347     CastExpressionAST *ast = new (pool) CastExpressionAST;
 348     ast->lparen_token = lparen_token;
 349     if (type_id)
 350         ast->type_id = type_id->clone(pool);
 351     ast->rparen_token = rparen_token;
 352     if (expression)
 353         ast->expression = expression->clone(pool);
 354     return ast;
 355 }
 356
 357 ClassSpecifierAST *ClassSpecifierAST::clone(MemoryPool *pool) const
 358 {
 359     ClassSpecifierAST *ast = new (pool) ClassSpecifierAST;
 360     ast->classkey_token = classkey_token;
 361     for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
 362          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 363         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 364     if (name)
 365         ast->name = name->clone(pool);
 366     ast->colon_token = colon_token;
 367     for (BaseSpecifierListAST *iter = base_clause_list, **ast_iter = &ast->base_clause_list;
 368          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 369         *ast_iter = new (pool) BaseSpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 370     ast->dot_dot_dot_token = dot_dot_dot_token;
 371     ast->lbrace_token = lbrace_token;
 372     for (DeclarationListAST *iter = member_specifier_list, **ast_iter = &ast->member_specifier_list;
 373          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 374         *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
 375     ast->rbrace_token = rbrace_token;
 376     return ast;
 377 }
 378
 379 CaseStatementAST *CaseStatementAST::clone(MemoryPool *pool) const
 380 {
 381     CaseStatementAST *ast = new (pool) CaseStatementAST;
 382     ast->case_token = case_token;
 383     if (expression)
 384         ast->expression = expression->clone(pool);
 385     ast->colon_token = colon_token;
 386     if (statement)
 387         ast->statement = statement->clone(pool);
 388     return ast;
 389 }
 390
 391 CompoundStatementAST *CompoundStatementAST::clone(MemoryPool *pool) const
 392 {
 393     CompoundStatementAST *ast = new (pool) CompoundStatementAST;
 394     ast->lbrace_token = lbrace_token;
 395     for (StatementListAST *iter = statement_list, **ast_iter = &ast->statement_list;
 396          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 397         *ast_iter = new (pool) StatementListAST((iter->value) ? iter->value->clone(pool) : 0);
 398     ast->rbrace_token = rbrace_token;
 399     return ast;
 400 }
 401
 402 ConditionAST *ConditionAST::clone(MemoryPool *pool) const
 403 {
 404     ConditionAST *ast = new (pool) ConditionAST;
 405     for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
 406          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 407         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 408     if (declarator)
 409         ast->declarator = declarator->clone(pool);
 410     return ast;
 411 }
 412
 413 ConditionalExpressionAST *ConditionalExpressionAST::clone(MemoryPool *pool) const
 414 {
 415     ConditionalExpressionAST *ast = new (pool) ConditionalExpressionAST;
 416     if (condition)
 417         ast->condition = condition->clone(pool);
 418     ast->question_token = question_token;
 419     if (left_expression)
 420         ast->left_expression = left_expression->clone(pool);
 421     ast->colon_token = colon_token;
 422     if (right_expression)
 423         ast->right_expression = right_expression->clone(pool);
 424     return ast;
 425 }
 426
 427 CppCastExpressionAST *CppCastExpressionAST::clone(MemoryPool *pool) const
 428 {
 429     CppCastExpressionAST *ast = new (pool) CppCastExpressionAST;
 430     ast->cast_token = cast_token;
 431     ast->less_token = less_token;
 432     if (type_id)
 433         ast->type_id = type_id->clone(pool);
 434     ast->greater_token = greater_token;
 435     ast->lparen_token = lparen_token;
 436     if (expression)
 437         ast->expression = expression->clone(pool);
 438     ast->rparen_token = rparen_token;
 439     return ast;
 440 }
 441
 442 CtorInitializerAST *CtorInitializerAST::clone(MemoryPool *pool) const
 443 {
 444     CtorInitializerAST *ast = new (pool) CtorInitializerAST;
 445     ast->colon_token = colon_token;
 446     for (MemInitializerListAST *iter = member_initializer_list, **ast_iter = &ast->member_initializer_list;
 447          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 448         *ast_iter = new (pool) MemInitializerListAST((iter->value) ? iter->value->clone(pool) : 0);
 449     ast->dot_dot_dot_token = dot_dot_dot_token;
 450     return ast;
 451 }
 452
 453 DeclarationStatementAST *DeclarationStatementAST::clone(MemoryPool *pool) const
 454 {
 455     DeclarationStatementAST *ast = new (pool) DeclarationStatementAST;
 456     if (declaration)
 457         ast->declaration = declaration->clone(pool);
 458     return ast;
 459 }
 460
 461 DeclaratorIdAST *DeclaratorIdAST::clone(MemoryPool *pool) const
 462 {
 463     DeclaratorIdAST *ast = new (pool) DeclaratorIdAST;
 464     ast->dot_dot_dot_token = dot_dot_dot_token;
 465     if (name)
 466         ast->name = name->clone(pool);
 467     return ast;
 468 }
 469
 470 NestedDeclaratorAST *NestedDeclaratorAST::clone(MemoryPool *pool) const
 471 {
 472     NestedDeclaratorAST *ast = new (pool) NestedDeclaratorAST;
 473     ast->lparen_token = lparen_token;
 474     if (declarator)
 475         ast->declarator = declarator->clone(pool);
 476     ast->rparen_token = rparen_token;
 477     return ast;
 478 }
 479
 480 FunctionDeclaratorAST *FunctionDeclaratorAST::clone(MemoryPool *pool) const
 481 {
 482     FunctionDeclaratorAST *ast = new (pool) FunctionDeclaratorAST;
 483     ast->lparen_token = lparen_token;
 484     if (parameter_declaration_clause)
 485         ast->parameter_declaration_clause = parameter_declaration_clause->clone(pool);
 486     ast->rparen_token = rparen_token;
 487     for (SpecifierListAST *iter = cv_qualifier_list, **ast_iter = &ast->cv_qualifier_list;
 488          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 489         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 490     if (exception_specification)
 491         ast->exception_specification = exception_specification->clone(pool);
 492     if (trailing_return_type)
 493         ast->trailing_return_type = trailing_return_type->clone(pool);
 494     if (as_cpp_initializer)
 495         ast->as_cpp_initializer = as_cpp_initializer->clone(pool);
 496     return ast;
 497 }
 498
 499 ArrayDeclaratorAST *ArrayDeclaratorAST::clone(MemoryPool *pool) const
 500 {
 501     ArrayDeclaratorAST *ast = new (pool) ArrayDeclaratorAST;
 502     ast->lbracket_token = lbracket_token;
 503     if (expression)
 504         ast->expression = expression->clone(pool);
 505     ast->rbracket_token = rbracket_token;
 506     return ast;
 507 }
 508
 509 DeleteExpressionAST *DeleteExpressionAST::clone(MemoryPool *pool) const
 510 {
 511     DeleteExpressionAST *ast = new (pool) DeleteExpressionAST;
 512     ast->scope_token = scope_token;
 513     ast->delete_token = delete_token;
 514     ast->lbracket_token = lbracket_token;
 515     ast->rbracket_token = rbracket_token;
 516     if (expression)
 517         ast->expression = expression->clone(pool);
 518     return ast;
 519 }
 520
 521 DoStatementAST *DoStatementAST::clone(MemoryPool *pool) const
 522 {
 523     DoStatementAST *ast = new (pool) DoStatementAST;
 524     ast->do_token = do_token;
 525     if (statement)
 526         ast->statement = statement->clone(pool);
 527     ast->while_token = while_token;
 528     ast->lparen_token = lparen_token;
 529     if (expression)
 530         ast->expression = expression->clone(pool);
 531     ast->rparen_token = rparen_token;
 532     ast->semicolon_token = semicolon_token;
 533     return ast;
 534 }
 535
 536 NamedTypeSpecifierAST *NamedTypeSpecifierAST::clone(MemoryPool *pool) const
 537 {
 538     NamedTypeSpecifierAST *ast = new (pool) NamedTypeSpecifierAST;
 539     if (name)
 540         ast->name = name->clone(pool);
 541     return ast;
 542 }
 543
 544 ElaboratedTypeSpecifierAST *ElaboratedTypeSpecifierAST::clone(MemoryPool *pool) const
 545 {
 546     ElaboratedTypeSpecifierAST *ast = new (pool) ElaboratedTypeSpecifierAST;
 547     ast->classkey_token = classkey_token;
 548     for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
 549          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 550         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 551     if (name)
 552         ast->name = name->clone(pool);
 553     return ast;
 554 }
 555
 556 EnumSpecifierAST *EnumSpecifierAST::clone(MemoryPool *pool) const
 557 {
 558     EnumSpecifierAST *ast = new (pool) EnumSpecifierAST;
 559     ast->enum_token = enum_token;
 560     if (name)
 561         ast->name = name->clone(pool);
 562     ast->lbrace_token = lbrace_token;
 563     for (EnumeratorListAST *iter = enumerator_list, **ast_iter = &ast->enumerator_list;
 564          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 565         *ast_iter = new (pool) EnumeratorListAST((iter->value) ? iter->value->clone(pool) : 0);
 566     ast->stray_comma_token = stray_comma_token;
 567     ast->rbrace_token = rbrace_token;
 568     return ast;
 569 }
 570
 571 EnumeratorAST *EnumeratorAST::clone(MemoryPool *pool) const
 572 {
 573     EnumeratorAST *ast = new (pool) EnumeratorAST;
 574     ast->identifier_token = identifier_token;
 575     ast->equal_token = equal_token;
 576     if (expression)
 577         ast->expression = expression->clone(pool);
 578     return ast;
 579 }
 580
 581 ExceptionDeclarationAST *ExceptionDeclarationAST::clone(MemoryPool *pool) const
 582 {
 583     ExceptionDeclarationAST *ast = new (pool) ExceptionDeclarationAST;
 584     for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
 585          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 586         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 587     if (declarator)
 588         ast->declarator = declarator->clone(pool);
 589     ast->dot_dot_dot_token = dot_dot_dot_token;
 590     return ast;
 591 }
 592
 593 ExceptionSpecificationAST *ExceptionSpecificationAST::clone(MemoryPool *pool) const
 594 {
 595     ExceptionSpecificationAST *ast = new (pool) ExceptionSpecificationAST;
 596     ast->throw_token = throw_token;
 597     ast->lparen_token = lparen_token;
 598     ast->dot_dot_dot_token = dot_dot_dot_token;
 599     for (ExpressionListAST *iter = type_id_list, **ast_iter = &ast->type_id_list;
 600          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 601         *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);
 602     ast->rparen_token = rparen_token;
 603     return ast;
 604 }
 605
 606 ExpressionOrDeclarationStatementAST *ExpressionOrDeclarationStatementAST::clone(MemoryPool *pool) const
 607 {
 608     ExpressionOrDeclarationStatementAST *ast = new (pool) ExpressionOrDeclarationStatementAST;
 609     if (expression)
 610         ast->expression = expression->clone(pool);
 611     if (declaration)
 612         ast->declaration = declaration->clone(pool);
 613     return ast;
 614 }
 615
 616 ExpressionStatementAST *ExpressionStatementAST::clone(MemoryPool *pool) const
 617 {
 618     ExpressionStatementAST *ast = new (pool) ExpressionStatementAST;
 619     if (expression)
 620         ast->expression = expression->clone(pool);
 621     ast->semicolon_token = semicolon_token;
 622     return ast;
 623 }
 624
 625 FunctionDefinitionAST *FunctionDefinitionAST::clone(MemoryPool *pool) const
 626 {
 627     FunctionDefinitionAST *ast = new (pool) FunctionDefinitionAST;
 628     ast->qt_invokable_token = qt_invokable_token;
 629     for (SpecifierListAST *iter = decl_specifier_list, **ast_iter = &ast->decl_specifier_list;
 630          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 631         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 632     if (declarator)
 633         ast->declarator = declarator->clone(pool);
 634     if (ctor_initializer)
 635         ast->ctor_initializer = ctor_initializer->clone(pool);
 636     if (function_body)
 637         ast->function_body = function_body->clone(pool);
 638     return ast;
 639 }
 640
 641 ForeachStatementAST *ForeachStatementAST::clone(MemoryPool *pool) const
 642 {
 643     ForeachStatementAST *ast = new (pool) ForeachStatementAST;
 644     ast->foreach_token = foreach_token;
 645     ast->lparen_token = lparen_token;
 646     for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
 647          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 648         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 649     if (declarator)
 650         ast->declarator = declarator->clone(pool);
 651     if (initializer)
 652         ast->initializer = initializer->clone(pool);
 653     ast->comma_token = comma_token;
 654     if (expression)
 655         ast->expression = expression->clone(pool);
 656     ast->rparen_token = rparen_token;
 657     if (statement)
 658         ast->statement = statement->clone(pool);
 659     return ast;
 660 }
 661
 662 ForStatementAST *ForStatementAST::clone(MemoryPool *pool) const
 663 {
 664     ForStatementAST *ast = new (pool) ForStatementAST;
 665     ast->for_token = for_token;
 666     ast->lparen_token = lparen_token;
 667     if (initializer)
 668         ast->initializer = initializer->clone(pool);
 669     if (condition)
 670         ast->condition = condition->clone(pool);
 671     ast->semicolon_token = semicolon_token;
 672     if (expression)
 673         ast->expression = expression->clone(pool);
 674     ast->rparen_token = rparen_token;
 675     if (statement)
 676         ast->statement = statement->clone(pool);
 677     return ast;
 678 }
 679
 680 IfStatementAST *IfStatementAST::clone(MemoryPool *pool) const
 681 {
 682     IfStatementAST *ast = new (pool) IfStatementAST;
 683     ast->if_token = if_token;
 684     ast->lparen_token = lparen_token;
 685     if (condition)
 686         ast->condition = condition->clone(pool);
 687     ast->rparen_token = rparen_token;
 688     if (statement)
 689         ast->statement = statement->clone(pool);
 690     ast->else_token = else_token;
 691     if (else_statement)
 692         ast->else_statement = else_statement->clone(pool);
 693     return ast;
 694 }
 695
 696 ArrayInitializerAST *ArrayInitializerAST::clone(MemoryPool *pool) const
 697 {
 698     ArrayInitializerAST *ast = new (pool) ArrayInitializerAST;
 699     ast->lbrace_token = lbrace_token;
 700     for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
 701          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 702         *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);
 703     ast->rbrace_token = rbrace_token;
 704     return ast;
 705 }
 706
 707 LabeledStatementAST *LabeledStatementAST::clone(MemoryPool *pool) const
 708 {
 709     LabeledStatementAST *ast = new (pool) LabeledStatementAST;
 710     ast->label_token = label_token;
 711     ast->colon_token = colon_token;
 712     if (statement)
 713         ast->statement = statement->clone(pool);
 714     return ast;
 715 }
 716
 717 LinkageBodyAST *LinkageBodyAST::clone(MemoryPool *pool) const
 718 {
 719     LinkageBodyAST *ast = new (pool) LinkageBodyAST;
 720     ast->lbrace_token = lbrace_token;
 721     for (DeclarationListAST *iter = declaration_list, **ast_iter = &ast->declaration_list;
 722          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 723         *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
 724     ast->rbrace_token = rbrace_token;
 725     return ast;
 726 }
 727
 728 LinkageSpecificationAST *LinkageSpecificationAST::clone(MemoryPool *pool) const
 729 {
 730     LinkageSpecificationAST *ast = new (pool) LinkageSpecificationAST;
 731     ast->extern_token = extern_token;
 732     ast->extern_type_token = extern_type_token;
 733     if (declaration)
 734         ast->declaration = declaration->clone(pool);
 735     return ast;
 736 }
 737
 738 MemInitializerAST *MemInitializerAST::clone(MemoryPool *pool) const
 739 {
 740     MemInitializerAST *ast = new (pool) MemInitializerAST;
 741     if (name)
 742         ast->name = name->clone(pool);
 743     ast->lparen_token = lparen_token;
 744     for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
 745          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 746         *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);
 747     ast->rparen_token = rparen_token;
 748     return ast;
 749 }
 750
 751 NestedNameSpecifierAST *NestedNameSpecifierAST::clone(MemoryPool *pool) const
 752 {
 753     NestedNameSpecifierAST *ast = new (pool) NestedNameSpecifierAST;
 754     if (class_or_namespace_name)
 755         ast->class_or_namespace_name = class_or_namespace_name->clone(pool);
 756     ast->scope_token = scope_token;
 757     return ast;
 758 }
 759
 760 QualifiedNameAST *QualifiedNameAST::clone(MemoryPool *pool) const
 761 {
 762     QualifiedNameAST *ast = new (pool) QualifiedNameAST;
 763     ast->global_scope_token = global_scope_token;
 764     for (NestedNameSpecifierListAST *iter = nested_name_specifier_list, **ast_iter = &ast->nested_name_specifier_list;
 765          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 766         *ast_iter = new (pool) NestedNameSpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 767     if (unqualified_name)
 768         ast->unqualified_name = unqualified_name->clone(pool);
 769     return ast;
 770 }
 771
 772 OperatorFunctionIdAST *OperatorFunctionIdAST::clone(MemoryPool *pool) const
 773 {
 774     OperatorFunctionIdAST *ast = new (pool) OperatorFunctionIdAST;
 775     ast->operator_token = operator_token;
 776     if (op)
 777         ast->op = op->clone(pool);
 778     return ast;
 779 }
 780
 781 ConversionFunctionIdAST *ConversionFunctionIdAST::clone(MemoryPool *pool) const
 782 {
 783     ConversionFunctionIdAST *ast = new (pool) ConversionFunctionIdAST;
 784     ast->operator_token = operator_token;
 785     for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
 786          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 787         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 788     for (PtrOperatorListAST *iter = ptr_operator_list, **ast_iter = &ast->ptr_operator_list;
 789          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 790         *ast_iter = new (pool) PtrOperatorListAST((iter->value) ? iter->value->clone(pool) : 0);
 791     return ast;
 792 }
 793
 794 SimpleNameAST *SimpleNameAST::clone(MemoryPool *pool) const
 795 {
 796     SimpleNameAST *ast = new (pool) SimpleNameAST;
 797     ast->identifier_token = identifier_token;
 798     return ast;
 799 }
 800
 801 DestructorNameAST *DestructorNameAST::clone(MemoryPool *pool) const
 802 {
 803     DestructorNameAST *ast = new (pool) DestructorNameAST;
 804     ast->tilde_token = tilde_token;
 805     ast->identifier_token = identifier_token;
 806     return ast;
 807 }
 808
 809 TemplateIdAST *TemplateIdAST::clone(MemoryPool *pool) const
 810 {
 811     TemplateIdAST *ast = new (pool) TemplateIdAST;
 812     ast->template_token = template_token;
 813     ast->identifier_token = identifier_token;
 814     ast->less_token = less_token;
 815     for (ExpressionListAST *iter = template_argument_list, **ast_iter = &ast->template_argument_list;
 816          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 817         *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);
 818     ast->greater_token = greater_token;
 819     return ast;
 820 }
 821
 822 NamespaceAST *NamespaceAST::clone(MemoryPool *pool) const
 823 {
 824     NamespaceAST *ast = new (pool) NamespaceAST;
 825     ast->namespace_token = namespace_token;
 826     ast->identifier_token = identifier_token;
 827     for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
 828          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 829         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 830     if (linkage_body)
 831         ast->linkage_body = linkage_body->clone(pool);
 832     return ast;
 833 }
 834
 835 NamespaceAliasDefinitionAST *NamespaceAliasDefinitionAST::clone(MemoryPool *pool) const
 836 {
 837     NamespaceAliasDefinitionAST *ast = new (pool) NamespaceAliasDefinitionAST;
 838     ast->namespace_token = namespace_token;
 839     ast->namespace_name_token = namespace_name_token;
 840     ast->equal_token = equal_token;
 841     if (name)
 842         ast->name = name->clone(pool);
 843     ast->semicolon_token = semicolon_token;
 844     return ast;
 845 }
 846
 847 NewPlacementAST *NewPlacementAST::clone(MemoryPool *pool) const
 848 {
 849     NewPlacementAST *ast = new (pool) NewPlacementAST;
 850     ast->lparen_token = lparen_token;
 851     for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
 852          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 853         *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);
 854     ast->rparen_token = rparen_token;
 855     return ast;
 856 }
 857
 858 NewArrayDeclaratorAST *NewArrayDeclaratorAST::clone(MemoryPool *pool) const
 859 {
 860     NewArrayDeclaratorAST *ast = new (pool) NewArrayDeclaratorAST;
 861     ast->lbracket_token = lbracket_token;
 862     if (expression)
 863         ast->expression = expression->clone(pool);
 864     ast->rbracket_token = rbracket_token;
 865     return ast;
 866 }
 867
 868 NewExpressionAST *NewExpressionAST::clone(MemoryPool *pool) const
 869 {
 870     NewExpressionAST *ast = new (pool) NewExpressionAST;
 871     ast->scope_token = scope_token;
 872     ast->new_token = new_token;
 873     if (new_placement)
 874         ast->new_placement = new_placement->clone(pool);
 875     ast->lparen_token = lparen_token;
 876     if (type_id)
 877         ast->type_id = type_id->clone(pool);
 878     ast->rparen_token = rparen_token;
 879     if (new_type_id)
 880         ast->new_type_id = new_type_id->clone(pool);
 881     if (new_initializer)
 882         ast->new_initializer = new_initializer->clone(pool);
 883     return ast;
 884 }
 885
 886 NewInitializerAST *NewInitializerAST::clone(MemoryPool *pool) const
 887 {
 888     NewInitializerAST *ast = new (pool) NewInitializerAST;
 889     ast->lparen_token = lparen_token;
 890     if (expression)
 891         ast->expression = expression->clone(pool);
 892     ast->rparen_token = rparen_token;
 893     return ast;
 894 }
 895
 896 NewTypeIdAST *NewTypeIdAST::clone(MemoryPool *pool) const
 897 {
 898     NewTypeIdAST *ast = new (pool) NewTypeIdAST;
 899     for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
 900          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 901         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 902     for (PtrOperatorListAST *iter = ptr_operator_list, **ast_iter = &ast->ptr_operator_list;
 903          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 904         *ast_iter = new (pool) PtrOperatorListAST((iter->value) ? iter->value->clone(pool) : 0);
 905     for (NewArrayDeclaratorListAST *iter = new_array_declarator_list, **ast_iter = &ast->new_array_declarator_list;
 906          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 907         *ast_iter = new (pool) NewArrayDeclaratorListAST((iter->value) ? iter->value->clone(pool) : 0);
 908     return ast;
 909 }
 910
 911 OperatorAST *OperatorAST::clone(MemoryPool *pool) const
 912 {
 913     OperatorAST *ast = new (pool) OperatorAST;
 914     ast->op_token = op_token;
 915     ast->open_token = open_token;
 916     ast->close_token = close_token;
 917     return ast;
 918 }
 919
 920 ParameterDeclarationAST *ParameterDeclarationAST::clone(MemoryPool *pool) const
 921 {
 922     ParameterDeclarationAST *ast = new (pool) ParameterDeclarationAST;
 923     for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
 924          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 925         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
 926     if (declarator)
 927         ast->declarator = declarator->clone(pool);
 928     ast->equal_token = equal_token;
 929     if (expression)
 930         ast->expression = expression->clone(pool);
 931     return ast;
 932 }
 933
 934 ParameterDeclarationClauseAST *ParameterDeclarationClauseAST::clone(MemoryPool *pool) const
 935 {
 936     ParameterDeclarationClauseAST *ast = new (pool) ParameterDeclarationClauseAST;
 937     for (ParameterDeclarationListAST *iter = parameter_declaration_list, **ast_iter = &ast->parameter_declaration_list;
 938          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 939         *ast_iter = new (pool) ParameterDeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
 940     ast->dot_dot_dot_token = dot_dot_dot_token;
 941     return ast;
 942 }
 943
 944 CallAST *CallAST::clone(MemoryPool *pool) const
 945 {
 946     CallAST *ast = new (pool) CallAST;
 947     if (base_expression)
 948         ast->base_expression = base_expression->clone(pool);
 949     ast->lparen_token = lparen_token;
 950     for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
 951          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
 952         *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);
 953     ast->rparen_token = rparen_token;
 954     return ast;
 955 }
 956
 957 ArrayAccessAST *ArrayAccessAST::clone(MemoryPool *pool) const
 958 {
 959     ArrayAccessAST *ast = new (pool) ArrayAccessAST;
 960     if (base_expression)
 961         ast->base_expression = base_expression->clone(pool);
 962     ast->lbracket_token = lbracket_token;
 963     if (expression)
 964         ast->expression = expression->clone(pool);
 965     ast->rbracket_token = rbracket_token;
 966     return ast;
 967 }
 968
 969 PostIncrDecrAST *PostIncrDecrAST::clone(MemoryPool *pool) const
 970 {
 971     PostIncrDecrAST *ast = new (pool) PostIncrDecrAST;
 972     if (base_expression)
 973         ast->base_expression = base_expression->clone(pool);
 974     ast->incr_decr_token = incr_decr_token;
 975     return ast;
 976 }
 977
 978 MemberAccessAST *MemberAccessAST::clone(MemoryPool *pool) const
 979 {
 980     MemberAccessAST *ast = new (pool) MemberAccessAST;
 981     if (base_expression)
 982         ast->base_expression = base_expression->clone(pool);
 983     ast->access_token = access_token;
 984     ast->template_token = template_token;
 985     if (member_name)
 986         ast->member_name = member_name->clone(pool);
 987     return ast;
 988 }
 989
 990 TypeidExpressionAST *TypeidExpressionAST::clone(MemoryPool *pool) const
 991 {
 992     TypeidExpressionAST *ast = new (pool) TypeidExpressionAST;
 993     ast->typeid_token = typeid_token;
 994     ast->lparen_token = lparen_token;
 995     if (expression)
 996         ast->expression = expression->clone(pool);
 997     ast->rparen_token = rparen_token;
 998     return ast;
 999 }
1000
1001 TypenameCallExpressionAST *TypenameCallExpressionAST::clone(MemoryPool *pool) const
1002 {
1003     TypenameCallExpressionAST *ast = new (pool) TypenameCallExpressionAST;
1004     ast->typename_token = typename_token;
1005     if (name)
1006         ast->name = name->clone(pool);
1007     ast->lparen_token = lparen_token;
1008     for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
1009          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1010         *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);
1011     ast->rparen_token = rparen_token;
1012     return ast;
1013 }
1014
1015 TypeConstructorCallAST *TypeConstructorCallAST::clone(MemoryPool *pool) const
1016 {
1017     TypeConstructorCallAST *ast = new (pool) TypeConstructorCallAST;
1018     for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
1019          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1020         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1021     ast->lparen_token = lparen_token;
1022     for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
1023          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1024         *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);
1025     ast->rparen_token = rparen_token;
1026     return ast;
1027 }
1028
1029 PointerToMemberAST *PointerToMemberAST::clone(MemoryPool *pool) const
1030 {
1031     PointerToMemberAST *ast = new (pool) PointerToMemberAST;
1032     ast->global_scope_token = global_scope_token;
1033     for (NestedNameSpecifierListAST *iter = nested_name_specifier_list, **ast_iter = &ast->nested_name_specifier_list;
1034          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1035         *ast_iter = new (pool) NestedNameSpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1036     ast->star_token = star_token;
1037     for (SpecifierListAST *iter = cv_qualifier_list, **ast_iter = &ast->cv_qualifier_list;
1038          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1039         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1040     return ast;
1041 }
1042
1043 PointerAST *PointerAST::clone(MemoryPool *pool) const
1044 {
1045     PointerAST *ast = new (pool) PointerAST;
1046     ast->star_token = star_token;
1047     for (SpecifierListAST *iter = cv_qualifier_list, **ast_iter = &ast->cv_qualifier_list;
1048          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1049         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1050     return ast;
1051 }
1052
1053 ReferenceAST *ReferenceAST::clone(MemoryPool *pool) const
1054 {
1055     ReferenceAST *ast = new (pool) ReferenceAST;
1056     ast->reference_token = reference_token;
1057     return ast;
1058 }
1059
1060 BreakStatementAST *BreakStatementAST::clone(MemoryPool *pool) const
1061 {
1062     BreakStatementAST *ast = new (pool) BreakStatementAST;
1063     ast->break_token = break_token;
1064     ast->semicolon_token = semicolon_token;
1065     return ast;
1066 }
1067
1068 ContinueStatementAST *ContinueStatementAST::clone(MemoryPool *pool) const
1069 {
1070     ContinueStatementAST *ast = new (pool) ContinueStatementAST;
1071     ast->continue_token = continue_token;
1072     ast->semicolon_token = semicolon_token;
1073     return ast;
1074 }
1075
1076 GotoStatementAST *GotoStatementAST::clone(MemoryPool *pool) const
1077 {
1078     GotoStatementAST *ast = new (pool) GotoStatementAST;
1079     ast->goto_token = goto_token;
1080     ast->identifier_token = identifier_token;
1081     ast->semicolon_token = semicolon_token;
1082     return ast;
1083 }
1084
1085 ReturnStatementAST *ReturnStatementAST::clone(MemoryPool *pool) const
1086 {
1087     ReturnStatementAST *ast = new (pool) ReturnStatementAST;
1088     ast->return_token = return_token;
1089     if (expression)
1090         ast->expression = expression->clone(pool);
1091     ast->semicolon_token = semicolon_token;
1092     return ast;
1093 }
1094
1095 SizeofExpressionAST *SizeofExpressionAST::clone(MemoryPool *pool) const
1096 {
1097     SizeofExpressionAST *ast = new (pool) SizeofExpressionAST;
1098     ast->sizeof_token = sizeof_token;
1099     ast->dot_dot_dot_token = dot_dot_dot_token;
1100     ast->lparen_token = lparen_token;
1101     if (expression)
1102         ast->expression = expression->clone(pool);
1103     ast->rparen_token = rparen_token;
1104     return ast;
1105 }
1106
1107 NumericLiteralAST *NumericLiteralAST::clone(MemoryPool *pool) const
1108 {
1109     NumericLiteralAST *ast = new (pool) NumericLiteralAST;
1110     ast->literal_token = literal_token;
1111     return ast;
1112 }
1113
1114 BoolLiteralAST *BoolLiteralAST::clone(MemoryPool *pool) const
1115 {
1116     BoolLiteralAST *ast = new (pool) BoolLiteralAST;
1117     ast->literal_token = literal_token;
1118     return ast;
1119 }
1120
1121 ThisExpressionAST *ThisExpressionAST::clone(MemoryPool *pool) const
1122 {
1123     ThisExpressionAST *ast = new (pool) ThisExpressionAST;
1124     ast->this_token = this_token;
1125     return ast;
1126 }
1127
1128 NestedExpressionAST *NestedExpressionAST::clone(MemoryPool *pool) const
1129 {
1130     NestedExpressionAST *ast = new (pool) NestedExpressionAST;
1131     ast->lparen_token = lparen_token;
1132     if (expression)
1133         ast->expression = expression->clone(pool);
1134     ast->rparen_token = rparen_token;
1135     return ast;
1136 }
1137
1138 StringLiteralAST *StringLiteralAST::clone(MemoryPool *pool) const
1139 {
1140     StringLiteralAST *ast = new (pool) StringLiteralAST;
1141     ast->literal_token = literal_token;
1142     if (next)
1143         ast->next = next->clone(pool);
1144     return ast;
1145 }
1146
1147 SwitchStatementAST *SwitchStatementAST::clone(MemoryPool *pool) const
1148 {
1149     SwitchStatementAST *ast = new (pool) SwitchStatementAST;
1150     ast->switch_token = switch_token;
1151     ast->lparen_token = lparen_token;
1152     if (condition)
1153         ast->condition = condition->clone(pool);
1154     ast->rparen_token = rparen_token;
1155     if (statement)
1156         ast->statement = statement->clone(pool);
1157     return ast;
1158 }
1159
1160 TemplateDeclarationAST *TemplateDeclarationAST::clone(MemoryPool *pool) const
1161 {
1162     TemplateDeclarationAST *ast = new (pool) TemplateDeclarationAST;
1163     ast->export_token = export_token;
1164     ast->template_token = template_token;
1165     ast->less_token = less_token;
1166     for (DeclarationListAST *iter = template_parameter_list, **ast_iter = &ast->template_parameter_list;
1167          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1168         *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
1169     ast->greater_token = greater_token;
1170     if (declaration)
1171         ast->declaration = declaration->clone(pool);
1172     return ast;
1173 }
1174
1175 ThrowExpressionAST *ThrowExpressionAST::clone(MemoryPool *pool) const
1176 {
1177     ThrowExpressionAST *ast = new (pool) ThrowExpressionAST;
1178     ast->throw_token = throw_token;
1179     if (expression)
1180         ast->expression = expression->clone(pool);
1181     return ast;
1182 }
1183
1184 TranslationUnitAST *TranslationUnitAST::clone(MemoryPool *pool) const
1185 {
1186     TranslationUnitAST *ast = new (pool) TranslationUnitAST;
1187     for (DeclarationListAST *iter = declaration_list, **ast_iter = &ast->declaration_list;
1188          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1189         *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
1190     return ast;
1191 }
1192
1193 TryBlockStatementAST *TryBlockStatementAST::clone(MemoryPool *pool) const
1194 {
1195     TryBlockStatementAST *ast = new (pool) TryBlockStatementAST;
1196     ast->try_token = try_token;
1197     if (statement)
1198         ast->statement = statement->clone(pool);
1199     for (CatchClauseListAST *iter = catch_clause_list, **ast_iter = &ast->catch_clause_list;
1200          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1201         *ast_iter = new (pool) CatchClauseListAST((iter->value) ? iter->value->clone(pool) : 0);
1202     return ast;
1203 }
1204
1205 CatchClauseAST *CatchClauseAST::clone(MemoryPool *pool) const
1206 {
1207     CatchClauseAST *ast = new (pool) CatchClauseAST;
1208     ast->catch_token = catch_token;
1209     ast->lparen_token = lparen_token;
1210     if (exception_declaration)
1211         ast->exception_declaration = exception_declaration->clone(pool);
1212     ast->rparen_token = rparen_token;
1213     if (statement)
1214         ast->statement = statement->clone(pool);
1215     return ast;
1216 }
1217
1218 TypeIdAST *TypeIdAST::clone(MemoryPool *pool) const
1219 {
1220     TypeIdAST *ast = new (pool) TypeIdAST;
1221     for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
1222          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1223         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1224     if (declarator)
1225         ast->declarator = declarator->clone(pool);
1226     return ast;
1227 }
1228
1229 TypenameTypeParameterAST *TypenameTypeParameterAST::clone(MemoryPool *pool) const
1230 {
1231     TypenameTypeParameterAST *ast = new (pool) TypenameTypeParameterAST;
1232     ast->classkey_token = classkey_token;
1233     ast->dot_dot_dot_token = dot_dot_dot_token;
1234     if (name)
1235         ast->name = name->clone(pool);
1236     ast->equal_token = equal_token;
1237     if (type_id)
1238         ast->type_id = type_id->clone(pool);
1239     return ast;
1240 }
1241
1242 TemplateTypeParameterAST *TemplateTypeParameterAST::clone(MemoryPool *pool) const
1243 {
1244     TemplateTypeParameterAST *ast = new (pool) TemplateTypeParameterAST;
1245     ast->template_token = template_token;
1246     ast->less_token = less_token;
1247     for (DeclarationListAST *iter = template_parameter_list, **ast_iter = &ast->template_parameter_list;
1248          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1249         *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
1250     ast->greater_token = greater_token;
1251     ast->class_token = class_token;
1252     ast->dot_dot_dot_token = dot_dot_dot_token;
1253     if (name)
1254         ast->name = name->clone(pool);
1255     ast->equal_token = equal_token;
1256     if (type_id)
1257         ast->type_id = type_id->clone(pool);
1258     return ast;
1259 }
1260
1261 UnaryExpressionAST *UnaryExpressionAST::clone(MemoryPool *pool) const
1262 {
1263     UnaryExpressionAST *ast = new (pool) UnaryExpressionAST;
1264     ast->unary_op_token = unary_op_token;
1265     if (expression)
1266         ast->expression = expression->clone(pool);
1267     return ast;
1268 }
1269
1270 UsingAST *UsingAST::clone(MemoryPool *pool) const
1271 {
1272     UsingAST *ast = new (pool) UsingAST;
1273     ast->using_token = using_token;
1274     ast->typename_token = typename_token;
1275     if (name)
1276         ast->name = name->clone(pool);
1277     ast->semicolon_token = semicolon_token;
1278     return ast;
1279 }
1280
1281 UsingDirectiveAST *UsingDirectiveAST::clone(MemoryPool *pool) const
1282 {
1283     UsingDirectiveAST *ast = new (pool) UsingDirectiveAST;
1284     ast->using_token = using_token;
1285     ast->namespace_token = namespace_token;
1286     if (name)
1287         ast->name = name->clone(pool);
1288     ast->semicolon_token = semicolon_token;
1289     return ast;
1290 }
1291
1292 WhileStatementAST *WhileStatementAST::clone(MemoryPool *pool) const
1293 {
1294     WhileStatementAST *ast = new (pool) WhileStatementAST;
1295     ast->while_token = while_token;
1296     ast->lparen_token = lparen_token;
1297     if (condition)
1298         ast->condition = condition->clone(pool);
1299     ast->rparen_token = rparen_token;
1300     if (statement)
1301         ast->statement = statement->clone(pool);
1302     return ast;
1303 }
1304
1305 ObjCClassForwardDeclarationAST *ObjCClassForwardDeclarationAST::clone(MemoryPool *pool) const
1306 {
1307     ObjCClassForwardDeclarationAST *ast = new (pool) ObjCClassForwardDeclarationAST;
1308     for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1309          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1310         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1311     ast->class_token = class_token;
1312     for (NameListAST *iter = identifier_list, **ast_iter = &ast->identifier_list;
1313          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1314         *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : 0);
1315     ast->semicolon_token = semicolon_token;
1316     return ast;
1317 }
1318
1319 ObjCClassDeclarationAST *ObjCClassDeclarationAST::clone(MemoryPool *pool) const
1320 {
1321     ObjCClassDeclarationAST *ast = new (pool) ObjCClassDeclarationAST;
1322     for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1323          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1324         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1325     ast->interface_token = interface_token;
1326     ast->implementation_token = implementation_token;
1327     if (class_name)
1328         ast->class_name = class_name->clone(pool);
1329     ast->lparen_token = lparen_token;
1330     if (category_name)
1331         ast->category_name = category_name->clone(pool);
1332     ast->rparen_token = rparen_token;
1333     ast->colon_token = colon_token;
1334     if (superclass)
1335         ast->superclass = superclass->clone(pool);
1336     if (protocol_refs)
1337         ast->protocol_refs = protocol_refs->clone(pool);
1338     if (inst_vars_decl)
1339         ast->inst_vars_decl = inst_vars_decl->clone(pool);
1340     for (DeclarationListAST *iter = member_declaration_list, **ast_iter = &ast->member_declaration_list;
1341          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1342         *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
1343     ast->end_token = end_token;
1344     return ast;
1345 }
1346
1347 ObjCProtocolForwardDeclarationAST *ObjCProtocolForwardDeclarationAST::clone(MemoryPool *pool) const
1348 {
1349     ObjCProtocolForwardDeclarationAST *ast = new (pool) ObjCProtocolForwardDeclarationAST;
1350     for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1351          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1352         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1353     ast->protocol_token = protocol_token;
1354     for (NameListAST *iter = identifier_list, **ast_iter = &ast->identifier_list;
1355          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1356         *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : 0);
1357     ast->semicolon_token = semicolon_token;
1358     return ast;
1359 }
1360
1361 ObjCProtocolDeclarationAST *ObjCProtocolDeclarationAST::clone(MemoryPool *pool) const
1362 {
1363     ObjCProtocolDeclarationAST *ast = new (pool) ObjCProtocolDeclarationAST;
1364     for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1365          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1366         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1367     ast->protocol_token = protocol_token;
1368     if (name)
1369         ast->name = name->clone(pool);
1370     if (protocol_refs)
1371         ast->protocol_refs = protocol_refs->clone(pool);
1372     for (DeclarationListAST *iter = member_declaration_list, **ast_iter = &ast->member_declaration_list;
1373          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1374         *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
1375     ast->end_token = end_token;
1376     return ast;
1377 }
1378
1379 ObjCProtocolRefsAST *ObjCProtocolRefsAST::clone(MemoryPool *pool) const
1380 {
1381     ObjCProtocolRefsAST *ast = new (pool) ObjCProtocolRefsAST;
1382     ast->less_token = less_token;
1383     for (NameListAST *iter = identifier_list, **ast_iter = &ast->identifier_list;
1384          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1385         *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : 0);
1386     ast->greater_token = greater_token;
1387     return ast;
1388 }
1389
1390 ObjCMessageArgumentAST *ObjCMessageArgumentAST::clone(MemoryPool *pool) const
1391 {
1392     ObjCMessageArgumentAST *ast = new (pool) ObjCMessageArgumentAST;
1393     if (parameter_value_expression)
1394         ast->parameter_value_expression = parameter_value_expression->clone(pool);
1395     return ast;
1396 }
1397
1398 ObjCMessageExpressionAST *ObjCMessageExpressionAST::clone(MemoryPool *pool) const
1399 {
1400     ObjCMessageExpressionAST *ast = new (pool) ObjCMessageExpressionAST;
1401     ast->lbracket_token = lbracket_token;
1402     if (receiver_expression)
1403         ast->receiver_expression = receiver_expression->clone(pool);
1404     if (selector)
1405         ast->selector = selector->clone(pool);
1406     for (ObjCMessageArgumentListAST *iter = argument_list, **ast_iter = &ast->argument_list;
1407          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1408         *ast_iter = new (pool) ObjCMessageArgumentListAST((iter->value) ? iter->value->clone(pool) : 0);
1409     ast->rbracket_token = rbracket_token;
1410     return ast;
1411 }
1412
1413 ObjCProtocolExpressionAST *ObjCProtocolExpressionAST::clone(MemoryPool *pool) const
1414 {
1415     ObjCProtocolExpressionAST *ast = new (pool) ObjCProtocolExpressionAST;
1416     ast->protocol_token = protocol_token;
1417     ast->lparen_token = lparen_token;
1418     ast->identifier_token = identifier_token;
1419     ast->rparen_token = rparen_token;
1420     return ast;
1421 }
1422
1423 ObjCTypeNameAST *ObjCTypeNameAST::clone(MemoryPool *pool) const
1424 {
1425     ObjCTypeNameAST *ast = new (pool) ObjCTypeNameAST;
1426     ast->lparen_token = lparen_token;
1427     ast->type_qualifier_token = type_qualifier_token;
1428     if (type_id)
1429         ast->type_id = type_id->clone(pool);
1430     ast->rparen_token = rparen_token;
1431     return ast;
1432 }
1433
1434 ObjCEncodeExpressionAST *ObjCEncodeExpressionAST::clone(MemoryPool *pool) const
1435 {
1436     ObjCEncodeExpressionAST *ast = new (pool) ObjCEncodeExpressionAST;
1437     ast->encode_token = encode_token;
1438     if (type_name)
1439         ast->type_name = type_name->clone(pool);
1440     return ast;
1441 }
1442
1443 ObjCSelectorExpressionAST *ObjCSelectorExpressionAST::clone(MemoryPool *pool) const
1444 {
1445     ObjCSelectorExpressionAST *ast = new (pool) ObjCSelectorExpressionAST;
1446     ast->selector_token = selector_token;
1447     ast->lparen_token = lparen_token;
1448     if (selector)
1449         ast->selector = selector->clone(pool);
1450     ast->rparen_token = rparen_token;
1451     return ast;
1452 }
1453
1454 ObjCInstanceVariablesDeclarationAST *ObjCInstanceVariablesDeclarationAST::clone(MemoryPool *pool) const
1455 {
1456     ObjCInstanceVariablesDeclarationAST *ast = new (pool) ObjCInstanceVariablesDeclarationAST;
1457     ast->lbrace_token = lbrace_token;
1458     for (DeclarationListAST *iter = instance_variable_list, **ast_iter = &ast->instance_variable_list;
1459          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1460         *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
1461     ast->rbrace_token = rbrace_token;
1462     return ast;
1463 }
1464
1465 ObjCVisibilityDeclarationAST *ObjCVisibilityDeclarationAST::clone(MemoryPool *pool) const
1466 {
1467     ObjCVisibilityDeclarationAST *ast = new (pool) ObjCVisibilityDeclarationAST;
1468     ast->visibility_token = visibility_token;
1469     return ast;
1470 }
1471
1472 ObjCPropertyAttributeAST *ObjCPropertyAttributeAST::clone(MemoryPool *pool) const
1473 {
1474     ObjCPropertyAttributeAST *ast = new (pool) ObjCPropertyAttributeAST;
1475     ast->attribute_identifier_token = attribute_identifier_token;
1476     ast->equals_token = equals_token;
1477     if (method_selector)
1478         ast->method_selector = method_selector->clone(pool);
1479     return ast;
1480 }
1481
1482 ObjCPropertyDeclarationAST *ObjCPropertyDeclarationAST::clone(MemoryPool *pool) const
1483 {
1484     ObjCPropertyDeclarationAST *ast = new (pool) ObjCPropertyDeclarationAST;
1485     for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1486          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1487         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1488     ast->property_token = property_token;
1489     ast->lparen_token = lparen_token;
1490     for (ObjCPropertyAttributeListAST *iter = property_attribute_list, **ast_iter = &ast->property_attribute_list;
1491          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1492         *ast_iter = new (pool) ObjCPropertyAttributeListAST((iter->value) ? iter->value->clone(pool) : 0);
1493     ast->rparen_token = rparen_token;
1494     if (simple_declaration)
1495         ast->simple_declaration = simple_declaration->clone(pool);
1496     return ast;
1497 }
1498
1499 ObjCMessageArgumentDeclarationAST *ObjCMessageArgumentDeclarationAST::clone(MemoryPool *pool) const
1500 {
1501     ObjCMessageArgumentDeclarationAST *ast = new (pool) ObjCMessageArgumentDeclarationAST;
1502     if (type_name)
1503         ast->type_name = type_name->clone(pool);
1504     for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1505          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1506         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1507     if (param_name)
1508         ast->param_name = param_name->clone(pool);
1509     return ast;
1510 }
1511
1512 ObjCMethodPrototypeAST *ObjCMethodPrototypeAST::clone(MemoryPool *pool) const
1513 {
1514     ObjCMethodPrototypeAST *ast = new (pool) ObjCMethodPrototypeAST;
1515     ast->method_type_token = method_type_token;
1516     if (type_name)
1517         ast->type_name = type_name->clone(pool);
1518     if (selector)
1519         ast->selector = selector->clone(pool);
1520     for (ObjCMessageArgumentDeclarationListAST *iter = argument_list, **ast_iter = &ast->argument_list;
1521          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1522         *ast_iter = new (pool) ObjCMessageArgumentDeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
1523     ast->dot_dot_dot_token = dot_dot_dot_token;
1524     for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1525          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1526         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1527     return ast;
1528 }
1529
1530 ObjCMethodDeclarationAST *ObjCMethodDeclarationAST::clone(MemoryPool *pool) const
1531 {
1532     ObjCMethodDeclarationAST *ast = new (pool) ObjCMethodDeclarationAST;
1533     if (method_prototype)
1534         ast->method_prototype = method_prototype->clone(pool);
1535     if (function_body)
1536         ast->function_body = function_body->clone(pool);
1537     ast->semicolon_token = semicolon_token;
1538     return ast;
1539 }
1540
1541 ObjCSynthesizedPropertyAST *ObjCSynthesizedPropertyAST::clone(MemoryPool *pool) const
1542 {
1543     ObjCSynthesizedPropertyAST *ast = new (pool) ObjCSynthesizedPropertyAST;
1544     ast->property_identifier_token = property_identifier_token;
1545     ast->equals_token = equals_token;
1546     ast->alias_identifier_token = alias_identifier_token;
1547     return ast;
1548 }
1549
1550 ObjCSynthesizedPropertiesDeclarationAST *ObjCSynthesizedPropertiesDeclarationAST::clone(MemoryPool *pool) const
1551 {
1552     ObjCSynthesizedPropertiesDeclarationAST *ast = new (pool) ObjCSynthesizedPropertiesDeclarationAST;
1553     ast->synthesized_token = synthesized_token;
1554     for (ObjCSynthesizedPropertyListAST *iter = property_identifier_list, **ast_iter = &ast->property_identifier_list;
1555          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1556         *ast_iter = new (pool) ObjCSynthesizedPropertyListAST((iter->value) ? iter->value->clone(pool) : 0);
1557     ast->semicolon_token = semicolon_token;
1558     return ast;
1559 }
1560
1561 ObjCDynamicPropertiesDeclarationAST *ObjCDynamicPropertiesDeclarationAST::clone(MemoryPool *pool) const
1562 {
1563     ObjCDynamicPropertiesDeclarationAST *ast = new (pool) ObjCDynamicPropertiesDeclarationAST;
1564     ast->dynamic_token = dynamic_token;
1565     for (NameListAST *iter = property_identifier_list, **ast_iter = &ast->property_identifier_list;
1566          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1567         *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : 0);
1568     ast->semicolon_token = semicolon_token;
1569     return ast;
1570 }
1571
1572 ObjCFastEnumerationAST *ObjCFastEnumerationAST::clone(MemoryPool *pool) const
1573 {
1574     ObjCFastEnumerationAST *ast = new (pool) ObjCFastEnumerationAST;
1575     ast->for_token = for_token;
1576     ast->lparen_token = lparen_token;
1577     for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
1578          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1579         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1580     if (declarator)
1581         ast->declarator = declarator->clone(pool);
1582     if (initializer)
1583         ast->initializer = initializer->clone(pool);
1584     ast->in_token = in_token;
1585     if (fast_enumeratable_expression)
1586         ast->fast_enumeratable_expression = fast_enumeratable_expression->clone(pool);
1587     ast->rparen_token = rparen_token;
1588     if (statement)
1589         ast->statement = statement->clone(pool);
1590     return ast;
1591 }
1592
1593 ObjCSynchronizedStatementAST *ObjCSynchronizedStatementAST::clone(MemoryPool *pool) const
1594 {
1595     ObjCSynchronizedStatementAST *ast = new (pool) ObjCSynchronizedStatementAST;
1596     ast->synchronized_token = synchronized_token;
1597     ast->lparen_token = lparen_token;
1598     if (synchronized_object)
1599         ast->synchronized_object = synchronized_object->clone(pool);
1600     ast->rparen_token = rparen_token;
1601     if (statement)
1602         ast->statement = statement->clone(pool);
1603     return ast;
1604 }
1605
1606 LambdaExpressionAST *LambdaExpressionAST::clone(MemoryPool *pool) const
1607 {
1608     LambdaExpressionAST *ast = new (pool) LambdaExpressionAST;
1609     if (lambda_introducer)
1610         ast->lambda_introducer = lambda_introducer->clone(pool);
1611     if (lambda_declarator)
1612         ast->lambda_declarator = lambda_declarator->clone(pool);
1613     if (statement)
1614         ast->statement = statement->clone(pool);
1615     return ast;
1616 }
1617
1618 LambdaIntroducerAST *LambdaIntroducerAST::clone(MemoryPool *pool) const
1619 {
1620     LambdaIntroducerAST *ast = new (pool) LambdaIntroducerAST;
1621     ast->lbracket_token = lbracket_token;
1622     if (lambda_capture)
1623         ast->lambda_capture = lambda_capture->clone(pool);
1624     ast->rbracket_token = rbracket_token;
1625     return ast;
1626 }
1627
1628 LambdaCaptureAST *LambdaCaptureAST::clone(MemoryPool *pool) const
1629 {
1630     LambdaCaptureAST *ast = new (pool) LambdaCaptureAST;
1631     ast->default_capture_token = default_capture_token;
1632     for (CaptureListAST *iter = capture_list, **ast_iter = &ast->capture_list;
1633          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1634         *ast_iter = new (pool) CaptureListAST((iter->value) ? iter->value->clone(pool) : 0);
1635     return ast;
1636 }
1637
1638 CaptureAST *CaptureAST::clone(MemoryPool *pool) const
1639 {
1640     CaptureAST *ast = new (pool) CaptureAST;
1641     return ast;
1642 }
1643
1644 LambdaDeclaratorAST *LambdaDeclaratorAST::clone(MemoryPool *pool) const
1645 {
1646     LambdaDeclaratorAST *ast = new (pool) LambdaDeclaratorAST;
1647     ast->lparen_token = lparen_token;
1648     if (parameter_declaration_clause)
1649         ast->parameter_declaration_clause = parameter_declaration_clause->clone(pool);
1650     ast->rparen_token = rparen_token;
1651     for (SpecifierListAST *iter = attributes, **ast_iter = &ast->attributes;
1652          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1653         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1654     ast->mutable_token = mutable_token;
1655     if (exception_specification)
1656         ast->exception_specification = exception_specification->clone(pool);
1657     if (trailing_return_type)
1658         ast->trailing_return_type = trailing_return_type->clone(pool);
1659     return ast;
1660 }
1661
1662 TrailingReturnTypeAST *TrailingReturnTypeAST::clone(MemoryPool *pool) const
1663 {
1664     TrailingReturnTypeAST *ast = new (pool) TrailingReturnTypeAST;
1665     ast->arrow_token = arrow_token;
1666     for (SpecifierListAST *iter = attributes, **ast_iter = &ast->attributes;
1667          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1668         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1669     for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
1670          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1671         *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
1672     if (declarator)
1673         ast->declarator = declarator->clone(pool);
1674     return ast;
1675 }
1676
1677 BracedInitializerAST *BracedInitializerAST::clone(MemoryPool *pool) const
1678 {
1679     BracedInitializerAST *ast = new (pool) BracedInitializerAST;
1680     ast->lbrace_token = lbrace_token;
1681     for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
1682          iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1683         *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);
1684     ast->comma_token = comma_token;
1685     ast->rbrace_token = rbrace_token;
1686     return ast;
1687 }
1688