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

**

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

**

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

#include "tokenreplacements.h"

#include "logger.h"

#include "portingrules.h"

QT_BEGIN_NAMESPACE

using namespace TokenEngine;

void addLogSourceEntry(const QString &text, const TokenContainer &tokenContainer, const int index)

{

    Logger *logger = Logger::instance();

    int line = tokenContainer.line(index);

    int col = tokenContainer.column(index);

    SourcePointLogEntry *logEntry =

                new SourcePointLogEntry(QLatin1String("Info"), QLatin1String("Porting"),

                                        logger->globalState.value(QLatin1String("currentFileName")),

                                        line, col, text);

    logger->addEntry(logEntry);

}

void addLogWarning(const QString &text)

{

     Logger::instance()->addEntry(new PlainLogEntry(QLatin1String("Warning"), QLatin1String("Porting"), text));

}

QualifiedNameParser::QualifiedNameParser(const TokenContainer &tokenContainer, const int tokenIndex)

:tokenContainer(tokenContainer)

,currentIndex(tokenIndex)

{

    Q_ASSERT(isValidIndex(currentIndex));

}

bool QualifiedNameParser::isPartOfQualifiedName()

{

    return ((nextScopeToken(Left) != -1) || (nextScopeToken(Right) != -1));

}

bool QualifiedNameParser::isValidIndex(int index)

{

    return (index < tokenContainer.count() && index >= 0);

}

/*

    A qualifier is a the leftmost or middle part of a qualified name

*/

bool QualifiedNameParser::isQualifier()

{

    return (nextScopeToken(Right) != -1);

}

/*

    A name is a the rightmost part of a qualified name.

*/

bool QualifiedNameParser::isName()

{

    return (nextScopeToken(Left) != -1);

}

/*

    Peek for a qualifier or name in the given direction

*/

int QualifiedNameParser::peek(Direction direction)

{

    return nextScopeToken(direction);

}

/*

    Look for a qualifier or name in the given direction,update

    current position if found.

*/

int QualifiedNameParser::move(Direction direction)

{

    int tokenIndex = nextScopeToken(direction);

    if(tokenIndex != -1)

        currentIndex = tokenIndex;

    return tokenIndex;

}

/*

    Looks for "::" starting at currentIndex, returns the token index

    for it if found. If the first non-whitespace token found is something else,

    -1 is returned.

*/

int QualifiedNameParser::findScopeOperator(Direction direction)

{

    int tokenIndex = currentIndex;

    QByteArray tokenText;

    //loop until we get a token containg text or we pass the beginning/end of the source

    tokenIndex += direction;

    while(tokenText.isEmpty() && isValidIndex(tokenIndex)) {

        tokenText = tokenContainer.text(tokenIndex).trimmed();

        if(tokenText==QByteArray("::"))

           return tokenIndex;

        tokenIndex += direction;

    }

    return -1;

}

/*

    Walks a qualified name. Returns the token index

    for the next identifer in the qualified name, or -1 if its not found.

*/

int QualifiedNameParser::nextScopeToken(Direction direction)

{

    int tokenIndex  = findScopeOperator(direction);

    if (tokenIndex == -1)

        return -1;

    QByteArray tokenText;

   //loop until we get a token containg text or we pass the start of the source

    tokenIndex += direction;

    while(tokenText.isEmpty() && isValidIndex(tokenIndex)) {

       tokenText = tokenContainer.text(tokenIndex).trimmed();

       tokenIndex += direction;

    }

    return tokenIndex - direction;

}

/////////////////////

GenericTokenReplacement::GenericTokenReplacement(QByteArray oldToken, QByteArray newToken)

:oldToken(oldToken)

,newToken(newToken)

{}

QByteArray GenericTokenReplacement::getReplaceKey()

{

    return QByteArray(oldToken);

}

bool GenericTokenReplacement::doReplace(const TokenContainer &tokenContainer,

                            int index, TextReplacements &textReplacements)

{

    QByteArray tokenText = tokenContainer.text(index);

    if(tokenText == oldToken){

        addLogSourceEntry(QString::fromLatin1(tokenText + QByteArray(" -> ") + newToken), tokenContainer, index);

        TokenEngine::Token token = tokenContainer.token(index);

        textReplacements.insert(newToken, token.start, token.length);

        return true;

    }

    return false;

}

///////////////////

ClassNameReplacement::ClassNameReplacement(QByteArray oldToken, QByteArray newToken)

:oldToken(oldToken)

,newToken(newToken)

{}

QByteArray ClassNameReplacement::getReplaceKey()

{

    return QByteArray(oldToken);

}

/*

    Replace a class name token. If the class name is a scope specifier (a "qualifier")

    in a qualified name, we check if qualified name will be replaced by a porting rule.

    If so, we don't do the class name replacement.

*/

bool ClassNameReplacement::doReplace(const TokenContainer &tokenContainer, int index, TextReplacements &textReplacements)

{

    QByteArray tokenText = tokenContainer.text(index);

    if(tokenText != oldToken)

        return false;

    QualifiedNameParser nameParser(tokenContainer, index);

    if(nameParser.isPartOfQualifiedName() &&

       nameParser.peek(QualifiedNameParser::Right) != -1) {

        int nameTokenIndex = nameParser.peek(QualifiedNameParser::Right);

        QByteArray name = tokenContainer.text(nameTokenIndex); 

        TextReplacements textReplacements;

        QList<TokenReplacement*> tokenReplacements

            = PortingRules::instance()->getTokenReplacementRules();

        bool changed = false;

        foreach(TokenReplacement *tokenReplacement, tokenReplacements) {

            changed = tokenReplacement->doReplace(tokenContainer, nameTokenIndex, textReplacements);

            if(changed)

                break;

        }

        if(changed)

            return false;

    }

    addLogSourceEntry(QString::fromLatin1(tokenText + QByteArray(" -> ") + newToken), tokenContainer, index);

    TokenEngine::Token token = tokenContainer.token(index);

    textReplacements.insert(newToken, token.start, token.length);

    return true;

}

///////////////////

ScopedTokenReplacement::ScopedTokenReplacement(const QByteArray &oldToken,

                                               const QByteArray &newToken)

:newScopedName(newToken)

{

    Q_ASSERT(oldToken.contains(QByteArray("::")));

    // Split oldToken into scope and name parts.

    oldName = oldToken.mid(oldToken.lastIndexOf(':')+1);

    oldScope = oldToken.mid(0, oldToken.indexOf(':'));

    // Split newToken into scope and name parts, execept if we have a spcial

    // case like Qt::WType_Modal -> (Qt::WType_Dialog | Qt::WShowModal)

    if (newToken.count(QByteArray("::")) != 1 || newToken.contains(QByteArray("("))) {

        newName = newToken;

    } else {

        newName = newToken.mid(newToken.lastIndexOf(':')+1);

        newScope = newToken.mid(0, newToken.indexOf(':'));

    }

    strictMode = Logger::instance()->globalState.contains(QString::fromLatin1("strictMode"));

}

bool ScopedTokenReplacement::doReplace(const TokenContainer &tokenContainer, int sourceIndex, TextReplacements &textReplacements)

{

    const QByteArray sourceName = tokenContainer.text(sourceIndex);

    // Check if the token texts matches.

    if (sourceName != oldName)

        return false;

    // Get token attributes. The attributes are created by the the C++ parser/analyzer.

    const TokenAttributes *attributes = tokenContainer.tokenAttributes();

    // If the declaration attribute is set we don't replace.

    if (!attributes->attribute(sourceIndex, "declaration").isEmpty())

        return false;

    // If the unknown (undeclared) attribute is set we don't replace.

    if (!attributes->attribute(sourceIndex, "unknown").isEmpty())

        return false;

    // If nameUse is set we test if the nameUse refers to the correct declaration.

    // This is done by checking the parentScope attriute, wich returns the scope

    // for the declaration associated with this name use.

    const bool haveNameUseInfo = !attributes->attribute(sourceIndex, "nameUse").isEmpty();

    if (haveNameUseInfo) {

        if (attributes->attribute(sourceIndex, "parentScope") != oldScope)

            return false;

    // If the user has specified -strict, we don't replace tokens when we don't have name use info.

    } else if (strictMode) {

        return false;

    }

    // The token might have a qualifier, and in that case we need to check if

    // we should replace the qualifier as well.

    QualifiedNameParser nameParser(tokenContainer, sourceIndex);

    // This is a pretty special case, it means that in a qualified

    // name like aaa::bbb the replacement rule has been triggered for

    // the aaa part. Since this is not what we'd normally use a

    // ScopedReplacement for, we just return here.

    if (nameParser.isQualifier())

        return false;

    // If the token is unqualified, just replace it.

    if (!nameParser.isPartOfQualifiedName()) {

        // If we have no name use info we try to avoid replacements of

        // e.g. Vertical with QSizePolicy::Vertically. Unqualified tokens

        // can't happen for classes one does not usually inherit from, so

        // we only let them pass for stuff that people usually inherited from.

        if (!haveNameUseInfo && newScope != "Qt" && newScope != "QFrame" && newScope != "QValidator")

            return false;

        const Token sourceToken = tokenContainer.token(sourceIndex);

        addLogSourceEntry(QString::fromLatin1(sourceName + QByteArray(" -> ") + newScopedName), tokenContainer, sourceIndex);

        textReplacements.insert(newScopedName, sourceToken.start, sourceName.size());

        return true;

    }

    // Peek left for the qualifer token.

    const int sourceScopeIndex = nameParser.peek(QualifiedNameParser::Left);

    if (sourceScopeIndex == -1) {

        return false;

    }

    const Token sourceNameToken = tokenContainer.token(sourceIndex);

    const Token sourceScopeToken = tokenContainer.token(sourceScopeIndex);

    const QByteArray sourceScope = tokenContainer.text(sourceScopeIndex);

    // If we have no name use info and the source and old scopes don't match,

    // we generally dont't do a replace, unless the old scope is Qt and

    // the source scope inherits Qt. For example, QWidget::ButtonState should

    // be renamed to Qt::ButtonState.

    if (!haveNameUseInfo && sourceScope != oldScope) {

        if (oldScope != "Qt")

            return false;

        // Check if sourceScope inherits the Qt class.

        if (!PortingRules::instance()->getInheritsQt().contains(QString::fromLatin1(sourceScope.constData()))) //TODO optimize: linear search

            return false;

    }

    // Spcecial cases, such as QIODevice::Offset -> Q_LONGLONG

    // or Qt::WType_Modal -> (Qt::WType_Dialog | Qt::WShowModal).

    if (newScope.isEmpty()) {

        addLogSourceEntry(QString::fromLatin1((sourceScope + QByteArray("::") + sourceName +

                          QByteArray(" -> ") + newScopedName).constData()), tokenContainer, sourceIndex);

        const int qualiferLength = sourceNameToken.start - sourceScopeToken.start;

        const int length = qualiferLength + sourceNameToken.length;

        textReplacements.insert(newName, sourceScopeToken.start, length);

        return true;

    }

    // If the old and new scopes are equal, we replace the name part only.

    if (newScope == sourceScope) {

        // If the names are equal, there is no need to do anything.

        if (newName == sourceName)

            return true;

        addLogSourceEntry(QString::fromLatin1((sourceName + QByteArray(" -> ") + newName).constData()), tokenContainer, sourceIndex);

        textReplacements.insert(newName, sourceNameToken.start, sourceNameToken.length);

        return true;

    }

    // If the names are equal, replace scope only.

    if (newName == sourceName) {

        addLogSourceEntry(QString::fromLatin1((sourceScope + QByteArray(" -> ") + newScope).constData()), tokenContainer, sourceScopeIndex);

        textReplacements.insert(newScope, sourceScopeToken.start, sourceScopeToken.length);

        return true;

    }

    // Replace scope and name.

    addLogSourceEntry(QString::fromLatin1((sourceScope + QByteArray("::") + sourceName +

                      QByteArray(" -> ") + newScopedName).constData()),

                      tokenContainer, sourceScopeIndex);

    textReplacements.insert(newScope, sourceScopeToken.start, sourceScopeToken.length);

    textReplacements.insert(newName, sourceNameToken.start, sourceNameToken.length);

    return true;

}

QByteArray ScopedTokenReplacement::getReplaceKey()

{

   return oldName;

}

QT_END_NAMESPACE