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

**

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

#include "Symbols.h"

#include "Names.h"

#include "TypeVisitor.h"

#include "SymbolVisitor.h"

#include "TypeMatcher.h"

#include "Scope.h"

using namespace CPlusPlus;

TemplateParameters::TemplateParameters(Scope *scope)

    : _previous(0), _scope(scope)

{ }

TemplateParameters::TemplateParameters(TemplateParameters *previous, Scope *scope)

    : _previous(previous), _scope(scope)

{ }

TemplateParameters::~TemplateParameters()

{

    delete _previous;

    delete _scope;

}

TemplateParameters *TemplateParameters::previous() const

{ return _previous; }

Scope *TemplateParameters::scope() const

{ return _scope; }

UsingNamespaceDirective::UsingNamespaceDirective(TranslationUnit *translationUnit,

                                                 unsigned sourceLocation, const Name *name)

    : Symbol(translationUnit, sourceLocation, name)

{ }

UsingNamespaceDirective::~UsingNamespaceDirective()

{ }

FullySpecifiedType UsingNamespaceDirective::type() const

{ return FullySpecifiedType(); }

void UsingNamespaceDirective::visitSymbol0(SymbolVisitor *visitor)

{ visitor->visit(this); }

UsingDeclaration::UsingDeclaration(TranslationUnit *translationUnit,

                                   unsigned sourceLocation, const Name *name)

    : Symbol(translationUnit, sourceLocation, name)

{ }

UsingDeclaration::~UsingDeclaration()

{ }

FullySpecifiedType UsingDeclaration::type() const

{ return FullySpecifiedType(); }

void UsingDeclaration::visitSymbol0(SymbolVisitor *visitor)

{ visitor->visit(this); }

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

    : Symbol(translationUnit, sourceLocation, name),

      _templateParameters(0)

{ }

Declaration::~Declaration()

{ delete _templateParameters; }

TemplateParameters *Declaration::templateParameters() const

{ return _templateParameters; }

void Declaration::setTemplateParameters(TemplateParameters *templateParameters)

{ _templateParameters = templateParameters; }

void Declaration::setType(const FullySpecifiedType &type)

{ _type = type; }

FullySpecifiedType Declaration::type() const

{ return _type; }

void Declaration::visitSymbol0(SymbolVisitor *visitor)

{ visitor->visit(this); }

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

    : Symbol(translationUnit, sourceLocation, name),

      _initializer(0)

{ }

Argument::~Argument()

{ }

bool Argument::hasInitializer() const

{ return _initializer != 0; }

const StringLiteral *Argument::initializer() const

{ return _initializer; }

void Argument::setInitializer(const StringLiteral *initializer)

{ _initializer = initializer; }

void Argument::setType(const FullySpecifiedType &type)

{ _type = type; }

FullySpecifiedType Argument::type() const

{ return _type; }

void Argument::visitSymbol0(SymbolVisitor *visitor)

{ visitor->visit(this); }

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

    : Symbol(translationUnit, sourceLocation, name)

{ }

TypenameArgument::~TypenameArgument()

{ }

void TypenameArgument::setType(const FullySpecifiedType &type)

{ _type = type; }

FullySpecifiedType TypenameArgument::type() const

{ return _type; }

void TypenameArgument::visitSymbol0(SymbolVisitor *visitor)

{ visitor->visit(this); }

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

    : ScopedSymbol(translationUnit, sourceLocation, name),

     _templateParameters(0),

     _flags(0)

{ _arguments = new Scope(this); }

Function::~Function()

{

    delete _templateParameters;

    delete _arguments;

}

bool Function::isNormal() const

{ return f._methodKey == NormalMethod; }

bool Function::isSignal() const

{ return f._methodKey == SignalMethod; }

bool Function::isSlot() const

{ return f._methodKey == SlotMethod; }

int Function::methodKey() const

{ return f._methodKey; }

void Function::setMethodKey(int key)

{ f._methodKey = key; }

unsigned Function::templateParameterCount() const

{

    if (! _templateParameters)

        return 0;

    return _templateParameters->scope()->symbolCount();

}

Symbol *Function::templateParameterAt(unsigned index) const

{ return _templateParameters->scope()->symbolAt(index); }

TemplateParameters *Function::templateParameters() const

{ return _templateParameters; }

void Function::setTemplateParameters(TemplateParameters *templateParameters)

{ _templateParameters = templateParameters; }

bool Function::isEqualTo(const Type *other) const

{

    const Function *o = other->asFunctionType();

    if (! o)

        return false;

    else if (isConst() != o->isConst())

        return false;

    else if (isVolatile() != o->isVolatile())

        return false;

#ifdef ICHECK_BUILD

    else if (isInvokable() != o->isInvokable())

        return false;

    else if (isSignal() != o->isSignal())

        return false;

#endif

    const Name *l = identity();

    const Name *r = o->identity();

    if (l == r || (l && l->isEqualTo(r))) {

        if (_arguments->symbolCount() != o->_arguments->symbolCount())

            return false;

        else if (! _returnType.isEqualTo(o->_returnType))

            return false;

        for (unsigned i = 0; i < _arguments->symbolCount(); ++i) {

            Symbol *l = _arguments->symbolAt(i);

            Symbol *r = o->_arguments->symbolAt(i);

            if (! l->type().isEqualTo(r->type()))

                return false;

        }

        return true;

    }

    return false;

}

#ifdef ICHECK_BUILD

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

{

    if(!ignoreName)

        return isEqualTo((Type*)fct);

    if (! fct)

        return false;

    else if (isConst() != fct->isConst())

        return false;

    else if (isVolatile() != fct->isVolatile())

        return false;

    else if (isInvokable() != fct->isInvokable())

        return false;

    else if (isSignal() != fct->isSignal())

        return false;

    if (_arguments->symbolCount() != fct->_arguments->symbolCount())

        return false;

    else if (! _returnType.isEqualTo(fct->_returnType))

        return false;

    for (unsigned i = 0; i < _arguments->symbolCount(); ++i) {

        Symbol *l = _arguments->symbolAt(i);

        Symbol *r = fct->_arguments->symbolAt(i);

        if (! l->type().isEqualTo(r->type()))

            return false;

    }

    return true;

}

#endif

void Function::accept0(TypeVisitor *visitor)

{ visitor->visit(this); }

bool Function::matchType0(const Type *otherType, TypeMatcher *matcher) const

{

    if (const Function *otherTy = otherType->asFunctionType())

        return matcher->match(this, otherTy);

    return false;

}

FullySpecifiedType Function::type() const

{ return FullySpecifiedType(const_cast<Function *>(this)); }

FullySpecifiedType Function::returnType() const

{ return _returnType; }

void Function::setReturnType(const FullySpecifiedType &returnType)

{ _returnType = returnType; }

bool Function::hasReturnType() const

{

    const FullySpecifiedType ty = returnType();

    return ty.isValid() || ty.isSigned() || ty.isUnsigned();

}

unsigned Function::argumentCount() const

{

    if (! _arguments)

        return 0;

    return _arguments->symbolCount();

}

Symbol *Function::argumentAt(unsigned index) const

{ return _arguments->symbolAt(index); }

Scope *Function::arguments() const

{ return _arguments; }

bool Function::hasArguments() const

{

    return ! (argumentCount() == 0 ||

              (argumentCount() == 1 && argumentAt(0)->type()->isVoidType()));

}

bool Function::isVirtual() const

{ return f._isVirtual; }

void Function::setVirtual(bool isVirtual)

{ f._isVirtual = isVirtual; }

bool Function::isVariadic() const

{ return f._isVariadic; }

void Function::setVariadic(bool isVariadic)

{ f._isVariadic = isVariadic; }

bool Function::isConst() const

{ return f._isConst; }

void Function::setConst(bool isConst)

{ f._isConst = isConst; }

bool Function::isVolatile() const

{ return f._isVolatile; }

void Function::setVolatile(bool isVolatile)

{ f._isVolatile = isVolatile; }

bool Function::isPureVirtual() const

{ return f._isPureVirtual; }

void Function::setPureVirtual(bool isPureVirtual)

{ f._isPureVirtual = isPureVirtual; }

#ifdef ICHECK_BUILD

bool Function::isInvokable() const

{ return f._isInvokable == 1; }

void Function::setInvokable(bool isInvokable)

{ f._isInvokable = isInvokable; }

#endif

bool Function::isAmbiguous() const

{ return f._isAmbiguous; }

void Function::setAmbiguous(bool isAmbiguous)

{ f._isAmbiguous = isAmbiguous; }

void Function::visitSymbol0(SymbolVisitor *visitor)

{

    if (visitor->visit(this)) {

        for (unsigned i = 0; i < _arguments->symbolCount(); ++i) {

            visitSymbol(_arguments->symbolAt(i), visitor);

        }

        for (unsigned i = 0; i < memberCount(); ++i) {

            visitSymbol(memberAt(i), visitor);

        }

    }

}

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

    : Symbol(translationUnit, sourceLocation, name)

{ _members = new Scope(this); }

ScopedSymbol::~ScopedSymbol()

{ delete _members; }

unsigned ScopedSymbol::memberCount() const

{

    if (! _members)

        return 0;

    return _members->symbolCount();

}

Symbol *ScopedSymbol::memberAt(unsigned index) const

{

    if (! _members)

        return 0;

    return _members->symbolAt(index);

}

Scope *ScopedSymbol::members() const

{ return _members; }

void ScopedSymbol::addMember(Symbol *member)

{ _members->enterSymbol(member); }

Block::Block(TranslationUnit *translationUnit, unsigned sourceLocation)

    : ScopedSymbol(translationUnit, sourceLocation, /*name = */ 0)

{ }

Block::~Block()

{ }

FullySpecifiedType Block::type() const

{ return FullySpecifiedType(); }

void Block::visitSymbol0(SymbolVisitor *visitor)

{

    if (visitor->visit(this)) {

        for (unsigned i = 0; i < memberCount(); ++i) {

            visitSymbol(memberAt(i), visitor);

        }

    }

}

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

    : ScopedSymbol(translationUnit, sourceLocation, name)

{ }

Enum::~Enum()

{ }

FullySpecifiedType Enum::type() const

{ return FullySpecifiedType(const_cast<Enum *>(this)); }

bool Enum::isEqualTo(const Type *other) const

{

    const Enum *o = other->asEnumType();

    if (! o)

        return false;

    const Name *l = identity();

    const Name *r = o->identity();

    if (l == r)

        return true;

    else if (! l)

        return false;

    return l->isEqualTo(r);

}

void Enum::accept0(TypeVisitor *visitor)

{ visitor->visit(this); }

bool Enum::matchType0(const Type *otherType, TypeMatcher *matcher) const

{

    if (const Enum *otherTy = otherType->asEnumType())

        return matcher->match(this, otherTy);

    return false;

}

void Enum::visitSymbol0(SymbolVisitor *visitor)

{

    if (visitor->visit(this)) {

        for (unsigned i = 0; i < memberCount(); ++i) {

            visitSymbol(memberAt(i), visitor);

        }

    }

}

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

    : ScopedSymbol(translationUnit, sourceLocation, name)

{ }

Namespace::~Namespace()

{ }

bool Namespace::isEqualTo(const Type *other) const

{

    const Namespace *o = other->asNamespaceType();

    if (! o)

        return false;

    const Name *l = identity();

    const Name *r = o->identity();

    if (l == r || (l && l->isEqualTo(r)))

        return true;

    return false;

}

void Namespace::accept0(TypeVisitor *visitor)

{ visitor->visit(this); }

bool Namespace::matchType0(const Type *otherType, TypeMatcher *matcher) const

{

    if (const Namespace *otherTy = otherType->asNamespaceType())

        return matcher->match(this, otherTy);

    return false;

}

void Namespace::visitSymbol0(SymbolVisitor *visitor)

{

    if (visitor->visit(this)) {

        for (unsigned i = 0; i < memberCount(); ++i) {

            visitSymbol(memberAt(i), visitor);

        }

    }

}

FullySpecifiedType Namespace::type() const

{ return FullySpecifiedType(const_cast<Namespace *>(this)); }

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