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

**

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

**

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

// Copyright (c) 2008 Roberto Raggi <roberto.raggi@gmail.com>

//

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to deal

// in the Software without restriction, including without limitation the rights

// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

// copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in

// all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

// THE SOFTWARE.

#ifndef CPLUSPLUS_AST_H

#define CPLUSPLUS_AST_H

#include "CPlusPlusForwardDeclarations.h"

#include "ASTfwd.h"

#include "MemoryPool.h"

namespace CPlusPlus {

template <typename _Tp>

class CPLUSPLUS_EXPORT List: public Managed

{

    List(const List &other);

    void operator =(const List &other);

public:

    List()

        : value(_Tp()), next(0)

    { }

    List(const _Tp &value)

        : value(value), next(0)

    { }

    unsigned firstToken() const

    {

        if (value)

            return value->firstToken();

        // ### assert(0);

        return 0;

    }

    unsigned lastToken() const

    {

        _Tp lastValue = 0;

        for (const List *it = this; it; it = it->next) {

            if (it->value)

                lastValue = it->value;

        }

        if (lastValue)

            return lastValue->lastToken();

        // ### assert(0);

        return 0;

    }

    _Tp value;

    List *next;

};

class CPLUSPLUS_EXPORT AST: public Managed

{

    AST(const AST &other);

    void operator =(const AST &other);

public:

    AST();

    virtual ~AST();

    void accept(ASTVisitor *visitor);

    static void accept(AST *ast, ASTVisitor *visitor)

    { if (ast) ast->accept(visitor); }

    template <typename _Tp>

    static void accept(List<_Tp> *it, ASTVisitor *visitor)

    {

        for (; it; it = it->next)

            accept(it->value, visitor);

    }

    static bool match(AST *ast, AST *pattern, ASTMatcher *matcher);

    bool match(AST *pattern, ASTMatcher *matcher);

    template <typename _Tp>

    static bool match(List<_Tp> *it, List<_Tp> *patternIt, ASTMatcher *matcher)

    {

        while (it && patternIt) {

            if (! match(it->value, patternIt->value, matcher))

                return false;

            it = it->next;

            patternIt = patternIt->next;

        }

        if (! it && ! patternIt)

            return true;

        return false;

    }

    virtual unsigned firstToken() const = 0;

    virtual unsigned lastToken() const = 0;

    virtual AST *clone(MemoryPool *pool) const = 0;

    virtual AccessDeclarationAST *asAccessDeclaration() { return 0; }

    virtual ArrayAccessAST *asArrayAccess() { return 0; }

    virtual ArrayDeclaratorAST *asArrayDeclarator() { return 0; }

    virtual ArrayInitializerAST *asArrayInitializer() { return 0; }

    virtual AsmDefinitionAST *asAsmDefinition() { return 0; }

    virtual AttributeAST *asAttribute() { return 0; }

    virtual AttributeSpecifierAST *asAttributeSpecifier() { return 0; }

    virtual BaseSpecifierAST *asBaseSpecifier() { return 0; }

    virtual BinaryExpressionAST *asBinaryExpression() { return 0; }

    virtual BoolLiteralAST *asBoolLiteral() { return 0; }

    virtual BreakStatementAST *asBreakStatement() { return 0; }

    virtual CallAST *asCall() { return 0; }

    virtual CaseStatementAST *asCaseStatement() { return 0; }

    virtual CastExpressionAST *asCastExpression() { return 0; }

    virtual CatchClauseAST *asCatchClause() { return 0; }

    virtual ClassSpecifierAST *asClassSpecifier() { return 0; }

    virtual CompoundLiteralAST *asCompoundLiteral() { return 0; }

    virtual CompoundStatementAST *asCompoundStatement() { return 0; }

    virtual ConditionAST *asCondition() { return 0; }

    virtual ConditionalExpressionAST *asConditionalExpression() { return 0; }

    virtual ContinueStatementAST *asContinueStatement() { return 0; }

    virtual ConversionFunctionIdAST *asConversionFunctionId() { return 0; }

    virtual CoreDeclaratorAST *asCoreDeclarator() { return 0; }

    virtual CppCastExpressionAST *asCppCastExpression() { return 0; }

    virtual CtorInitializerAST *asCtorInitializer() { return 0; }

    virtual DeclarationAST *asDeclaration() { return 0; }

    virtual DeclarationStatementAST *asDeclarationStatement() { return 0; }

    virtual DeclaratorAST *asDeclarator() { return 0; }

    virtual DeclaratorIdAST *asDeclaratorId() { return 0; }

    virtual DeleteExpressionAST *asDeleteExpression() { return 0; }

    virtual DestructorNameAST *asDestructorName() { return 0; }

    virtual DoStatementAST *asDoStatement() { return 0; }

    virtual ElaboratedTypeSpecifierAST *asElaboratedTypeSpecifier() { return 0; }

    virtual EmptyDeclarationAST *asEmptyDeclaration() { return 0; }

    virtual EnumSpecifierAST *asEnumSpecifier() { return 0; }

    virtual EnumeratorAST *asEnumerator() { return 0; }

    virtual ExceptionDeclarationAST *asExceptionDeclaration() { return 0; }

    virtual ExceptionSpecificationAST *asExceptionSpecification() { return 0; }

    virtual ExpressionAST *asExpression() { return 0; }

    virtual ExpressionOrDeclarationStatementAST *asExpressionOrDeclarationStatement() { return 0; }

    virtual ExpressionStatementAST *asExpressionStatement() { return 0; }

    virtual ForStatementAST *asForStatement() { return 0; }

    virtual ForeachStatementAST *asForeachStatement() { return 0; }

    virtual FunctionDeclaratorAST *asFunctionDeclarator() { return 0; }

    virtual FunctionDefinitionAST *asFunctionDefinition() { return 0; }

    virtual GotoStatementAST *asGotoStatement() { return 0; }

    virtual IfStatementAST *asIfStatement() { return 0; }

    virtual LabeledStatementAST *asLabeledStatement() { return 0; }

    virtual LinkageBodyAST *asLinkageBody() { return 0; }

    virtual LinkageSpecificationAST *asLinkageSpecification() { return 0; }

    virtual MemInitializerAST *asMemInitializer() { return 0; }

    virtual MemberAccessAST *asMemberAccess() { return 0; }

    virtual NameAST *asName() { return 0; }

    virtual NamedTypeSpecifierAST *asNamedTypeSpecifier() { return 0; }

    virtual NamespaceAST *asNamespace() { return 0; }

    virtual NamespaceAliasDefinitionAST *asNamespaceAliasDefinition() { return 0; }

    virtual NestedDeclaratorAST *asNestedDeclarator() { return 0; }

    virtual NestedExpressionAST *asNestedExpression() { return 0; }

    virtual NestedNameSpecifierAST *asNestedNameSpecifier() { return 0; }

    virtual NewArrayDeclaratorAST *asNewArrayDeclarator() { return 0; }

    virtual NewExpressionAST *asNewExpression() { return 0; }

    virtual NewInitializerAST *asNewInitializer() { return 0; }

    virtual NewPlacementAST *asNewPlacement() { return 0; }

    virtual NewTypeIdAST *asNewTypeId() { return 0; }

    virtual NumericLiteralAST *asNumericLiteral() { return 0; }

    virtual ObjCClassDeclarationAST *asObjCClassDeclaration() { return 0; }

    virtual ObjCClassForwardDeclarationAST *asObjCClassForwardDeclaration() { return 0; }

    virtual ObjCDynamicPropertiesDeclarationAST *asObjCDynamicPropertiesDeclaration() { return 0; }

    virtual ObjCEncodeExpressionAST *asObjCEncodeExpression() { return 0; }

    virtual ObjCFastEnumerationAST *asObjCFastEnumeration() { return 0; }

    virtual ObjCInstanceVariablesDeclarationAST *asObjCInstanceVariablesDeclaration() { return 0; }

    virtual ObjCMessageArgumentAST *asObjCMessageArgument() { return 0; }

    virtual ObjCMessageArgumentDeclarationAST *asObjCMessageArgumentDeclaration() { return 0; }

    virtual ObjCMessageExpressionAST *asObjCMessageExpression() { return 0; }

    virtual ObjCMethodDeclarationAST *asObjCMethodDeclaration() { return 0; }

    virtual ObjCMethodPrototypeAST *asObjCMethodPrototype() { return 0; }

    virtual ObjCPropertyAttributeAST *asObjCPropertyAttribute() { return 0; }

    virtual ObjCPropertyDeclarationAST *asObjCPropertyDeclaration() { return 0; }

    virtual ObjCProtocolDeclarationAST *asObjCProtocolDeclaration() { return 0; }

    virtual ObjCProtocolExpressionAST *asObjCProtocolExpression() { return 0; }

    virtual ObjCProtocolForwardDeclarationAST *asObjCProtocolForwardDeclaration() { return 0; }

    virtual ObjCProtocolRefsAST *asObjCProtocolRefs() { return 0; }

    virtual ObjCSelectorAST *asObjCSelector() { return 0; }

    virtual ObjCSelectorArgumentAST *asObjCSelectorArgument() { return 0; }

    virtual ObjCSelectorExpressionAST *asObjCSelectorExpression() { return 0; }

    virtual ObjCSelectorWithArgumentsAST *asObjCSelectorWithArguments() { return 0; }

    virtual ObjCSelectorWithoutArgumentsAST *asObjCSelectorWithoutArguments() { return 0; }

    virtual ObjCSynchronizedStatementAST *asObjCSynchronizedStatement() { return 0; }

    virtual ObjCSynthesizedPropertiesDeclarationAST *asObjCSynthesizedPropertiesDeclaration() { return 0; }

    virtual ObjCSynthesizedPropertyAST *asObjCSynthesizedProperty() { return 0; }

    virtual ObjCTypeNameAST *asObjCTypeName() { return 0; }

    virtual ObjCVisibilityDeclarationAST *asObjCVisibilityDeclaration() { return 0; }

    virtual OperatorAST *asOperator() { return 0; }

    virtual OperatorFunctionIdAST *asOperatorFunctionId() { return 0; }

    virtual ParameterDeclarationAST *asParameterDeclaration() { return 0; }

    virtual ParameterDeclarationClauseAST *asParameterDeclarationClause() { return 0; }

    virtual PointerAST *asPointer() { return 0; }

    virtual PointerToMemberAST *asPointerToMember() { return 0; }

    virtual PostIncrDecrAST *asPostIncrDecr() { return 0; }

    virtual PostfixAST *asPostfix() { return 0; }

    virtual PostfixDeclaratorAST *asPostfixDeclarator() { return 0; }

    virtual PostfixExpressionAST *asPostfixExpression() { return 0; }

    virtual PtrOperatorAST *asPtrOperator() { return 0; }

    virtual QtMemberDeclarationAST *asQtMemberDeclaration() { return 0; }

    virtual QtMethodAST *asQtMethod() { return 0; }

    virtual QualifiedNameAST *asQualifiedName() { return 0; }

    virtual ReferenceAST *asReference() { return 0; }

    virtual ReturnStatementAST *asReturnStatement() { return 0; }

    virtual SimpleDeclarationAST *asSimpleDeclaration() { return 0; }

    virtual SimpleNameAST *asSimpleName() { return 0; }

    virtual SimpleSpecifierAST *asSimpleSpecifier() { return 0; }

    virtual SizeofExpressionAST *asSizeofExpression() { return 0; }

    virtual SpecifierAST *asSpecifier() { return 0; }

    virtual StatementAST *asStatement() { return 0; }

    virtual StringLiteralAST *asStringLiteral() { return 0; }

    virtual SwitchStatementAST *asSwitchStatement() { return 0; }

    virtual TemplateDeclarationAST *asTemplateDeclaration() { return 0; }

    virtual TemplateIdAST *asTemplateId() { return 0; }

    virtual TemplateTypeParameterAST *asTemplateTypeParameter() { return 0; }

    virtual ThisExpressionAST *asThisExpression() { return 0; }

    virtual ThrowExpressionAST *asThrowExpression() { return 0; }

    virtual TranslationUnitAST *asTranslationUnit() { return 0; }

    virtual TryBlockStatementAST *asTryBlockStatement() { return 0; }

    virtual TypeConstructorCallAST *asTypeConstructorCall() { return 0; }

    virtual TypeIdAST *asTypeId() { return 0; }

    virtual TypeidExpressionAST *asTypeidExpression() { return 0; }

    virtual TypenameCallExpressionAST *asTypenameCallExpression() { return 0; }

    virtual TypenameTypeParameterAST *asTypenameTypeParameter() { return 0; }

    virtual TypeofSpecifierAST *asTypeofSpecifier() { return 0; }

    virtual UnaryExpressionAST *asUnaryExpression() { return 0; }

    virtual UsingAST *asUsing() { return 0; }

    virtual UsingDirectiveAST *asUsingDirective() { return 0; }

    virtual WhileStatementAST *asWhileStatement() { return 0; }

#ifdef ICHECK_BUILD

    virtual QPropertyDeclarationAST *asQPropertyDeclarationAST() { return 0; }

    virtual QEnumDeclarationAST *asQEnumDeclarationAST() { return 0; }

    virtual QFlagsDeclarationAST *asQFlagsDeclarationAST() { return 0; }

    virtual QDeclareFlagsDeclarationAST *asQDeclareFlagsDeclarationAST() { return 0; }

#endif

protected:

    virtual void accept0(ASTVisitor *visitor) = 0;

    virtual bool match0(AST *, ASTMatcher *) = 0;

};

class CPLUSPLUS_EXPORT StatementAST: public AST

{

public:

    virtual StatementAST *asStatement() { return this; }

    virtual StatementAST *clone(MemoryPool *pool) const = 0;

};

class CPLUSPLUS_EXPORT ExpressionAST: public AST

{

public:

    virtual ExpressionAST *asExpression() { return this; }

    virtual ExpressionAST *clone(MemoryPool *pool) const = 0;

};

class CPLUSPLUS_EXPORT DeclarationAST: public AST

{

public:

    virtual DeclarationAST *asDeclaration() { return this; }

    virtual DeclarationAST *clone(MemoryPool *pool) const = 0;

#ifdef ICHECK_BUILD

    unsigned invoke_token;

#endif

};

class CPLUSPLUS_EXPORT NameAST: public ExpressionAST

{

public: // annotations

    const Name *name;

public:

    virtual NameAST *asName() { return this; }

    virtual NameAST *clone(MemoryPool *pool) const = 0;

};

class CPLUSPLUS_EXPORT SpecifierAST: public AST

{

public:

    virtual SpecifierAST *asSpecifier() { return this; }

    virtual SpecifierAST *clone(MemoryPool *pool) const = 0;

};

class CPLUSPLUS_EXPORT PtrOperatorAST: public AST

{

public:

    virtual PtrOperatorAST *asPtrOperator() { return this; }

    virtual PtrOperatorAST *clone(MemoryPool *pool) const = 0;

};

class CPLUSPLUS_EXPORT PostfixAST: public AST

{

public:

    virtual PostfixAST *asPostfix() { return this; }

    virtual PostfixAST *clone(MemoryPool *pool) const = 0;

};

class CPLUSPLUS_EXPORT CoreDeclaratorAST: public AST

{

public:

    virtual CoreDeclaratorAST *asCoreDeclarator() { return this; }

    virtual CoreDeclaratorAST *clone(MemoryPool *pool) const = 0;

};

class CPLUSPLUS_EXPORT PostfixDeclaratorAST: public AST

{

public:

    virtual PostfixDeclaratorAST *asPostfixDeclarator() { return this; }

    virtual PostfixDeclaratorAST *clone(MemoryPool *pool) const = 0;

};

class CPLUSPLUS_EXPORT ObjCSelectorAST: public AST

{

public: // annotation

    const Name *selector_name;

public:

    virtual ObjCSelectorAST *asObjCSelector() { return this; }

    virtual ObjCSelectorAST *clone(MemoryPool *pool) const = 0;

};

class CPLUSPLUS_EXPORT SimpleSpecifierAST: public SpecifierAST

{

public:

    unsigned specifier_token;

public:

    virtual SimpleSpecifierAST *asSimpleSpecifier() { return this; }

    virtual unsigned firstToken() const;

    virtual unsigned lastToken() const;

    virtual SimpleSpecifierAST *clone(MemoryPool *pool) const;

protected:

    virtual void accept0(ASTVisitor *visitor);

    virtual bool match0(AST *, ASTMatcher *);

};

class CPLUSPLUS_EXPORT AttributeSpecifierAST: public SpecifierAST

{

public:

    unsigned attribute_token;

    unsigned first_lparen_token;

    unsigned second_lparen_token;

    AttributeListAST *attribute_list;

    unsigned first_rparen_token;

    unsigned second_rparen_token;

public:

    virtual AttributeSpecifierAST *asAttributeSpecifier() { return this; }

    virtual unsigned firstToken() const;

    virtual unsigned lastToken() const;

    virtual AttributeSpecifierAST *clone(MemoryPool *pool) const;

protected:

    virtual void accept0(ASTVisitor *visitor);

    virtual bool match0(AST *, ASTMatcher *);

};

class CPLUSPLUS_EXPORT AttributeAST: public AST

{

public:

    unsigned identifier_token;

    unsigned lparen_token;

    unsigned tag_token;

    ExpressionListAST *expression_list;

    unsigned rparen_token;

public:

    virtual AttributeAST *asAttribute() { return this; }

    virtual unsigned firstToken() const;

    virtual unsigned lastToken() const;

    virtual AttributeAST *clone(MemoryPool *pool) const;

protected:

    virtual void accept0(ASTVisitor *visitor);

    virtual bool match0(AST *, ASTMatcher *);

};

class CPLUSPLUS_EXPORT TypeofSpecifierAST: public SpecifierAST

{

public:

    unsigned typeof_token;

    unsigned lparen_token;

    ExpressionAST *expression;

    unsigned rparen_token;

public:

    virtual TypeofSpecifierAST *asTypeofSpecifier() { return this; }

    virtual unsigned firstToken() const;

    virtual unsigned lastToken() const;

    virtual TypeofSpecifierAST *clone(MemoryPool *pool) const;

protected:

    virtual void accept0(ASTVisitor *visitor);

    virtual bool match0(AST *, ASTMatcher *);

};

class CPLUSPLUS_EXPORT DeclaratorAST: public AST

{

public:

    SpecifierListAST *attribute_list;

    PtrOperatorListAST *ptr_operator_list;

    CoreDeclaratorAST *core_declarator;

    PostfixDeclaratorListAST *postfix_declarator_list;

    SpecifierListAST *post_attribute_list;

    unsigned equals_token;

    ExpressionAST *initializer;

public:

    virtual DeclaratorAST *asDeclarator() { return this; }

    virtual unsigned firstToken() const;

    virtual unsigned lastToken() const;

    virtual DeclaratorAST *clone(MemoryPool *pool) const;

protected:

    virtual void accept0(ASTVisitor *visitor);

    virtual bool match0(AST *, ASTMatcher *);

};

class CPLUSPLUS_EXPORT SimpleDeclarationAST: public DeclarationAST

{

public:

    unsigned qt_invokable_token;

    SpecifierListAST *decl_specifier_list;

    DeclaratorListAST *declarator_list;

    unsigned semicolon_token;

public:

    List<Declaration *> *symbols;

public:

    virtual SimpleDeclarationAST *asSimpleDeclaration() { return this; }

    virtual unsigned firstToken() const;

    virtual unsigned lastToken() const;

    virtual SimpleDeclarationAST *clone(MemoryPool *pool) const;

protected:

    virtual void accept0(ASTVisitor *visitor);

    virtual bool match0(AST *, ASTMatcher *);

};

class CPLUSPLUS_EXPORT EmptyDeclarationAST: public DeclarationAST

{