/****************************************************************************
**
** 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;
}
ExpressionOrDeclarationStatementAST *ExpressionOrDeclarationStatementAST::clone(MemoryPool *pool) const
{
ExpressionOrDeclarationStatementAST *ast = new (pool) ExpressionOrDeclarationStatementAST;
if (expression)
ast->expression = expression->clone(pool);
if (declaration)
ast->declaration = declaration->clone(pool);
return ast;
}
ExpressionStatementAST *ExpressionStatementAST::clone(MemoryPool *pool) const
{
ExpressionStatementAST *ast = new (pool) ExpressionStatementAST;
if (expression)
ast->expression = expression->clone(pool);
ast->semicolon_token = semicolon_token;
return ast;
}
FunctionDefinitionAST *FunctionDefinitionAST::clone(MemoryPool *pool) const
{
FunctionDefinitionAST *ast = new (pool) FunctionDefinitionAST;
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);
if (declarator)
ast->declarator = declarator->clone(pool);
if (ctor_initializer)
ast->ctor_initializer = ctor_initializer->clone(pool);
if (function_body)
ast->function_body = function_body->clone(pool);
return ast;
}
ForeachStatementAST *ForeachStatementAST::clone(MemoryPool *pool) const
{
ForeachStatementAST *ast = new (pool) ForeachStatementAST;
ast->foreach_token = foreach_token;
ast->lparen_token = lparen_token;
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);
if (initializer)
ast->initializer = initializer->clone(pool);
ast->comma_token = comma_token;
if (expression)
ast->expression = expression->clone(pool);
ast->rparen_token = rparen_token;
if (statement)
ast->statement = statement->clone(pool);
return ast;
}
ForStatementAST *ForStatementAST::clone(MemoryPool *pool) const
{
ForStatementAST *ast = new (pool) ForStatementAST;
ast->for_token = for_token;
ast->lparen_token = lparen_token;
if (initializer)
ast->initializer = initializer->clone(pool);
if (condition)
ast->condition = condition->clone(pool);
ast->semicolon_token = semicolon_token;
if (expression)
ast->expression = expression->clone(pool);
ast->rparen_token = rparen_token;
if (statement)
ast->statement = statement->clone(pool);
return ast;
}
IfStatementAST *IfStatementAST::clone(MemoryPool *pool) const
{
IfStatementAST *ast = new (pool) IfStatementAST;
ast->if_token = if_token;
ast->lparen_token = lparen_token;
if (condition)
ast->condition = condition->clone(pool);
ast->rparen_token = rparen_token;
if (statement)
ast->statement = statement->clone(pool);
ast->else_token = else_token;
if (else_statement)
ast->else_statement = else_statement->clone(pool);
return ast;
}
ArrayInitializerAST *ArrayInitializerAST::clone(MemoryPool *pool) const
{
ArrayInitializerAST *ast = new (pool) ArrayInitializerAST;
ast->lbrace_token = lbrace_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->rbrace_token = rbrace_token;
return ast;
}
LabeledStatementAST *LabeledStatementAST::clone(MemoryPool *pool) const
{
LabeledStatementAST *ast = new (pool) LabeledStatementAST;
ast->label_token = label_token;
ast->colon_token = colon_token;
if (statement)
ast->statement = statement->clone(pool);
return ast;
}
LinkageBodyAST *LinkageBodyAST::clone(MemoryPool *pool) const
{
LinkageBodyAST *ast = new (pool) LinkageBodyAST;
ast->lbrace_token = lbrace_token;
for (DeclarationListAST *iter = declaration_list, **ast_iter = &ast->declaration_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;
}
LinkageSpecificationAST *LinkageSpecificationAST::clone(MemoryPool *pool) const
{
LinkageSpecificationAST *ast = new (pool) LinkageSpecificationAST;
ast->extern_token = extern_token;
ast->extern_type_token = extern_type_token;
if (declaration)
ast->declaration = declaration->clone(pool);
return ast;
}
MemInitializerAST *MemInitializerAST::clone(MemoryPool *pool) const
{
MemInitializerAST *ast = new (pool) MemInitializerAST;
if (name)
ast->name = name->clone(pool);
ast->lparen_token = lparen_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;
}
NestedNameSpecifierAST *NestedNameSpecifierAST::clone(MemoryPool *pool) const
{
NestedNameSpecifierAST *ast = new (pool) NestedNameSpecifierAST;
if (class_or_namespace_name)
ast->class_or_namespace_name = class_or_namespace_name->clone(pool);
ast->scope_token = scope_token;
return ast;
}
QualifiedNameAST *QualifiedNameAST::clone(MemoryPool *pool) const
{
QualifiedNameAST *ast = new (pool) QualifiedNameAST;
ast->global_scope_token = global_scope_token;
for (NestedNameSpecifierListAST *iter = nested_name_specifier_list, **ast_iter = &ast->nested_name_specifier_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) NestedNameSpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
if (unqualified_name)
ast->unqualified_name = unqualified_name->clone(pool);
return ast;
}
OperatorFunctionIdAST *OperatorFunctionIdAST::clone(MemoryPool *pool) const
{
OperatorFunctionIdAST *ast = new (pool) OperatorFunctionIdAST;
ast->operator_token = operator_token;
if (op)
ast->op = op->clone(pool);
return ast;
}
ConversionFunctionIdAST *ConversionFunctionIdAST::clone(MemoryPool *pool) const
{
ConversionFunctionIdAST *ast = new (pool) ConversionFunctionIdAST;
ast->operator_token = operator_token;
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);
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);
return ast;
}
SimpleNameAST *SimpleNameAST::clone(MemoryPool *pool) const
{
SimpleNameAST *ast = new (pool) SimpleNameAST;
ast->identifier_token = identifier_token;
return ast;
}
DestructorNameAST *DestructorNameAST::clone(MemoryPool *pool) const
{
DestructorNameAST *ast = new (pool) DestructorNameAST;
ast->tilde_token = tilde_token;
ast->identifier_token = identifier_token;
return ast;
}
TemplateIdAST *TemplateIdAST::clone(MemoryPool *pool) const
{
TemplateIdAST *ast = new (pool) TemplateIdAST;
ast->identifier_token = identifier_token;
ast->less_token = less_token;
for (TemplateArgumentListAST *iter = template_argument_list, **ast_iter = &ast->template_argument_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) TemplateArgumentListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->greater_token = greater_token;
return ast;
}
NamespaceAST *NamespaceAST::clone(MemoryPool *pool) const
{
NamespaceAST *ast = new (pool) NamespaceAST;
ast->namespace_token = namespace_token;
ast->identifier_token = identifier_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 (linkage_body)
ast->linkage_body = linkage_body->clone(pool);
return ast;
}
NamespaceAliasDefinitionAST *NamespaceAliasDefinitionAST::clone(MemoryPool *pool) const
{
NamespaceAliasDefinitionAST *ast = new (pool) NamespaceAliasDefinitionAST;
ast->namespace_token = namespace_token;
ast->namespace_name_token = namespace_name_token;
ast->equal_token = equal_token;
if (name)
ast->name = name->clone(pool);
ast->semicolon_token = semicolon_token;
return ast;
}
NewPlacementAST *NewPlacementAST::clone(MemoryPool *pool) const
{
NewPlacementAST *ast = new (pool) NewPlacementAST;
ast->lparen_token = lparen_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;
}
NewArrayDeclaratorAST *NewArrayDeclaratorAST::clone(MemoryPool *pool) const
{
NewArrayDeclaratorAST *ast = new (pool) NewArrayDeclaratorAST;
ast->lbracket_token = lbracket_token;
if (expression)
ast->expression = expression->clone(pool);
ast->rbracket_token = rbracket_token;
return ast;
}
NewExpressionAST *NewExpressionAST::clone(MemoryPool *pool) const
{
NewExpressionAST *ast = new (pool) NewExpressionAST;
ast->scope_token = scope_token;
ast->new_token = new_token;
if (new_placement)
ast->new_placement = new_placement->clone(pool);
ast->lparen_token = lparen_token;
if (type_id)
ast->type_id = type_id->clone(pool);
ast->rparen_token = rparen_token;
if (new_type_id)
ast->new_type_id = new_type_id->clone(pool);
if (new_initializer)
ast->new_initializer = new_initializer->clone(pool);
return ast;
}
NewInitializerAST *NewInitializerAST::clone(MemoryPool *pool) const
{
NewInitializerAST *ast = new (pool) NewInitializerAST;
ast->lparen_token = lparen_token;
if (expression)
ast->expression = expression->clone(pool);
ast->rparen_token = rparen_token;
return ast;
}
NewTypeIdAST *NewTypeIdAST::clone(MemoryPool *pool) const
{
NewTypeIdAST *ast = new (pool) NewTypeIdAST;
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);
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);
for (NewArrayDeclaratorListAST *iter = new_array_declarator_list, **ast_iter = &ast->new_array_declarator_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) NewArrayDeclaratorListAST((iter->value) ? iter->value->clone(pool) : 0);
return ast;
}
OperatorAST *OperatorAST::clone(MemoryPool *pool) const
{
OperatorAST *ast = new (pool) OperatorAST;
ast->op_token = op_token;
ast->open_token = open_token;
ast->close_token = close_token;
return ast;
}
ParameterDeclarationAST *ParameterDeclarationAST::clone(MemoryPool *pool) const
{
ParameterDeclarationAST *ast = new (pool) ParameterDeclarationAST;
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->equal_token = equal_token;
if (expression)
ast->expression = expression->clone(pool);
return ast;
}
ParameterDeclarationClauseAST *ParameterDeclarationClauseAST::clone(MemoryPool *pool) const
{
ParameterDeclarationClauseAST *ast = new (pool) ParameterDeclarationClauseAST;
for (DeclarationListAST *iter = parameter_declaration_list, **ast_iter = &ast->parameter_declaration_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->dot_dot_dot_token = dot_dot_dot_token;
return ast;
}
CallAST *CallAST::clone(MemoryPool *pool) const
{
CallAST *ast = new (pool) CallAST;
ast->lparen_token = lparen_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;
}
ArrayAccessAST *ArrayAccessAST::clone(MemoryPool *pool) const
{
ArrayAccessAST *ast = new (pool) ArrayAccessAST;
ast->lbracket_token = lbracket_token;
if (expression)
ast->expression = expression->clone(pool);
ast->rbracket_token = rbracket_token;
return ast;
}
PostIncrDecrAST *PostIncrDecrAST::clone(MemoryPool *pool) const
{
PostIncrDecrAST *ast = new (pool) PostIncrDecrAST;
ast->incr_decr_token = incr_decr_token;
return ast;
}
MemberAccessAST *MemberAccessAST::clone(MemoryPool *pool) const
{
MemberAccessAST *ast = new (pool) MemberAccessAST;
ast->access_token = access_token;
ast->template_token = template_token;
if (member_name)
ast->member_name = member_name->clone(pool);
return ast;
}
TypeidExpressionAST *TypeidExpressionAST::clone(MemoryPool *pool) const
{
TypeidExpressionAST *ast = new (pool) TypeidExpressionAST;
ast->typeid_token = typeid_token;
ast->lparen_token = lparen_token;
if (expression)
ast->expression = expression->clone(pool);
ast->rparen_token = rparen_token;
return ast;
}
TypenameCallExpressionAST *TypenameCallExpressionAST::clone(MemoryPool *pool) const
{
TypenameCallExpressionAST *ast = new (pool) TypenameCallExpressionAST;
ast->typename_token = typename_token;
if (name)
ast->name = name->clone(pool);
ast->lparen_token = lparen_token;
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;
}
TypeConstructorCallAST *TypeConstructorCallAST::clone(MemoryPool *pool) const
{
TypeConstructorCallAST *ast = new (pool) TypeConstructorCallAST;
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);
ast->lparen_token = lparen_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;
}
PostfixExpressionAST *PostfixExpressionAST::clone(MemoryPool *pool) const
{
PostfixExpressionAST *ast = new (pool) PostfixExpressionAST;
if (base_expression)
ast->base_expression = base_expression->clone(pool);
for (PostfixListAST *iter = postfix_expression_list, **ast_iter = &ast->postfix_expression_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) PostfixListAST((iter->value) ? iter->value->clone(pool) : 0);
return ast;
}
PointerToMemberAST *PointerToMemberAST::clone(MemoryPool *pool) const
{
PointerToMemberAST *ast = new (pool) PointerToMemberAST;
ast->global_scope_token = global_scope_token;
for (NestedNameSpecifierListAST *iter = nested_name_specifier_list, **ast_iter = &ast->nested_name_specifier_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) NestedNameSpecifierListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->star_token = star_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);
return ast;
}
PointerAST *PointerAST::clone(MemoryPool *pool) const
{
PointerAST *ast = new (pool) PointerAST;
ast->star_token = star_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);
return ast;
}
ReferenceAST *ReferenceAST::clone(MemoryPool *pool) const
{
ReferenceAST *ast = new (pool) ReferenceAST;
ast->amp_token = amp_token;
return ast;
}
BreakStatementAST *BreakStatementAST::clone(MemoryPool *pool) const
{
BreakStatementAST *ast = new (pool) BreakStatementAST;
ast->break_token = break_token;
ast->semicolon_token = semicolon_token;
return ast;
}
ContinueStatementAST *ContinueStatementAST::clone(MemoryPool *pool) const
{
ContinueStatementAST *ast = new (pool) ContinueStatementAST;
ast->continue_token = continue_token;
ast->semicolon_token = semicolon_token;
return ast;
}
GotoStatementAST *GotoStatementAST::clone(MemoryPool *pool) const
{
GotoStatementAST *ast = new (pool) GotoStatementAST;
ast->goto_token = goto_token;
ast->identifier_token = identifier_token;
ast->semicolon_token = semicolon_token;
return ast;
}
ReturnStatementAST *ReturnStatementAST::clone(MemoryPool *pool) const
{
ReturnStatementAST *ast = new (pool) ReturnStatementAST;
ast->return_token = return_token;
if (expression)
ast->expression = expression->clone(pool);
ast->semicolon_token = semicolon_token;
return ast;
}
SizeofExpressionAST *SizeofExpressionAST::clone(MemoryPool *pool) const
{
SizeofExpressionAST *ast = new (pool) SizeofExpressionAST;
ast->sizeof_token = sizeof_token;
ast->lparen_token = lparen_token;
if (expression)
ast->expression = expression->clone(pool);
ast->rparen_token = rparen_token;
return ast;
}
NumericLiteralAST *NumericLiteralAST::clone(MemoryPool *pool) const
{
NumericLiteralAST *ast = new (pool) NumericLiteralAST;
ast->literal_token = literal_token;
return ast;
}
BoolLiteralAST *BoolLiteralAST::clone(MemoryPool *pool) const
{
BoolLiteralAST *ast = new (pool) BoolLiteralAST;
ast->literal_token = literal_token;
return ast;
}
ThisExpressionAST *ThisExpressionAST::clone(MemoryPool *pool) const
{
ThisExpressionAST *ast = new (pool) ThisExpressionAST;
ast->this_token = this_token;
return ast;
}
NestedExpressionAST *NestedExpressionAST::clone(MemoryPool *pool) const
{
NestedExpressionAST *ast = new (pool) NestedExpressionAST;
ast->lparen_token = lparen_token;
if (expression)
ast->expression = expression->clone(pool);
ast->rparen_token = rparen_token;
return ast;
}
StringLiteralAST *StringLiteralAST::clone(MemoryPool *pool) const
{
StringLiteralAST *ast = new (pool) StringLiteralAST;
ast->literal_token = literal_token;
if (next)
ast->next = next->clone(pool);
return ast;
}
SwitchStatementAST *SwitchStatementAST::clone(MemoryPool *pool) const
{
SwitchStatementAST *ast = new (pool) SwitchStatementAST;
ast->switch_token = switch_token;
ast->lparen_token = lparen_token;
if (condition)
ast->condition = condition->clone(pool);
ast->rparen_token = rparen_token;
if (statement)
ast->statement = statement->clone(pool);
return ast;
}
TemplateDeclarationAST *TemplateDeclarationAST::clone(MemoryPool *pool) const
{
TemplateDeclarationAST *ast = new (pool) TemplateDeclarationAST;
ast->export_token = export_token;
ast->template_token = template_token;
ast->less_token = less_token;
for (DeclarationListAST *iter = template_parameter_list, **ast_iter = &ast->template_parameter_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->greater_token = greater_token;
if (declaration)
ast->declaration = declaration->clone(pool);
return ast;
}
ThrowExpressionAST *ThrowExpressionAST::clone(MemoryPool *pool) const
{
ThrowExpressionAST *ast = new (pool) ThrowExpressionAST;
ast->throw_token = throw_token;
if (expression)
ast->expression = expression->clone(pool);
return ast;
}
TranslationUnitAST *TranslationUnitAST::clone(MemoryPool *pool) const
{
TranslationUnitAST *ast = new (pool) TranslationUnitAST;
for (DeclarationListAST *iter = declaration_list, **ast_iter = &ast->declaration_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
return ast;
}
TryBlockStatementAST *TryBlockStatementAST::clone(MemoryPool *pool) const
{
TryBlockStatementAST *ast = new (pool) TryBlockStatementAST;
ast->try_token = try_token;
if (statement)
ast->statement = statement->clone(pool);
for (CatchClauseListAST *iter = catch_clause_list, **ast_iter = &ast->catch_clause_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) CatchClauseListAST((iter->value) ? iter->value->clone(pool) : 0);
return ast;
}
CatchClauseAST *CatchClauseAST::clone(MemoryPool *pool) const
{
CatchClauseAST *ast = new (pool) CatchClauseAST;
ast->catch_token = catch_token;
ast->lparen_token = lparen_token;
if (exception_declaration)
ast->exception_declaration = exception_declaration->clone(pool);
ast->rparen_token = rparen_token;
if (statement)
ast->statement = statement->clone(pool);
return ast;
}
TypeIdAST *TypeIdAST::clone(MemoryPool *pool) const
{
TypeIdAST *ast = new (pool) TypeIdAST;
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;
}
TypenameTypeParameterAST *TypenameTypeParameterAST::clone(MemoryPool *pool) const
{
TypenameTypeParameterAST *ast = new (pool) TypenameTypeParameterAST;
ast->classkey_token = classkey_token;
if (name)
ast->name = name->clone(pool);
ast->equal_token = equal_token;
if (type_id)
ast->type_id = type_id->clone(pool);
return ast;
}
TemplateTypeParameterAST *TemplateTypeParameterAST::clone(MemoryPool *pool) const
{
TemplateTypeParameterAST *ast = new (pool) TemplateTypeParameterAST;
ast->template_token = template_token;
ast->less_token = less_token;
for (DeclarationListAST *iter = template_parameter_list, **ast_iter = &ast->template_parameter_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->greater_token = greater_token;
ast->class_token = class_token;
if (name)
ast->name = name->clone(pool);
ast->equal_token = equal_token;
if (type_id)
ast->type_id = type_id->clone(pool);
return ast;
}
UnaryExpressionAST *UnaryExpressionAST::clone(MemoryPool *pool) const
{
UnaryExpressionAST *ast = new (pool) UnaryExpressionAST;
ast->unary_op_token = unary_op_token;
if (expression)
ast->expression = expression->clone(pool);
return ast;
}
UsingAST *UsingAST::clone(MemoryPool *pool) const
{
UsingAST *ast = new (pool) UsingAST;
ast->using_token = using_token;
ast->typename_token = typename_token;
if (name)
ast->name = name->clone(pool);
ast->semicolon_token = semicolon_token;
return ast;
}
UsingDirectiveAST *UsingDirectiveAST::clone(MemoryPool *pool) const
{
UsingDirectiveAST *ast = new (pool) UsingDirectiveAST;
ast->using_token = using_token;
ast->namespace_token = namespace_token;
if (name)
ast->name = name->clone(pool);
ast->semicolon_token = semicolon_token;
return ast;
}
WhileStatementAST *WhileStatementAST::clone(MemoryPool *pool) const
{
WhileStatementAST *ast = new (pool) WhileStatementAST;
ast->while_token = while_token;
ast->lparen_token = lparen_token;
if (condition)
ast->condition = condition->clone(pool);
ast->rparen_token = rparen_token;
if (statement)
ast->statement = statement->clone(pool);
return ast;
}
ObjCClassForwardDeclarationAST *ObjCClassForwardDeclarationAST::clone(MemoryPool *pool) const
{
ObjCClassForwardDeclarationAST *ast = new (pool) ObjCClassForwardDeclarationAST;
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);
ast->class_token = class_token;
for (ObjCIdentifierListAST *iter = identifier_list, **ast_iter = &ast->identifier_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) ObjCIdentifierListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->semicolon_token = semicolon_token;
return ast;
}
ObjCClassDeclarationAST *ObjCClassDeclarationAST::clone(MemoryPool *pool) const
{
ObjCClassDeclarationAST *ast = new (pool) ObjCClassDeclarationAST;
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);
ast->interface_token = interface_token;
ast->implementation_token = implementation_token;
if (class_name)
ast->class_name = class_name->clone(pool);
ast->lparen_token = lparen_token;
if (category_name)
ast->category_name = category_name->clone(pool);
ast->rparen_token = rparen_token;
ast->colon_token = colon_token;
if (superclass)
ast->superclass = superclass->clone(pool);
if (protocol_refs)
ast->protocol_refs = protocol_refs->clone(pool);
if (inst_vars_decl)
ast->inst_vars_decl = inst_vars_decl->clone(pool);
for (DeclarationListAST *iter = member_declaration_list, **ast_iter = &ast->member_declaration_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->end_token = end_token;
return ast;
}
ObjCProtocolForwardDeclarationAST *ObjCProtocolForwardDeclarationAST::clone(MemoryPool *pool) const
{
ObjCProtocolForwardDeclarationAST *ast = new (pool) ObjCProtocolForwardDeclarationAST;
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);
ast->protocol_token = protocol_token;
for (ObjCIdentifierListAST *iter = identifier_list, **ast_iter = &ast->identifier_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) ObjCIdentifierListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->semicolon_token = semicolon_token;
return ast;
}
ObjCProtocolDeclarationAST *ObjCProtocolDeclarationAST::clone(MemoryPool *pool) const
{
ObjCProtocolDeclarationAST *ast = new (pool) ObjCProtocolDeclarationAST;
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);
ast->protocol_token = protocol_token;
if (name)
ast->name = name->clone(pool);
if (protocol_refs)
ast->protocol_refs = protocol_refs->clone(pool);
for (DeclarationListAST *iter = member_declaration_list, **ast_iter = &ast->member_declaration_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->end_token = end_token;
return ast;
}
ObjCProtocolRefsAST *ObjCProtocolRefsAST::clone(MemoryPool *pool) const
{
ObjCProtocolRefsAST *ast = new (pool) ObjCProtocolRefsAST;
ast->less_token = less_token;
for (ObjCIdentifierListAST *iter = identifier_list, **ast_iter = &ast->identifier_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) ObjCIdentifierListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->greater_token = greater_token;
return ast;
}
ObjCMessageArgumentAST *ObjCMessageArgumentAST::clone(MemoryPool *pool) const
{
ObjCMessageArgumentAST *ast = new (pool) ObjCMessageArgumentAST;
if (parameter_value_expression)
ast->parameter_value_expression = parameter_value_expression->clone(pool);
return ast;
}
ObjCMessageExpressionAST *ObjCMessageExpressionAST::clone(MemoryPool *pool) const
{
ObjCMessageExpressionAST *ast = new (pool) ObjCMessageExpressionAST;
ast->lbracket_token = lbracket_token;
if (receiver_expression)
ast->receiver_expression = receiver_expression->clone(pool);
if (selector)
ast->selector = selector->clone(pool);
for (ObjCMessageArgumentListAST *iter = argument_list, **ast_iter = &ast->argument_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) ObjCMessageArgumentListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->rbracket_token = rbracket_token;
return ast;
}
ObjCProtocolExpressionAST *ObjCProtocolExpressionAST::clone(MemoryPool *pool) const
{
ObjCProtocolExpressionAST *ast = new (pool) ObjCProtocolExpressionAST;
ast->protocol_token = protocol_token;
ast->lparen_token = lparen_token;
ast->identifier_token = identifier_token;
ast->rparen_token = rparen_token;
return ast;
}
ObjCTypeNameAST *ObjCTypeNameAST::clone(MemoryPool *pool) const
{
ObjCTypeNameAST *ast = new (pool) ObjCTypeNameAST;
ast->lparen_token = lparen_token;
ast->type_qualifier_token = type_qualifier_token;
if (type_id)
ast->type_id = type_id->clone(pool);
ast->rparen_token = rparen_token;
return ast;
}
ObjCEncodeExpressionAST *ObjCEncodeExpressionAST::clone(MemoryPool *pool) const
{
ObjCEncodeExpressionAST *ast = new (pool) ObjCEncodeExpressionAST;
ast->encode_token = encode_token;
if (type_name)
ast->type_name = type_name->clone(pool);
return ast;
}
ObjCSelectorWithoutArgumentsAST *ObjCSelectorWithoutArgumentsAST::clone(MemoryPool *pool) const
{
ObjCSelectorWithoutArgumentsAST *ast = new (pool) ObjCSelectorWithoutArgumentsAST;
ast->name_token = name_token;
return ast;
}
ObjCSelectorArgumentAST *ObjCSelectorArgumentAST::clone(MemoryPool *pool) const
{
ObjCSelectorArgumentAST *ast = new (pool) ObjCSelectorArgumentAST;
ast->name_token = name_token;
ast->colon_token = colon_token;
return ast;
}
ObjCSelectorWithArgumentsAST *ObjCSelectorWithArgumentsAST::clone(MemoryPool *pool) const
{
ObjCSelectorWithArgumentsAST *ast = new (pool) ObjCSelectorWithArgumentsAST;
for (ObjCSelectorArgumentListAST *iter = selector_argument_list, **ast_iter = &ast->selector_argument_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) ObjCSelectorArgumentListAST((iter->value) ? iter->value->clone(pool) : 0);
return ast;
}
ObjCSelectorExpressionAST *ObjCSelectorExpressionAST::clone(MemoryPool *pool) const
{
ObjCSelectorExpressionAST *ast = new (pool) ObjCSelectorExpressionAST;
ast->selector_token = selector_token;
ast->lparen_token = lparen_token;
if (selector)
ast->selector = selector->clone(pool);
ast->rparen_token = rparen_token;
return ast;
}
ObjCInstanceVariablesDeclarationAST *ObjCInstanceVariablesDeclarationAST::clone(MemoryPool *pool) const
{
ObjCInstanceVariablesDeclarationAST *ast = new (pool) ObjCInstanceVariablesDeclarationAST;
ast->lbrace_token = lbrace_token;
for (DeclarationListAST *iter = instance_variable_list, **ast_iter = &ast->instance_variable_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;
}
ObjCVisibilityDeclarationAST *ObjCVisibilityDeclarationAST::clone(MemoryPool *pool) const
{
ObjCVisibilityDeclarationAST *ast = new (pool) ObjCVisibilityDeclarationAST;
ast->visibility_token = visibility_token;
return ast;
}
ObjCPropertyAttributeAST *ObjCPropertyAttributeAST::clone(MemoryPool *pool) const
{
ObjCPropertyAttributeAST *ast = new (pool) ObjCPropertyAttributeAST;
ast->attribute_identifier_token = attribute_identifier_token;
ast->equals_token = equals_token;
if (method_selector)
ast->method_selector = method_selector->clone(pool);
return ast;
}
ObjCPropertyDeclarationAST *ObjCPropertyDeclarationAST::clone(MemoryPool *pool) const
{
ObjCPropertyDeclarationAST *ast = new (pool) ObjCPropertyDeclarationAST;
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);
ast->property_token = property_token;
ast->lparen_token = lparen_token;
for (ObjCPropertyAttributeListAST *iter = property_attribute_list, **ast_iter = &ast->property_attribute_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) ObjCPropertyAttributeListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->rparen_token = rparen_token;
if (simple_declaration)
ast->simple_declaration = simple_declaration->clone(pool);
return ast;
}
ObjCMessageArgumentDeclarationAST *ObjCMessageArgumentDeclarationAST::clone(MemoryPool *pool) const
{
ObjCMessageArgumentDeclarationAST *ast = new (pool) ObjCMessageArgumentDeclarationAST;
if (type_name)
ast->type_name = type_name->clone(pool);
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);
ast->param_name_token = param_name_token;
return ast;
}
ObjCMethodPrototypeAST *ObjCMethodPrototypeAST::clone(MemoryPool *pool) const
{
ObjCMethodPrototypeAST *ast = new (pool) ObjCMethodPrototypeAST;
ast->method_type_token = method_type_token;
if (type_name)
ast->type_name = type_name->clone(pool);
if (selector)
ast->selector = selector->clone(pool);
for (ObjCMessageArgumentDeclarationListAST *iter = argument_list, **ast_iter = &ast->argument_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) ObjCMessageArgumentDeclarationListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->dot_dot_dot_token = dot_dot_dot_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);
return ast;
}
ObjCMethodDeclarationAST *ObjCMethodDeclarationAST::clone(MemoryPool *pool) const
{
ObjCMethodDeclarationAST *ast = new (pool) ObjCMethodDeclarationAST;
if (method_prototype)
ast->method_prototype = method_prototype->clone(pool);
if (function_body)
ast->function_body = function_body->clone(pool);
ast->semicolon_token = semicolon_token;
return ast;
}
ObjCSynthesizedPropertyAST *ObjCSynthesizedPropertyAST::clone(MemoryPool *pool) const
{
ObjCSynthesizedPropertyAST *ast = new (pool) ObjCSynthesizedPropertyAST;
ast->property_identifier_token = property_identifier_token;
ast->equals_token = equals_token;
ast->alias_identifier_token = alias_identifier_token;
return ast;
}
ObjCSynthesizedPropertiesDeclarationAST *ObjCSynthesizedPropertiesDeclarationAST::clone(MemoryPool *pool) const
{
ObjCSynthesizedPropertiesDeclarationAST *ast = new (pool) ObjCSynthesizedPropertiesDeclarationAST;
ast->synthesized_token = synthesized_token;
for (ObjCSynthesizedPropertyListAST *iter = property_identifier_list, **ast_iter = &ast->property_identifier_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) ObjCSynthesizedPropertyListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->semicolon_token = semicolon_token;
return ast;
}
ObjCDynamicPropertiesDeclarationAST *ObjCDynamicPropertiesDeclarationAST::clone(MemoryPool *pool) const
{
ObjCDynamicPropertiesDeclarationAST *ast = new (pool) ObjCDynamicPropertiesDeclarationAST;
ast->dynamic_token = dynamic_token;
for (ObjCIdentifierListAST *iter = property_identifier_list, **ast_iter = &ast->property_identifier_list;
iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
*ast_iter = new (pool) ObjCIdentifierListAST((iter->value) ? iter->value->clone(pool) : 0);
ast->semicolon_token = semicolon_token;
return ast;
}
ObjCFastEnumerationAST *ObjCFastEnumerationAST::clone(MemoryPool *pool) const
{
ObjCFastEnumerationAST *ast = new (pool) ObjCFastEnumerationAST;
ast->for_token = for_token;
ast->lparen_token = lparen_token;
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);
if (initializer)
ast->initializer = initializer->clone(pool);
ast->in_token = in_token;
if (fast_enumeratable_expression)
ast->fast_enumeratable_expression = fast_enumeratable_expression->clone(pool);
ast->rparen_token = rparen_token;
if (statement)
ast->statement = statement->clone(pool);
return ast;
}
ObjCSynchronizedStatementAST *ObjCSynchronizedStatementAST::clone(MemoryPool *pool) const
{
ObjCSynchronizedStatementAST *ast = new (pool) ObjCSynchronizedStatementAST;
ast->synchronized_token = synchronized_token;
ast->lparen_token = lparen_token;
if (synchronized_object)
ast->synchronized_object = synchronized_object->clone(pool);
ast->rparen_token = rparen_token;
if (statement)
ast->statement = statement->clone(pool);
return ast;
}