/**************************************************************************** ** ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). ** 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 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