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

**

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

using namespace CPlusPlus;

bool SimpleSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (SimpleSpecifierAST *_other = pattern->asSimpleSpecifier())

        return matcher->match(this, _other);

    return false;

}

bool AttributeSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (AttributeSpecifierAST *_other = pattern->asAttributeSpecifier())

        return matcher->match(this, _other);

    return false;

}

bool AttributeAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (AttributeAST *_other = pattern->asAttribute())

        return matcher->match(this, _other);

    return false;

}

bool TypeofSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (TypeofSpecifierAST *_other = pattern->asTypeofSpecifier())

        return matcher->match(this, _other);

    return false;

}

bool DeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (DeclaratorAST *_other = pattern->asDeclarator())

        return matcher->match(this, _other);

    return false;

}

bool SimpleDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (SimpleDeclarationAST *_other = pattern->asSimpleDeclaration())

        return matcher->match(this, _other);

    return false;

}

bool EmptyDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (EmptyDeclarationAST *_other = pattern->asEmptyDeclaration())

        return matcher->match(this, _other);

    return false;

}

bool AccessDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (AccessDeclarationAST *_other = pattern->asAccessDeclaration())

        return matcher->match(this, _other);

    return false;

}

#ifdef ICHECK_BUILD

bool QPropertyDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (QPropertyDeclarationAST *_other = pattern->asQPropertyDeclarationAST())

        return matcher->match(this, _other);

    return false;

}

bool QEnumDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (QEnumDeclarationAST *_other = pattern->asQEnumDeclarationAST())

        return matcher->match(this, _other);

    return false;

}

bool QFlagsDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (QFlagsDeclarationAST *_other = pattern->asQFlagsDeclarationAST())

        return matcher->match(this, _other);

    return false;

}

bool QDeclareFlagsDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (QDeclareFlagsDeclarationAST *_other = pattern->asQDeclareFlagsDeclarationAST())

        return matcher->match(this, _other);

    return false;

}

#endif

bool AsmDefinitionAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (AsmDefinitionAST *_other = pattern->asAsmDefinition())

        return matcher->match(this, _other);

    return false;

}

bool BaseSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (BaseSpecifierAST *_other = pattern->asBaseSpecifier())

        return matcher->match(this, _other);

    return false;

}

bool CompoundLiteralAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (CompoundLiteralAST *_other = pattern->asCompoundLiteral())

        return matcher->match(this, _other);

    return false;

}

bool QtMethodAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (QtMethodAST *_other = pattern->asQtMethod())

        return matcher->match(this, _other);

    return false;

}

bool QtMemberDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (QtMemberDeclarationAST *_other = pattern->asQtMemberDeclaration())

        return matcher->match(this, _other);

    return false;

}

bool BinaryExpressionAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (BinaryExpressionAST *_other = pattern->asBinaryExpression())

        return matcher->match(this, _other);

    return false;

}

bool CastExpressionAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (CastExpressionAST *_other = pattern->asCastExpression())

        return matcher->match(this, _other);

    return false;

}

bool ClassSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ClassSpecifierAST *_other = pattern->asClassSpecifier())

        return matcher->match(this, _other);

    return false;

}

bool CaseStatementAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (CaseStatementAST *_other = pattern->asCaseStatement())

        return matcher->match(this, _other);

    return false;

}

bool CompoundStatementAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (CompoundStatementAST *_other = pattern->asCompoundStatement())

        return matcher->match(this, _other);

    return false;

}

bool ConditionAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ConditionAST *_other = pattern->asCondition())

        return matcher->match(this, _other);

    return false;

}

bool ConditionalExpressionAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ConditionalExpressionAST *_other = pattern->asConditionalExpression())

        return matcher->match(this, _other);

    return false;

}

bool CppCastExpressionAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (CppCastExpressionAST *_other = pattern->asCppCastExpression())

        return matcher->match(this, _other);

    return false;

}

bool CtorInitializerAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (CtorInitializerAST *_other = pattern->asCtorInitializer())

        return matcher->match(this, _other);

    return false;

}

bool DeclarationStatementAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (DeclarationStatementAST *_other = pattern->asDeclarationStatement())

        return matcher->match(this, _other);

    return false;

}

bool DeclaratorIdAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (DeclaratorIdAST *_other = pattern->asDeclaratorId())

        return matcher->match(this, _other);

    return false;

}

bool NestedDeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (NestedDeclaratorAST *_other = pattern->asNestedDeclarator())

        return matcher->match(this, _other);

    return false;

}

bool FunctionDeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (FunctionDeclaratorAST *_other = pattern->asFunctionDeclarator())

        return matcher->match(this, _other);

    return false;

}

bool ArrayDeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ArrayDeclaratorAST *_other = pattern->asArrayDeclarator())

        return matcher->match(this, _other);

    return false;

}

bool DeleteExpressionAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (DeleteExpressionAST *_other = pattern->asDeleteExpression())

        return matcher->match(this, _other);

    return false;

}

bool DoStatementAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (DoStatementAST *_other = pattern->asDoStatement())

        return matcher->match(this, _other);

    return false;

}

bool NamedTypeSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (NamedTypeSpecifierAST *_other = pattern->asNamedTypeSpecifier())

        return matcher->match(this, _other);

    return false;

}

bool ElaboratedTypeSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ElaboratedTypeSpecifierAST *_other = pattern->asElaboratedTypeSpecifier())

        return matcher->match(this, _other);

    return false;

}

bool EnumSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (EnumSpecifierAST *_other = pattern->asEnumSpecifier())

        return matcher->match(this, _other);

    return false;

}

bool EnumeratorAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (EnumeratorAST *_other = pattern->asEnumerator())

        return matcher->match(this, _other);

    return false;

}

bool ExceptionDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ExceptionDeclarationAST *_other = pattern->asExceptionDeclaration())

        return matcher->match(this, _other);

    return false;

}

bool ExceptionSpecificationAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ExceptionSpecificationAST *_other = pattern->asExceptionSpecification())

        return matcher->match(this, _other);

    return false;

}

bool ExpressionOrDeclarationStatementAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ExpressionOrDeclarationStatementAST *_other = pattern->asExpressionOrDeclarationStatement())

        return matcher->match(this, _other);

    return false;

}

bool ExpressionStatementAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ExpressionStatementAST *_other = pattern->asExpressionStatement())

        return matcher->match(this, _other);

    return false;

}

bool FunctionDefinitionAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (FunctionDefinitionAST *_other = pattern->asFunctionDefinition())

        return matcher->match(this, _other);

    return false;

}

bool ForeachStatementAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ForeachStatementAST *_other = pattern->asForeachStatement())

        return matcher->match(this, _other);

    return false;

}

bool ForStatementAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ForStatementAST *_other = pattern->asForStatement())

        return matcher->match(this, _other);

    return false;

}

bool IfStatementAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (IfStatementAST *_other = pattern->asIfStatement())

        return matcher->match(this, _other);

    return false;

}

bool ArrayInitializerAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ArrayInitializerAST *_other = pattern->asArrayInitializer())

        return matcher->match(this, _other);

    return false;

}

bool LabeledStatementAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (LabeledStatementAST *_other = pattern->asLabeledStatement())

        return matcher->match(this, _other);

    return false;

}

bool LinkageBodyAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (LinkageBodyAST *_other = pattern->asLinkageBody())

        return matcher->match(this, _other);

    return false;

}

bool LinkageSpecificationAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (LinkageSpecificationAST *_other = pattern->asLinkageSpecification())

        return matcher->match(this, _other);

    return false;

}

bool MemInitializerAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (MemInitializerAST *_other = pattern->asMemInitializer())

        return matcher->match(this, _other);

    return false;

}

bool NestedNameSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (NestedNameSpecifierAST *_other = pattern->asNestedNameSpecifier())

        return matcher->match(this, _other);

    return false;

}

bool QualifiedNameAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (QualifiedNameAST *_other = pattern->asQualifiedName())

        return matcher->match(this, _other);

    return false;

}

bool OperatorFunctionIdAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (OperatorFunctionIdAST *_other = pattern->asOperatorFunctionId())

        return matcher->match(this, _other);

    return false;

}

bool ConversionFunctionIdAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (ConversionFunctionIdAST *_other = pattern->asConversionFunctionId())

        return matcher->match(this, _other);

    return false;

}

bool SimpleNameAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (SimpleNameAST *_other = pattern->asSimpleName())

        return matcher->match(this, _other);

    return false;

}

bool DestructorNameAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (DestructorNameAST *_other = pattern->asDestructorName())

        return matcher->match(this, _other);

    return false;

}

bool TemplateIdAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (TemplateIdAST *_other = pattern->asTemplateId())

        return matcher->match(this, _other);

    return false;

}

bool NamespaceAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (NamespaceAST *_other = pattern->asNamespace())

        return matcher->match(this, _other);

    return false;

}

bool NamespaceAliasDefinitionAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (NamespaceAliasDefinitionAST *_other = pattern->asNamespaceAliasDefinition())

        return matcher->match(this, _other);

    return false;

}

bool NewPlacementAST::match0(AST *pattern, ASTMatcher *matcher)

{

    if (NewPlacementAST *_other = pattern->asNewPlacement())

        return matcher->match(this, _other);

    return false;

}