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

**

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

#define CPLUSPLUS_SYMBOLS_H

#include "CPlusPlusForwardDeclarations.h"

#include "Symbol.h"

#include "Type.h"

#include "FullySpecifiedType.h"

#include "Array.h"

namespace CPlusPlus {

class TemplateParameters

{

public:

    TemplateParameters(Scope *scope);

    TemplateParameters(TemplateParameters *previous, Scope *scope);

    ~TemplateParameters();

    TemplateParameters *previous() const;

    Scope *scope() const;

private:

    TemplateParameters *_previous;

    Scope *_scope;

};

class CPLUSPLUS_EXPORT UsingNamespaceDirective: public Symbol

{

public:

    UsingNamespaceDirective(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~UsingNamespaceDirective();

    // Symbol's interface

    virtual FullySpecifiedType type() const;

    virtual const UsingNamespaceDirective *asUsingNamespaceDirective() const

    { return this; }

    virtual UsingNamespaceDirective *asUsingNamespaceDirective()

    { return this; }

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

};

class CPLUSPLUS_EXPORT UsingDeclaration: public Symbol

{

public:

    UsingDeclaration(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~UsingDeclaration();

    // Symbol's interface

    virtual FullySpecifiedType type() const;

    virtual const UsingDeclaration *asUsingDeclaration() const

    { return this; }

    virtual UsingDeclaration *asUsingDeclaration()

    { return this; }

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

};

class CPLUSPLUS_EXPORT Declaration: public Symbol

{

public:

    Declaration(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~Declaration();

    TemplateParameters *templateParameters() const;

    void setTemplateParameters(TemplateParameters *templateParameters);

    void setType(const FullySpecifiedType &type);

    // Symbol's interface

    virtual FullySpecifiedType type() const;

    virtual const Declaration *asDeclaration() const

    { return this; }

    virtual Declaration *asDeclaration()

    { return this; }

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

private:

    FullySpecifiedType _type;

    TemplateParameters *_templateParameters;

};

class CPLUSPLUS_EXPORT Argument: public Symbol

{

public:

    Argument(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~Argument();

    void setType(const FullySpecifiedType &type);

    bool hasInitializer() const;

    const StringLiteral *initializer() const;

    void setInitializer(const StringLiteral *initializer);

    // Symbol's interface

    virtual FullySpecifiedType type() const;

    virtual const Argument *asArgument() const

    { return this; }

    virtual Argument *asArgument()

    { return this; }

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

private:

    FullySpecifiedType _type;

    const StringLiteral *_initializer;

};

class CPLUSPLUS_EXPORT TypenameArgument: public Symbol

{

public:

    TypenameArgument(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~TypenameArgument();

    void setType(const FullySpecifiedType &type);

    // Symbol's interface

    virtual FullySpecifiedType type() const;

    virtual const TypenameArgument *asTypenameArgument() const

    { return this; }

    virtual TypenameArgument *asTypenameArgument()

    { return this; }

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

private:

    FullySpecifiedType _type;

};

class CPLUSPLUS_EXPORT ScopedSymbol: public Symbol

{

public:

    ScopedSymbol(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~ScopedSymbol();

    unsigned memberCount() const;

    Symbol *memberAt(unsigned index) const;

    Scope *members() const;

    void addMember(Symbol *member);

    virtual const ScopedSymbol *asScopedSymbol() const

    { return this; }

    virtual ScopedSymbol *asScopedSymbol()

    { return this; }

private:

    Scope *_members;

};

class CPLUSPLUS_EXPORT Block: public ScopedSymbol

{

public:

    Block(TranslationUnit *translationUnit, unsigned sourceLocation);

    virtual ~Block();

    // Symbol's interface

    virtual FullySpecifiedType type() const;

    virtual const Block *asBlock() const

    { return this; }

    virtual Block *asBlock()

    { return this; }

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

};

class CPLUSPLUS_EXPORT ForwardClassDeclaration: public Symbol, public Type

{

public:

    ForwardClassDeclaration(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~ForwardClassDeclaration();

    TemplateParameters *templateParameters() const;

    void setTemplateParameters(TemplateParameters *templateParameters);

    virtual FullySpecifiedType type() const;

    virtual bool isEqualTo(const Type *other) const;

    virtual const ForwardClassDeclaration *asForwardClassDeclaration() const

    { return this; }

    virtual ForwardClassDeclaration *asForwardClassDeclaration()

    { return this; }

    virtual const ForwardClassDeclaration *asForwardClassDeclarationType() const

    { return this; }

    virtual ForwardClassDeclaration *asForwardClassDeclarationType()

    { return this; }

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

    virtual void accept0(TypeVisitor *visitor);

    virtual bool matchType0(const Type *otherType, TypeMatcher *matcher) const;

private:

    TemplateParameters *_templateParameters;

};

class CPLUSPLUS_EXPORT Enum: public ScopedSymbol, public Type

{

public:

    Enum(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~Enum();

    // Symbol's interface

    virtual FullySpecifiedType type() const;

    // Type's interface

    virtual bool isEqualTo(const Type *other) const;

    virtual const Enum *asEnum() const

    { return this; }

    virtual Enum *asEnum()

    { return this; }

    virtual const Enum *asEnumType() const

    { return this; }

    virtual Enum *asEnumType()

    { return this; }

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

    virtual void accept0(TypeVisitor *visitor);

    virtual bool matchType0(const Type *otherType, TypeMatcher *matcher) const;

};

class CPLUSPLUS_EXPORT Function: public ScopedSymbol, public Type

{

public:

    enum MethodKey {

        NormalMethod,

        SlotMethod,

        SignalMethod

    };

public:

    Function(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~Function();

    bool isNormal() const;

    bool isSignal() const;

    bool isSlot() const;

    int methodKey() const;

    void setMethodKey(int key);

    unsigned templateParameterCount() const; // ### remove me

    Symbol *templateParameterAt(unsigned index) const; // ### remove me

    TemplateParameters *templateParameters() const;

    void setTemplateParameters(TemplateParameters *templateParameters);

    FullySpecifiedType returnType() const;

    void setReturnType(const FullySpecifiedType &returnType);

    /** Convenience function that returns whether the function returns something (including void). */

    bool hasReturnType() const;

    unsigned argumentCount() const;

    Symbol *argumentAt(unsigned index) const;

    Scope *arguments() const;

    /** Convenience function that returns whether the function receives any arguments. */

    bool hasArguments() const;

    bool isVirtual() const;

    void setVirtual(bool isVirtual);

    bool isVariadic() const;

    void setVariadic(bool isVariadic);

    bool isConst() const;

    void setConst(bool isConst);

    bool isVolatile() const;

    void setVolatile(bool isVolatile);

    bool isPureVirtual() const;

    void setPureVirtual(bool isPureVirtual);

#ifdef ICHECK_BUILD

    bool isInvokable() const;

    void setInvokable(bool isInvokable);

    bool isEqualTo(const Function* fct, bool ignoreName = false) const;

#endif

    // Symbol's interface

    virtual FullySpecifiedType type() const;

    // Type's interface

    virtual bool isEqualTo(const Type *other) const;

    virtual const Function *asFunction() const

    { return this; }

    virtual Function *asFunction()

    { return this; }

    virtual const Function *asFunctionType() const

    { return this; }

    virtual Function *asFunctionType()

    { return this; }

    bool isAmbiguous() const; // internal

    void setAmbiguous(bool isAmbiguous); // internal

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

    virtual void accept0(TypeVisitor *visitor);

    virtual bool matchType0(const Type *otherType, TypeMatcher *matcher) const;

private:

    TemplateParameters *_templateParameters;

    FullySpecifiedType _returnType;

    struct Flags {

        unsigned _isVirtual: 1;

        unsigned _isVariadic: 1;

        unsigned _isPureVirtual: 1;

        unsigned _isConst: 1;

        unsigned _isVolatile: 1;

        unsigned _isAmbiguous: 1;

        unsigned _methodKey: 3;

#ifdef ICHECK_BUILD

        unsigned _isInvokable: 1;

#endif

    };

    union {

        unsigned _flags;

        Flags f;

    };

    Scope *_arguments;

};

class CPLUSPLUS_EXPORT Namespace: public ScopedSymbol, public Type

{

public:

    Namespace(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~Namespace();

    // Symbol's interface

    virtual FullySpecifiedType type() const;

    // Type's interface

    virtual bool isEqualTo(const Type *other) const;

    virtual const Namespace *asNamespace() const

    { return this; }

    virtual Namespace *asNamespace()

    { return this; }

    virtual const Namespace *asNamespaceType() const

    { return this; }

    virtual Namespace *asNamespaceType()

    { return this; }

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

    virtual void accept0(TypeVisitor *visitor);

    virtual bool matchType0(const Type *otherType, TypeMatcher *matcher) const;

};

class CPLUSPLUS_EXPORT BaseClass: public Symbol

{

public:

    BaseClass(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~BaseClass();

    bool isVirtual() const;

    void setVirtual(bool isVirtual);

    // Symbol's interface

    virtual FullySpecifiedType type() const;

    void setType(const FullySpecifiedType &type);

    virtual const BaseClass *asBaseClass() const

    { return this; }

    virtual BaseClass *asBaseClass()

    { return this; }

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

private:

    bool _isVirtual;

    FullySpecifiedType _type;

};

class CPLUSPLUS_EXPORT Class: public ScopedSymbol, public Type

{

public:

    Class(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);

    virtual ~Class();

    enum Key {

        ClassKey,

        StructKey,

        UnionKey

    };

    bool isClass() const;

    bool isStruct() const;

    bool isUnion() const;

    Key classKey() const;

    void setClassKey(Key key);

    unsigned templateParameterCount() const; // ### remove me

    Symbol *templateParameterAt(unsigned index) const; // ### remove me

    TemplateParameters *templateParameters() const;

    void setTemplateParameters(TemplateParameters *templateParameters);

    unsigned baseClassCount() const;

    BaseClass *baseClassAt(unsigned index) const;

    void addBaseClass(BaseClass *baseClass);

    // Symbol's interface

    virtual FullySpecifiedType type() const;

    // Type's interface

    virtual bool isEqualTo(const Type *other) const;

    virtual const Class *asClass() const

    { return this; }

    virtual Class *asClass()

    { return this; }

    virtual const Class *asClassType() const

    { return this; }

    virtual Class *asClassType()

    { return this; }

protected:

    virtual void visitSymbol0(SymbolVisitor *visitor);

    virtual void accept0(TypeVisitor *visitor);

    virtual bool matchType0(const Type *otherType, TypeMatcher *matcher) const;