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