/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

//

//  W A R N I N G

//  -------------

//

// This file is automatically generated.

// Changes will be lost.

//

#include "AST.h"

#include "MemoryPool.h"

using namespace CPlusPlus;

SimpleSpecifierAST *SimpleSpecifierAST::clone(MemoryPool *pool) const

{

    SimpleSpecifierAST *ast = new (pool) SimpleSpecifierAST;

    ast->specifier_token = specifier_token;

    return ast;

}

AttributeSpecifierAST *AttributeSpecifierAST::clone(MemoryPool *pool) const

{

    AttributeSpecifierAST *ast = new (pool) AttributeSpecifierAST;

    ast->attribute_token = attribute_token;

    ast->first_lparen_token = first_lparen_token;

    ast->second_lparen_token = second_lparen_token;

    for (AttributeListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) AttributeListAST((iter->value) ? iter->value->clone(pool) : 0);

    ast->first_rparen_token = first_rparen_token;

    ast->second_rparen_token = second_rparen_token;

    return ast;

}

AttributeAST *AttributeAST::clone(MemoryPool *pool) const

{

    AttributeAST *ast = new (pool) AttributeAST;

    ast->identifier_token = identifier_token;

    ast->lparen_token = lparen_token;

    ast->tag_token = tag_token;

    for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);

    ast->rparen_token = rparen_token;

    return ast;

}

TypeofSpecifierAST *TypeofSpecifierAST::clone(MemoryPool *pool) const

{

    TypeofSpecifierAST *ast = new (pool) TypeofSpecifierAST;

    ast->typeof_token = typeof_token;

    ast->lparen_token = lparen_token;

    if (expression)

        ast->expression = expression->clone(pool);

    ast->rparen_token = rparen_token;

    return ast;

}

DeclaratorAST *DeclaratorAST::clone(MemoryPool *pool) const

{

    DeclaratorAST *ast = new (pool) DeclaratorAST;

    for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);

    for (PtrOperatorListAST *iter = ptr_operator_list, **ast_iter = &ast->ptr_operator_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) PtrOperatorListAST((iter->value) ? iter->value->clone(pool) : 0);

    if (core_declarator)

        ast->core_declarator = core_declarator->clone(pool);

    for (PostfixDeclaratorListAST *iter = postfix_declarator_list, **ast_iter = &ast->postfix_declarator_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) PostfixDeclaratorListAST((iter->value) ? iter->value->clone(pool) : 0);

    for (SpecifierListAST *iter = post_attribute_list, **ast_iter = &ast->post_attribute_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);

    ast->equals_token = equals_token;

    if (initializer)

        ast->initializer = initializer->clone(pool);

    return ast;

}

SimpleDeclarationAST *SimpleDeclarationAST::clone(MemoryPool *pool) const

{

    SimpleDeclarationAST *ast = new (pool) SimpleDeclarationAST;

    ast->qt_invokable_token = qt_invokable_token;

    for (SpecifierListAST *iter = decl_specifier_list, **ast_iter = &ast->decl_specifier_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);

    for (DeclaratorListAST *iter = declarator_list, **ast_iter = &ast->declarator_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) DeclaratorListAST((iter->value) ? iter->value->clone(pool) : 0);

    ast->semicolon_token = semicolon_token;

    return ast;

}

EmptyDeclarationAST *EmptyDeclarationAST::clone(MemoryPool *pool) const

{

    EmptyDeclarationAST *ast = new (pool) EmptyDeclarationAST;

    ast->semicolon_token = semicolon_token;

    return ast;

}

AccessDeclarationAST *AccessDeclarationAST::clone(MemoryPool *pool) const

{

    AccessDeclarationAST *ast = new (pool) AccessDeclarationAST;

    ast->access_specifier_token = access_specifier_token;

    ast->slots_token = slots_token;

    ast->colon_token = colon_token;

    return ast;

}

#ifdef ICHECK_BUILD

QPropertyDeclarationAST *QPropertyDeclarationAST::clone(MemoryPool *pool) const

{

    QPropertyDeclarationAST *ast = new (pool) QPropertyDeclarationAST;

    ast->property_specifier_token = property_specifier_token;

    ast->lparen_token = lparen_token;

    ast->type_token = type_token;

    ast->type_name_token = type_name_token;

    ast->read_token = read_token;

    ast->read_function_token = read_function_token;

    ast->write_token = write_token;

    ast->write_function_token = write_function_token;

    ast->reset_token = reset_token;

    ast->reset_function_token = reset_function_token;

    ast->notify_token = notify_token;

    ast->notify_function_token = notify_function_token;

    ast->rparen_token = rparen_token;

    return ast;

}

QEnumDeclarationAST *QEnumDeclarationAST::clone(MemoryPool *pool) const

{

    QEnumDeclarationAST *ast = new (pool)QEnumDeclarationAST;

    ast->enum_specifier_token = enum_specifier_token;

    ast->lparen_token = lparen_token;

    ast->rparen_token = rparen_token;

    for (EnumeratorListAST *iter = enumerator_list, **ast_iter = &ast->enumerator_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) EnumeratorListAST((iter->value) ? iter->value->clone(pool) : 0);

    return ast;

}

QFlagsDeclarationAST *QFlagsDeclarationAST::clone(MemoryPool *pool) const

{

    QFlagsDeclarationAST *ast = new (pool) QFlagsDeclarationAST;

    ast->flags_specifier_token = flags_specifier_token;

    ast->lparen_token = lparen_token;

    ast->rparen_token = rparen_token;

    for (EnumeratorListAST *iter = enumerator_list, **ast_iter = &ast->enumerator_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) EnumeratorListAST((iter->value) ? iter->value->clone(pool) : 0);

    return ast;

}

QDeclareFlagsDeclarationAST *QDeclareFlagsDeclarationAST::clone(MemoryPool *pool) const

{

    QDeclareFlagsDeclarationAST *ast = new (pool) QDeclareFlagsDeclarationAST;

    ast->declareflags_specifier_token = declareflags_specifier_token;

    ast->lparen_token = lparen_token;

    ast->flag_token = flag_token;

    ast->enum_token = enum_token;

    ast->rparen_token = rparen_token;

    return ast;

}

#endif

AsmDefinitionAST *AsmDefinitionAST::clone(MemoryPool *pool) const

{

    AsmDefinitionAST *ast = new (pool) AsmDefinitionAST;

    ast->asm_token = asm_token;

    ast->volatile_token = volatile_token;

    ast->lparen_token = lparen_token;

    ast->rparen_token = rparen_token;

    ast->semicolon_token = semicolon_token;

    return ast;

}

BaseSpecifierAST *BaseSpecifierAST::clone(MemoryPool *pool) const

{

    BaseSpecifierAST *ast = new (pool) BaseSpecifierAST;

    ast->virtual_token = virtual_token;

    ast->access_specifier_token = access_specifier_token;

    if (name)

        ast->name = name->clone(pool);

    return ast;

}

CompoundLiteralAST *CompoundLiteralAST::clone(MemoryPool *pool) const

{

    CompoundLiteralAST *ast = new (pool) CompoundLiteralAST;

    ast->lparen_token = lparen_token;

    if (type_id)

        ast->type_id = type_id->clone(pool);

    ast->rparen_token = rparen_token;

    if (initializer)

        ast->initializer = initializer->clone(pool);

    return ast;

}

QtMethodAST *QtMethodAST::clone(MemoryPool *pool) const

{

    QtMethodAST *ast = new (pool) QtMethodAST;

    ast->method_token = method_token;

    ast->lparen_token = lparen_token;

    if (declarator)

        ast->declarator = declarator->clone(pool);

    ast->rparen_token = rparen_token;

    return ast;

}

QtMemberDeclarationAST *QtMemberDeclarationAST::clone(MemoryPool *pool) const

{

    QtMemberDeclarationAST *ast = new (pool) QtMemberDeclarationAST;

    ast->q_token = q_token;

    ast->lparen_token = lparen_token;

    if (type_id)

        ast->type_id = type_id->clone(pool);

    ast->rparen_token = rparen_token;

    return ast;

}

BinaryExpressionAST *BinaryExpressionAST::clone(MemoryPool *pool) const

{

    BinaryExpressionAST *ast = new (pool) BinaryExpressionAST;

    if (left_expression)

        ast->left_expression = left_expression->clone(pool);

    ast->binary_op_token = binary_op_token;

    if (right_expression)

        ast->right_expression = right_expression->clone(pool);

    return ast;

}

CastExpressionAST *CastExpressionAST::clone(MemoryPool *pool) const

{

    CastExpressionAST *ast = new (pool) CastExpressionAST;

    ast->lparen_token = lparen_token;

    if (type_id)

        ast->type_id = type_id->clone(pool);

    ast->rparen_token = rparen_token;

    if (expression)

        ast->expression = expression->clone(pool);

    return ast;

}

ClassSpecifierAST *ClassSpecifierAST::clone(MemoryPool *pool) const

{

    ClassSpecifierAST *ast = new (pool) ClassSpecifierAST;

    ast->classkey_token = classkey_token;

    for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);

    if (name)

        ast->name = name->clone(pool);

    ast->colon_token = colon_token;

    for (BaseSpecifierListAST *iter = base_clause_list, **ast_iter = &ast->base_clause_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) BaseSpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);

    ast->lbrace_token = lbrace_token;

    for (DeclarationListAST *iter = member_specifier_list, **ast_iter = &ast->member_specifier_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);

    ast->rbrace_token = rbrace_token;

    return ast;

}

CaseStatementAST *CaseStatementAST::clone(MemoryPool *pool) const

{

    CaseStatementAST *ast = new (pool) CaseStatementAST;

    ast->case_token = case_token;

    if (expression)

        ast->expression = expression->clone(pool);

    ast->colon_token = colon_token;

    if (statement)

        ast->statement = statement->clone(pool);

    return ast;

}

CompoundStatementAST *CompoundStatementAST::clone(MemoryPool *pool) const

{

    CompoundStatementAST *ast = new (pool) CompoundStatementAST;

    ast->lbrace_token = lbrace_token;

    for (StatementListAST *iter = statement_list, **ast_iter = &ast->statement_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) StatementListAST((iter->value) ? iter->value->clone(pool) : 0);

    ast->rbrace_token = rbrace_token;

    return ast;

}

ConditionAST *ConditionAST::clone(MemoryPool *pool) const

{

    ConditionAST *ast = new (pool) ConditionAST;

    for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);

    if (declarator)

        ast->declarator = declarator->clone(pool);

    return ast;

}

ConditionalExpressionAST *ConditionalExpressionAST::clone(MemoryPool *pool) const

{

    ConditionalExpressionAST *ast = new (pool) ConditionalExpressionAST;

    if (condition)

        ast->condition = condition->clone(pool);

    ast->question_token = question_token;

    if (left_expression)

        ast->left_expression = left_expression->clone(pool);

    ast->colon_token = colon_token;

    if (right_expression)

        ast->right_expression = right_expression->clone(pool);

    return ast;

}

CppCastExpressionAST *CppCastExpressionAST::clone(MemoryPool *pool) const

{

    CppCastExpressionAST *ast = new (pool) CppCastExpressionAST;

    ast->cast_token = cast_token;

    ast->less_token = less_token;

    if (type_id)

        ast->type_id = type_id->clone(pool);

    ast->greater_token = greater_token;

    ast->lparen_token = lparen_token;

    if (expression)

        ast->expression = expression->clone(pool);

    ast->rparen_token = rparen_token;

    return ast;

}

CtorInitializerAST *CtorInitializerAST::clone(MemoryPool *pool) const

{

    CtorInitializerAST *ast = new (pool) CtorInitializerAST;

    ast->colon_token = colon_token;

    for (MemInitializerListAST *iter = member_initializer_list, **ast_iter = &ast->member_initializer_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) MemInitializerListAST((iter->value) ? iter->value->clone(pool) : 0);

    return ast;

}

DeclarationStatementAST *DeclarationStatementAST::clone(MemoryPool *pool) const

{

    DeclarationStatementAST *ast = new (pool) DeclarationStatementAST;

    if (declaration)

        ast->declaration = declaration->clone(pool);

    return ast;

}

DeclaratorIdAST *DeclaratorIdAST::clone(MemoryPool *pool) const

{

    DeclaratorIdAST *ast = new (pool) DeclaratorIdAST;

    if (name)

        ast->name = name->clone(pool);

    return ast;

}

NestedDeclaratorAST *NestedDeclaratorAST::clone(MemoryPool *pool) const

{

    NestedDeclaratorAST *ast = new (pool) NestedDeclaratorAST;

    ast->lparen_token = lparen_token;

    if (declarator)

        ast->declarator = declarator->clone(pool);

    ast->rparen_token = rparen_token;

    return ast;

}

FunctionDeclaratorAST *FunctionDeclaratorAST::clone(MemoryPool *pool) const

{

    FunctionDeclaratorAST *ast = new (pool) FunctionDeclaratorAST;

    ast->lparen_token = lparen_token;

    if (parameters)

        ast->parameters = parameters->clone(pool);

    ast->rparen_token = rparen_token;

    for (SpecifierListAST *iter = cv_qualifier_list, **ast_iter = &ast->cv_qualifier_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);

    if (exception_specification)

        ast->exception_specification = exception_specification->clone(pool);

    if (as_cpp_initializer)

        ast->as_cpp_initializer = as_cpp_initializer->clone(pool);

    return ast;

}

ArrayDeclaratorAST *ArrayDeclaratorAST::clone(MemoryPool *pool) const

{

    ArrayDeclaratorAST *ast = new (pool) ArrayDeclaratorAST;

    ast->lbracket_token = lbracket_token;

    if (expression)

        ast->expression = expression->clone(pool);

    ast->rbracket_token = rbracket_token;

    return ast;

}

DeleteExpressionAST *DeleteExpressionAST::clone(MemoryPool *pool) const

{

    DeleteExpressionAST *ast = new (pool) DeleteExpressionAST;

    ast->scope_token = scope_token;

    ast->delete_token = delete_token;

    ast->lbracket_token = lbracket_token;

    ast->rbracket_token = rbracket_token;

    if (expression)

        ast->expression = expression->clone(pool);

    return ast;

}

DoStatementAST *DoStatementAST::clone(MemoryPool *pool) const

{

    DoStatementAST *ast = new (pool) DoStatementAST;

    ast->do_token = do_token;

    if (statement)

        ast->statement = statement->clone(pool);

    ast->while_token = while_token;

    ast->lparen_token = lparen_token;

    if (expression)

        ast->expression = expression->clone(pool);

    ast->rparen_token = rparen_token;

    ast->semicolon_token = semicolon_token;

    return ast;

}

NamedTypeSpecifierAST *NamedTypeSpecifierAST::clone(MemoryPool *pool) const

{

    NamedTypeSpecifierAST *ast = new (pool) NamedTypeSpecifierAST;

    if (name)

        ast->name = name->clone(pool);

    return ast;

}

ElaboratedTypeSpecifierAST *ElaboratedTypeSpecifierAST::clone(MemoryPool *pool) const

{

    ElaboratedTypeSpecifierAST *ast = new (pool) ElaboratedTypeSpecifierAST;

    ast->classkey_token = classkey_token;

    if (name)

        ast->name = name->clone(pool);

    return ast;

}

EnumSpecifierAST *EnumSpecifierAST::clone(MemoryPool *pool) const

{

    EnumSpecifierAST *ast = new (pool) EnumSpecifierAST;

    ast->enum_token = enum_token;

    if (name)

        ast->name = name->clone(pool);

    ast->lbrace_token = lbrace_token;

    for (EnumeratorListAST *iter = enumerator_list, **ast_iter = &ast->enumerator_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) EnumeratorListAST((iter->value) ? iter->value->clone(pool) : 0);

    ast->rbrace_token = rbrace_token;

    return ast;

}

EnumeratorAST *EnumeratorAST::clone(MemoryPool *pool) const

{

    EnumeratorAST *ast = new (pool) EnumeratorAST;

    ast->identifier_token = identifier_token;

    ast->equal_token = equal_token;

    if (expression)

        ast->expression = expression->clone(pool);

    return ast;

}

ExceptionDeclarationAST *ExceptionDeclarationAST::clone(MemoryPool *pool) const

{

    ExceptionDeclarationAST *ast = new (pool) ExceptionDeclarationAST;

    for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);

    if (declarator)

        ast->declarator = declarator->clone(pool);

    ast->dot_dot_dot_token = dot_dot_dot_token;

    return ast;

}

ExceptionSpecificationAST *ExceptionSpecificationAST::clone(MemoryPool *pool) const

{

    ExceptionSpecificationAST *ast = new (pool) ExceptionSpecificationAST;

    ast->throw_token = throw_token;

    ast->lparen_token = lparen_token;

    ast->dot_dot_dot_token = dot_dot_dot_token;

    for (ExpressionListAST *iter = type_id_list, **ast_iter = &ast->type_id_list;

         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)

        *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : 0);

    ast->rparen_token = rparen_token;

    return ast;

}