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

**

** 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$

**

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

#include "AST.h"

#include "ASTMatcher.h"

#include "TranslationUnit.h"

using namespace CPlusPlus;

ASTMatcher::ASTMatcher()

{ }

ASTMatcher::~ASTMatcher()

{ }

bool ASTMatcher::match(SimpleSpecifierAST *node, SimpleSpecifierAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->specifier_token = node->specifier_token;

    return true;

}

bool ASTMatcher::match(AttributeSpecifierAST *node, AttributeSpecifierAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->attribute_token = node->attribute_token;

    pattern->first_lparen_token = node->first_lparen_token;

    pattern->second_lparen_token = node->second_lparen_token;

    if (! pattern->attribute_list)

        pattern->attribute_list = node->attribute_list;

    else if (! AST::match(node->attribute_list, pattern->attribute_list, this))

        return false;

    pattern->first_rparen_token = node->first_rparen_token;

    pattern->second_rparen_token = node->second_rparen_token;

    return true;

}

bool ASTMatcher::match(AttributeAST *node, AttributeAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->identifier_token = node->identifier_token;

    pattern->lparen_token = node->lparen_token;

    pattern->tag_token = node->tag_token;

    if (! pattern->expression_list)

        pattern->expression_list = node->expression_list;

    else if (! AST::match(node->expression_list, pattern->expression_list, this))

        return false;

    pattern->rparen_token = node->rparen_token;

    return true;

}

bool ASTMatcher::match(TypeofSpecifierAST *node, TypeofSpecifierAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->typeof_token = node->typeof_token;

    pattern->lparen_token = node->lparen_token;

    if (! pattern->expression)

        pattern->expression = node->expression;

    else if (! AST::match(node->expression, pattern->expression, this))

        return false;

    pattern->rparen_token = node->rparen_token;

    return true;

}

bool ASTMatcher::match(DeclaratorAST *node, DeclaratorAST *pattern)

{

    (void) node;

    (void) pattern;

    if (! pattern->attribute_list)

        pattern->attribute_list = node->attribute_list;

    else if (! AST::match(node->attribute_list, pattern->attribute_list, this))

        return false;

    if (! pattern->ptr_operator_list)

        pattern->ptr_operator_list = node->ptr_operator_list;

    else if (! AST::match(node->ptr_operator_list, pattern->ptr_operator_list, this))

        return false;

    if (! pattern->core_declarator)

        pattern->core_declarator = node->core_declarator;

    else if (! AST::match(node->core_declarator, pattern->core_declarator, this))

        return false;

    if (! pattern->postfix_declarator_list)

        pattern->postfix_declarator_list = node->postfix_declarator_list;

    else if (! AST::match(node->postfix_declarator_list, pattern->postfix_declarator_list, this))

        return false;

    if (! pattern->post_attribute_list)

        pattern->post_attribute_list = node->post_attribute_list;

    else if (! AST::match(node->post_attribute_list, pattern->post_attribute_list, this))

        return false;

    pattern->equals_token = node->equals_token;

    if (! pattern->initializer)

        pattern->initializer = node->initializer;

    else if (! AST::match(node->initializer, pattern->initializer, this))

        return false;

    return true;

}

bool ASTMatcher::match(SimpleDeclarationAST *node, SimpleDeclarationAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->qt_invokable_token = node->qt_invokable_token;

    if (! pattern->decl_specifier_list)

        pattern->decl_specifier_list = node->decl_specifier_list;

    else if (! AST::match(node->decl_specifier_list, pattern->decl_specifier_list, this))

        return false;

    if (! pattern->declarator_list)

        pattern->declarator_list = node->declarator_list;

    else if (! AST::match(node->declarator_list, pattern->declarator_list, this))

        return false;

    pattern->semicolon_token = node->semicolon_token;

    return true;

}

bool ASTMatcher::match(EmptyDeclarationAST *node, EmptyDeclarationAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->semicolon_token = node->semicolon_token;

    return true;

}

bool ASTMatcher::match(AccessDeclarationAST *node, AccessDeclarationAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->access_specifier_token = node->access_specifier_token;

    pattern->slots_token = node->slots_token;

    pattern->colon_token = node->colon_token;

#ifdef ICHECK_BUILD

    pattern->invoke_token = node->invoke_token;

#endif

    return true;

}

#ifdef ICHECK_BUILD

bool ASTMatcher::match(QPropertyDeclarationAST *node, QPropertyDeclarationAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->property_specifier_token = node->property_specifier_token;

    pattern->type_name_token = node->type_name_token;

    pattern->read_function_token = node->read_function_token;

    pattern->write_function_token = node->write_function_token;

    pattern->notify_function_token = node->notify_function_token;

    return true;

}

bool ASTMatcher::match(QEnumDeclarationAST *node, QEnumDeclarationAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->enum_specifier_token = node->enum_specifier_token;

    if (! pattern->enumerator_list)

        pattern->enumerator_list = node->enumerator_list;

    else if (! AST::match(node->enumerator_list, pattern->enumerator_list, this))

        return false;

    return true;

}

bool ASTMatcher::match(QFlagsDeclarationAST *node, QFlagsDeclarationAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->flags_specifier_token = node->flags_specifier_token;

    if (! pattern->enumerator_list)

        pattern->enumerator_list = node->enumerator_list;

    else if (! AST::match(node->enumerator_list, pattern->enumerator_list, this))

        return false;

    return true;

}

bool ASTMatcher::match(QDeclareFlagsDeclarationAST *node, QDeclareFlagsDeclarationAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->declareflags_specifier_token = node->declareflags_specifier_token;

    pattern->flag_token = node->flag_token;

    pattern->enum_token = node->enum_token;

    return true;

}

#endif

bool ASTMatcher::match(AsmDefinitionAST *node, AsmDefinitionAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->asm_token = node->asm_token;

    pattern->volatile_token = node->volatile_token;

    pattern->lparen_token = node->lparen_token;

    pattern->rparen_token = node->rparen_token;

    pattern->semicolon_token = node->semicolon_token;

    return true;

}

bool ASTMatcher::match(BaseSpecifierAST *node, BaseSpecifierAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->virtual_token = node->virtual_token;

    pattern->access_specifier_token = node->access_specifier_token;

    if (! pattern->name)

        pattern->name = node->name;

    else if (! AST::match(node->name, pattern->name, this))

        return false;

    return true;

}

bool ASTMatcher::match(CompoundLiteralAST *node, CompoundLiteralAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->lparen_token = node->lparen_token;

    if (! pattern->type_id)

        pattern->type_id = node->type_id;

    else if (! AST::match(node->type_id, pattern->type_id, this))

        return false;

    pattern->rparen_token = node->rparen_token;

    if (! pattern->initializer)

        pattern->initializer = node->initializer;

    else if (! AST::match(node->initializer, pattern->initializer, this))

        return false;

    return true;

}

bool ASTMatcher::match(QtMethodAST *node, QtMethodAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->method_token = node->method_token;

    pattern->lparen_token = node->lparen_token;

    if (! pattern->declarator)

        pattern->declarator = node->declarator;

    else if (! AST::match(node->declarator, pattern->declarator, this))

        return false;

    pattern->rparen_token = node->rparen_token;

    return true;

}

bool ASTMatcher::match(QtMemberDeclarationAST *node, QtMemberDeclarationAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->q_token = node->q_token;

    pattern->lparen_token = node->lparen_token;

    if (! pattern->type_id)

        pattern->type_id = node->type_id;

    else if (! AST::match(node->type_id, pattern->type_id, this))

        return false;

    pattern->rparen_token = node->rparen_token;

    return true;

}

bool ASTMatcher::match(BinaryExpressionAST *node, BinaryExpressionAST *pattern)

{

    (void) node;

    (void) pattern;

    if (! pattern->left_expression)

        pattern->left_expression = node->left_expression;

    else if (! AST::match(node->left_expression, pattern->left_expression, this))

        return false;

    pattern->binary_op_token = node->binary_op_token;

    if (! pattern->right_expression)

        pattern->right_expression = node->right_expression;

    else if (! AST::match(node->right_expression, pattern->right_expression, this))

        return false;

    return true;

}

bool ASTMatcher::match(CastExpressionAST *node, CastExpressionAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->lparen_token = node->lparen_token;

    if (! pattern->type_id)

        pattern->type_id = node->type_id;

    else if (! AST::match(node->type_id, pattern->type_id, this))

        return false;

    pattern->rparen_token = node->rparen_token;

    if (! pattern->expression)

        pattern->expression = node->expression;

    else if (! AST::match(node->expression, pattern->expression, this))

        return false;

    return true;

}

bool ASTMatcher::match(ClassSpecifierAST *node, ClassSpecifierAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->classkey_token = node->classkey_token;

    if (! pattern->attribute_list)

        pattern->attribute_list = node->attribute_list;

    else if (! AST::match(node->attribute_list, pattern->attribute_list, this))

        return false;

    if (! pattern->name)

        pattern->name = node->name;

    else if (! AST::match(node->name, pattern->name, this))

        return false;

    pattern->colon_token = node->colon_token;

    if (! pattern->base_clause_list)

        pattern->base_clause_list = node->base_clause_list;

    else if (! AST::match(node->base_clause_list, pattern->base_clause_list, this))

        return false;

    pattern->lbrace_token = node->lbrace_token;

    if (! pattern->member_specifier_list)

        pattern->member_specifier_list = node->member_specifier_list;

    else if (! AST::match(node->member_specifier_list, pattern->member_specifier_list, this))

        return false;

    pattern->rbrace_token = node->rbrace_token;

    return true;

}

bool ASTMatcher::match(CaseStatementAST *node, CaseStatementAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->case_token = node->case_token;

    if (! pattern->expression)

        pattern->expression = node->expression;

    else if (! AST::match(node->expression, pattern->expression, this))

        return false;

    pattern->colon_token = node->colon_token;

    if (! pattern->statement)

        pattern->statement = node->statement;

    else if (! AST::match(node->statement, pattern->statement, this))

        return false;

    return true;

}

bool ASTMatcher::match(CompoundStatementAST *node, CompoundStatementAST *pattern)

{

    (void) node;

    (void) pattern;

    pattern->lbrace_token = node->lbrace_token;

    if (! pattern->statement_list)

        pattern->statement_list = node->statement_list;

    else if (! AST::match(node->statement_list, pattern->statement_list, this))

        return false;

    pattern->rbrace_token = node->rbrace_token;

    return true;

}

bool ASTMatcher::match(ConditionAST *node, ConditionAST *pattern)

{

    (void) node;

    (void) pattern;

    if (! pattern->type_specifier_list)

        pattern->type_specifier_list = node->type_specifier_list;

    else if (! AST::match(node->type_specifier_list, pattern->type_specifier_list, this))

        return false;

    if (! pattern->declarator)

        pattern->declarator = node->declarator;

    else if (! AST::match(node->declarator, pattern->declarator, this))

        return false;

    return true;

}

bool ASTMatcher::match(ConditionalExpressionAST *node, ConditionalExpressionAST *pattern)

{

    (void) node;

    (void) pattern;

    if (! pattern->condition)

        pattern->condition = node->condition;

    else if (! AST::match(node->condition, pattern->condition, this))

        return false;

    pattern->question_token = node->question_token;

    if (! pattern->left_expression)

        pattern->left_expression = node->left_expression;

    else if (! AST::match(node->left_expression, pattern->left_expression, this))

        return false;

    pattern->colon_token = node->colon_token;

    if (! pattern->right_expression)

        pattern->right_expression = node->right_expression;