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

**

** Copyright (C) 2001-2004 Roberto Raggi

** 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 qt3to4 porting application of the Qt Toolkit.

**

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

**

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

#ifndef AST_H

#define AST_H

#include "smallobject.h"

#include "list.h"

QT_BEGIN_NAMESPACE

class AST;

class NameAST;

class TypeIdAST;

class TypeSpecifierAST;

class DeclaratorAST;

class Symbol;

class Scope;

enum NodeType

{

    NodeType_Generic = 0,

    NodeType_TemplateArgumentList = 1000,

    NodeType_ClassOrNamespaceName,

    NodeType_Name,

    NodeType_Declaration,

    NodeType_TypeSpecifier,

    NodeType_BaseSpecifier,

    NodeType_BaseClause,

    NodeType_ClassSpecifier,

    NodeType_Enumerator,

    NodeType_EnumSpecifier,

    NodeType_ElaboratedTypeSpecifier,

    NodeType_LinkageBody,

    NodeType_LinkageSpecification,

    NodeType_Namespace,

    NodeType_NamespaceAlias,

    NodeType_Using,

    NodeType_UsingDirective,

    NodeType_InitDeclaratorList,

    NodeType_Typedef,

    NodeType_Declarator,

    NodeType_InitDeclarator,

    NodeType_TemplateDeclaration,

    NodeType_SimpleDeclaration,

    NodeType_Statement,

    NodeType_StatementList,

    NodeType_IfStatement,

    NodeType_WhileStatement,

    NodeType_DoStatement,

    NodeType_ForStatement,

    NodeType_SwitchStatement,

    NodeType_DeclarationStatement,

    NodeType_LabeledStatement,

    NodeType_ReturnStatement,

    NodeType_TranslationUnit,

    NodeType_FunctionDefinition,

    NodeType_ExpressionStatement,

    NodeType_ParameterDeclaration,

    NodeType_ParameterDeclarationList,

    NodeType_ParameterDeclarationClause,

    NodeType_AccessDeclaration,

    NodeType_TypeParameter,

    NodeType_TemplateParameter,

    NodeType_TemplateParameterList,

    NodeType_Condition,

    NodeType_TypeId,

    NodeType_Expression = 2000,

    NodeType_BinaryExpression,

    NodeType_PrimaryExpression,

//

// postfix expression

//

    NodeType_PostfixExpression,

    NodeType_Subscripting,

    NodeType_FunctionCall,

    NodeType_ExplicitTypeConversion,

    NodeType_PseudoConstructorCall,

    NodeType_ClassMemberAccess,

    NodeType_IncrDecr,

    NodeType_CppCastExpression,

    NodeType_TypeIdentification,

    NodeType_UnaryExpression,

    NodeType_NewExpression,

    NodeType_NewTypeId,

    NodeType_NewDeclarator,

    NodeType_NewInitializer,

    NodeType_DeleteExpression,

    NodeType_CastExpression,

    NodeType_ConditionalExpression,

    NodeType_ThrowExpression,

    NodeType_Custom = 3000

};

template <typename T>

inline int length(List<T> *e)

{

    return e ? e->size() : 0;

}

class AST

{

public:

    enum { Type=NodeType_Generic };

    pool *_pool;

    static int N;

public:

    AST(int startToken=0, int count=1);

    virtual ~AST() { --N; }

    inline int startToken() const

    { return m_startToken; }

    inline int endToken() const

    { return m_endToken; }

    inline void setPosition(int startToken, int endToken)

    {

        m_startToken = startToken;

        m_endToken = endToken;

    }

    inline int nodeType() const

    { return m_nodeType; }

    inline void setNodeType(int nodeType)

    { m_nodeType = nodeType; }

    inline AST *parent() const

    { return m_parent; }

    void setParent(AST *parent);

    inline List<AST *> *children() const

    { return m_children; }

    void appendChild(AST *child);

    void removeChild(AST *child);

// ### move

    inline Scope *scope() const

    {

        if (m_scope)

            return m_scope;

        return m_parent ? m_parent->scope() : 0;

    }

    inline void setScope(Scope *scope)

    { m_scope = scope; }

private:

    Scope *m_scope;

    int m_nodeType;

    int m_startToken;

    int m_endToken;

    AST *m_parent;

    List<AST *> *m_children;

private:

    AST(const AST &source);

    void operator = (const AST &source);

};

class AbstractExpressionAST: public AST

{

public:

    enum { Type = NodeType_Expression };

    AbstractExpressionAST();

    inline Symbol *symbol() const

    { return m_symbol; }

    inline void setSymbol(Symbol *symbol)

    { m_symbol = symbol; }

private:

    Symbol *m_symbol;

};

// ### remove me

template <int kind, class Base = AbstractExpressionAST>

class ExpressionAST: public Base

{

public:

    enum { Type = kind };

public:

    inline ExpressionAST() {}

private:

    ExpressionAST(const ExpressionAST &source);

    void operator = (const ExpressionAST &source);

};

class BinaryExpressionAST: public AbstractExpressionAST

{

public:

    enum { Type = NodeType_BinaryExpression };

public:

    BinaryExpressionAST();

    inline AST *op() const

    { return m_op; }

    inline AbstractExpressionAST *leftExpression() const

    { return m_left; }

    inline AbstractExpressionAST *rightExpression() const

    { return m_right; }

    void setOp(AST *op);

    void setLeftExpression(AbstractExpressionAST *left);

    void setRightExpression(AbstractExpressionAST *right);

private:

    AST *m_op;

    AbstractExpressionAST *m_left;

    AbstractExpressionAST *m_right;

private:

    BinaryExpressionAST(const BinaryExpressionAST &source);

    void operator = (const BinaryExpressionAST &source);

};

class ConditionalExpressionAST: public AbstractExpressionAST

{

public:

    enum { Type = NodeType_ConditionalExpression };

public:

    ConditionalExpressionAST();

    inline AbstractExpressionAST *condition() const

    { return m_condition; }

    inline AbstractExpressionAST *leftExpression() const

    { return m_left; }

    inline AbstractExpressionAST *rightExpression() const

    { return m_right; }

    void setCondition(AbstractExpressionAST *condition);

    void setLeftExpression(AbstractExpressionAST *left);

    void setRightExpression(AbstractExpressionAST *right);

private:

    AbstractExpressionAST *m_condition;

    AbstractExpressionAST *m_left;

    AbstractExpressionAST *m_right;

private:

    ConditionalExpressionAST(const ConditionalExpressionAST& source);

    void operator = (const ConditionalExpressionAST &source);

};

//

// postfix expression

//

class SubscriptingAST: public AbstractExpressionAST

{

public:

    enum { Type = NodeType_Subscripting };

public:

    SubscriptingAST();

    inline AbstractExpressionAST *expression() const

    { return m_expression; }

    inline AbstractExpressionAST *subscript() const

    { return m_subscript; }

    void setExpression(AbstractExpressionAST *expression);

    void setSubscript(AbstractExpressionAST *subscript);

private:

    AbstractExpressionAST *m_expression;

    AbstractExpressionAST *m_subscript;

private:

    SubscriptingAST(const SubscriptingAST &source);

    void operator = (const SubscriptingAST &source);

};

class FunctionCallAST: public AbstractExpressionAST

{

public:

    enum { Type = NodeType_FunctionCall };

public:

    FunctionCallAST();

    inline AbstractExpressionAST *expression() const

    { return m_expression; }

    inline AbstractExpressionAST *arguments() const

    { return m_arguments; }

    void setExpression(AbstractExpressionAST *expression);

    void setArguments(AbstractExpressionAST *arguments);

private:

    AbstractExpressionAST *m_expression;

    AbstractExpressionAST *m_arguments;

private:

    FunctionCallAST(const FunctionCallAST &source);

    void operator = (const FunctionCallAST &source);

};

class ExplicitTypeConversionAST: public AbstractExpressionAST

{

public:

    enum { Type = NodeType_ExplicitTypeConversion };

public:

    ExplicitTypeConversionAST();

private:

    ExplicitTypeConversionAST(const ExplicitTypeConversionAST &source);

    void operator = (const ExplicitTypeConversionAST &source);

};

class PseudoDestructorCallAST: public AbstractExpressionAST

{

public:

    enum { Type = NodeType_PseudoConstructorCall };

public:

    PseudoDestructorCallAST();

private:

    PseudoDestructorCallAST(const PseudoDestructorCallAST &source);

    void operator = (const PseudoDestructorCallAST &source);

};

class ClassMemberAccessAST: public AbstractExpressionAST

{

public:

    enum { Type = NodeType_ClassMemberAccess };

public:

    ClassMemberAccessAST();

    inline AST *op() const

    { return m_op; }

    inline AbstractExpressionAST *expression() const

    { return m_expression; }

    inline NameAST *name() const

    { return m_name; }

    void setOp(AST *op);

    void setExpression(AbstractExpressionAST *expression);

    void setName(NameAST *name);

private:

    AST *m_op;

    AbstractExpressionAST *m_expression;

    AST *m_templ;

    NameAST *m_name;

private:

    ClassMemberAccessAST(const ClassMemberAccessAST &source);

    void operator = (const ClassMemberAccessAST &source);

};

class IncrDecrAST: public AbstractExpressionAST

{

public:

    enum { Type = NodeType_IncrDecr };

public:

    IncrDecrAST();

    inline AST *op() const

    { return m_op; }

    inline AbstractExpressionAST *expression() const

    { return m_expression; }

    void setOp(AST *op);

    void setExpression(AbstractExpressionAST *expression);

private:

    AST *m_op;

    AbstractExpressionAST *m_expression;

private:

    IncrDecrAST(const IncrDecrAST &source);

    void operator = (const IncrDecrAST &source);

};

class CppCastExpressionAST: public AbstractExpressionAST

{

public:

    enum { Type = NodeType_CppCastExpression };

public:

    CppCastExpressionAST();

    inline AST *castOp() const

    { return m_castOp; }

    inline AST *typeId() const

    { return m_typeId; }

    inline AbstractExpressionAST *expression() const

    { return m_expression; }

    void setCastOp(AST *castOp);

    void setTypeId(AST *typeId);

    void setExpression(AbstractExpressionAST *expression);

private:

    AST *m_castOp;

    AST *m_typeId;

    AbstractExpressionAST *m_expression;

private:

    CppCastExpressionAST(const CppCastExpressionAST &source);

    void operator = (const CppCastExpressionAST &source);

};

class TypeIdentificationAST: public AbstractExpressionAST

{

public:

    enum { Type = NodeType_TypeIdentification };

public:

    TypeIdentificationAST();

private:

    TypeIdentificationAST(const TypeIdentificationAST &source);

    void operator = (const TypeIdentificationAST &source);

};

class TypeIdAST: public AST

{

public:

    enum { Type = NodeType_TypeId };

public:

    TypeIdAST();

    inline TypeSpecifierAST *typeSpecifier() const

    { return m_typeSpecifier; }

    inline DeclaratorAST *declarator() const

    { return m_declarator; }

    void setTypeSpecifier(TypeSpecifierAST *typeSpecifier);

    void setDeclarator(DeclaratorAST *declarator);

private:

    TypeSpecifierAST *m_typeSpecifier;

    DeclaratorAST *m_declarator;

private:

    TypeIdAST(const TypeIdAST &source);

    void operator = (const TypeIdAST &source);

};

class StatementAST: public AST

{

public:

    enum { Type = NodeType_Statement };

};

class TemplateArgumentListAST: public AST

{

public: