ProjectPorter Class Reference

#include <projectporter.h>

Inheritance diagram for ProjectPorter:

[legend]Collaboration diagram for ProjectPorter:

[legend]List of all members.

---

Detailed Description

Definition at line 32 of file projectporter.h.

Public Member Functions
	ProjectPorter (QString basePath, QStringList includeDirectories, QStringList qt3HeadersFilenames=QStringList())
void	enableCppParsing (bool enable)
void	enableMissingFilesWarnings (bool enable)
void	portProject (QString filePath)
void	portFile (QString filePath)
Private Slots
void	error (QString type, QString text)
Private Member Functions
void	portProject (QString inPath, QString proFileName)
void	portProFile (QString fileName, QMap< QString, QString > tagMap)
void	portFiles (QString basePath, QStringList fileNames)
void	enableAttributes (const IncludeFiles &includeFiles, const QString &fileName)
Private Attributes
QSet< QString >	processedFilesSet
QString	basePath
QStringList	includeDirectories
PreprocessorCache	preprocessorCache
Rpp::DefineMap *	defaultDefinitions
FilePorter	filePorter
QStringList	qt3HeadersFilenames
bool	analyze
bool	warnings

---

Constructor & Destructor Documentation

ProjectPorter::ProjectPorter	(	QString	basePath,
		QStringList	includeDirectories,
		QStringList	qt3HeadersFilenames = QStringList()
	)

Definition at line 40 of file projectporter.cpp.

:basePath(basePath)
,includeDirectories(includeDirectories)
,defaultDefinitions(defaultMacros(preprocessorCache))
,filePorter(preprocessorCache)
,qt3HeadersFilenames(qt3HeadersFilenames)
,analyze(true)
,warnings(false)
{}

---

Member Function Documentation

void ProjectPorter::enableCppParsing

(

bool

enable

)

Definition at line 50 of file projectporter.cpp.

References analyze.

Referenced by main().

{
    analyze = enable;
}

void ProjectPorter::enableMissingFilesWarnings

(

bool

enable

)

Definition at line 55 of file projectporter.cpp.

References warnings.

Referenced by main().

{
    warnings = enable;
}

void ProjectPorter::portProject

(

QString

filePath

)

Definition at line 60 of file projectporter.cpp.

References QFileInfo::fileName(), and QFileInfo::path().

Referenced by main(), and portProject().

{
    QFileInfo fileInfo(fileName);
    portProject(fileInfo.path(), fileInfo.fileName());
}

Here is the call graph for this function:

void ProjectPorter::portFile

(

QString

filePath

)

Definition at line 69 of file projectporter.cpp.

References analyze, basePath, QObject::connect(), defaultDefinitions, enableAttributes(), error(), PreprocessorController::evaluate(), includeDirectories, portFiles(), preprocessorCache, qt3HeadersFilenames, SIGNAL, and SLOT.

Referenced by main().

{
    if (analyze) {
        IncludeFiles includeFiles(basePath, includeDirectories);

        PreprocessorController preprocessor(includeFiles, preprocessorCache, qt3HeadersFilenames);
        connect(&preprocessor, SIGNAL(error(QString,QString)), SLOT(error(QString,QString)));

        Rpp::DefineMap definitionsCopy = *defaultDefinitions;
        // Preprocess
        TokenSectionSequence translationUnit = preprocessor.evaluate(fileName, &definitionsCopy);
        // Parse
        TranslationUnit translationUnitData = TranslationUnitAnalyzer().analyze(translationUnit);

        // Enable attribute generation for this file.
        enableAttributes(includeFiles, fileName);
        // Generate attributes.
        CodeModelAttributes().createAttributes(translationUnitData);
    }

    portFiles(QString(), QStringList() << fileName);
}

Here is the call graph for this function:

void ProjectPorter::error	(	QString	type,
		QString	text
	)			[private, slot]

Definition at line 92 of file projectporter.cpp.

References QByteArray::constData(), printf, QString::toLocal8Bit(), type, and warnings.

Referenced by portFile(), and portProject().

{
   if (warnings && type == "Error")
        printf("Warning: %s\n", text.toLocal8Bit().constData());
}

void ProjectPorter::portProject	(	QString	inPath,
		QString	proFileName
	)			[private]

Definition at line 98 of file projectporter.cpp.

References analyze, TranslationUnitAnalyzer::analyze(), QList< T >::at(), basePath, Logger::beginSection(), QObject::connect(), constData(), CodeModelAttributes::createAttributes(), defaultDefinitions, enableAttributes(), error(), PreprocessorController::evaluate(), QFile::exists(), QFileInfo::exists(), Logger::globalState, i, includeDirectories, Logger::instance(), QList< T >::isEmpty(), QList< T >::last(), loadFile(), portFiles(), portProFile(), portProject(), preprocessorCache, printf, proFileTagMap(), qt3HeadersFilenames, SIGNAL, QList< T >::size(), QString::SkipEmptyParts, SLOT, QString::split(), and QDir::toNativeSeparators().

{
    QString fullInFileName = basePath + "/" + proFileName;
    QFileInfo infileInfo(fullInFileName);
    if (!infileInfo.exists()) {
        printf("Could not open file: %s\n", QDir::toNativeSeparators(fullInFileName).toLocal8Bit().constData());
        return;
    }

    QString proFileContents = loadFile(fullInFileName);
    QMap<QString, QString> proFileMap = proFileTagMap(proFileContents, QDir(basePath).absolutePath());


    // Check if this is a TEMPLATE = subdirs .pro file, in that case we
    // process each subdir (recursively).

    QString templateTag = proFileMap["TEMPLATE"];
    if (templateTag == "subdirs") {
        QStringList subdirs = proFileMap["SUBDIRS"].split(" ", QString::SkipEmptyParts);
        foreach(QString subdir, subdirs) {
            QString newBasePath  = basePath + "/" + subdir;
            QStringList dirsInSubdir = subdir.split(QRegExp("/|\\\\"), QString::SkipEmptyParts);
            QString newProFileName = dirsInSubdir.last() + ".pro";
            portProject(newBasePath, newProFileName);
        }
        return;
    }

    // Get headers and sources file names from .pro file.
    QStringList sources = proFileMap["SOURCES"].split(" ", QString::SkipEmptyParts);
    QStringList headers = proFileMap["HEADERS"].split(" ", QString::SkipEmptyParts);
    QStringList forms = proFileMap["FORMS"].split(" ", QString::SkipEmptyParts);
    QStringList uidoth;
    for (int i = 0; i < forms.size(); ++i) {
        QString ui_h = forms.at(i) + ".h";
        if (QFile::exists(basePath + "/" + ui_h))
            uidoth += ui_h;
    }

    if (analyze) {
        printf("Parsing");
        // Get include paths from the pro file.
        QStringList includeProPaths = proFileMap["INCLUDEPATH"].split(" ", QString::SkipEmptyParts);
        QStringList dependProPaths = proFileMap["DEPENDPATH"].split(" ", QString::SkipEmptyParts);
        IncludeFiles includeFiles(basePath, includeDirectories + includeProPaths + dependProPaths);

        PreprocessorController preprocessorController(includeFiles, preprocessorCache, qt3HeadersFilenames);
        connect(&preprocessorController, SIGNAL(error(QString,QString)), SLOT(error(QString,QString)));

        TranslationUnitAnalyzer translationUnitAnalyzer;
        CodeModelAttributes codeModelAttributes;

        // Enable attribute generation for header files.
        foreach(QString headerFile, headers)
            enableAttributes(includeFiles, headerFile);

        // Enable attribute generation for ui.h files.
        foreach(QString headerFile, uidoth)
            enableAttributes(includeFiles, headerFile);

        // Analyze each translation unit. (one per cpp file)
        foreach(QString sourceFile, sources) {
            printf(".");
            fflush(stdout);
            Rpp::DefineMap definitionsCopy = *defaultDefinitions;
            TokenSectionSequence translationUnit =
                preprocessorController.evaluate(sourceFile, &definitionsCopy);
            TranslationUnit translationUnitData =
                translationUnitAnalyzer.analyze(translationUnit);

            // Enable attribute generation for this file.
            enableAttributes(includeFiles, sourceFile);

            codeModelAttributes.createAttributes(translationUnitData);
        }
        puts("");
    }


    // Port files.
    portFiles(basePath, sources);
    portFiles(basePath, headers);
    if (!uidoth.isEmpty())
        portFiles(basePath, uidoth);

    Logger::instance()->globalState["currentFileName"] = proFileName;
    Logger::instance()->beginSection();
    portProFile(fullInFileName, proFileMap);
}

Here is the call graph for this function:

void ProjectPorter::portProFile	(	QString	fileName,
		QMap< QString, QString >	tagMap
	)			[private]

Definition at line 217 of file projectporter.cpp.

References Logger::addEntry(), QList< T >::at(), QTextStream::atEnd(), QFile::close(), Logger::commitSection(), QStringList::contains(), QList< T >::count(), detectLineEndings(), filePorter, QTextStream::flush(), Logger::globalState, i, QList< T >::insert(), QSet< T >::insert(), FileWriter::instance(), Logger::instance(), isEmpty(), QSet< T >::isEmpty(), name, QFile::open(), QString::prepend(), QIODevice::readAll(), QTextStream::readLine(), QIODevice::ReadOnly, QSet< T >::remove(), Logger::revertSection(), QFile::seek(), QString::SkipEmptyParts, QString::startsWith(), QString::trimmed(), FilePorter::usedQtModules(), QMap< Key, T >::value(), FileWriter::WriteFailed, FileWriter::writeFileVerbously(), FileWriter::WriteSkipped, and FileWriter::WriteSucceeded.

Referenced by portProject().

{
    // Read pro file.
    QFile proFile(fileName);
    if (!proFile.open(QIODevice::ReadOnly))
        return;

    const QByteArray contents = proFile.readAll();
    const QByteArray lineEnding = detectLineEndings(contents);
    proFile.seek(0);

    QTextStream proTextStream(&proFile);
    QStringList lines;
    while (!proTextStream.atEnd())
        lines += proTextStream.readLine();

    proFile.close();

    // Find out what modules we should add to the QT variable.
     QSet<QByteArray> qtModules;

    // Add qt3support to the Qt tag
    qtModules.insert("qt3support");

    // Read CONFIG and add other modules.
    QStringList config = tagMap["CONFIG"].split(" ", QString::SkipEmptyParts);
    if (config.contains("opengl"))
        qtModules.insert("opengl");
    if (config.contains("xml"))
        qtModules.insert("xml");
    if (config.contains("sql"))
        qtModules.insert("sql");
    if (config.contains("network"))
        qtModules.insert("network");

    // Get set of used modules from the file porter.
    qtModules += filePorter.usedQtModules();

    // Remove gui and core.
    qtModules.remove("gui");
    qtModules.remove("core");

    // Qt3Support is already added.
    qtModules.remove("3support");

    // Remove modules already present in the QT variable.
    QStringList qt = tagMap["QT"].split(" ", QString::SkipEmptyParts);
    foreach(QString name, qt) {
        qtModules.remove(name.toLatin1());
    }

    Logger *logger = Logger::instance();
    bool changesMade = false;

    if (!qtModules.isEmpty()) {
        changesMade = true;
        QString insertText = "QT += ";
        foreach(QByteArray module, qtModules) {
            insertText += module + QLatin1Char(' ');
        }
        lines += QString("#The following line was inserted by qt3to4");
        lines += insertText;
         QString logText = "In file "
                        + logger->globalState.value("currentFileName")
                        + ": Added entry "
                        + insertText;
        logger->addEntry(new PlainLogEntry("Info", "Porting", logText));
    }

    // Add uic3 if we have forms, and change FORMS and INTERFACES to FORMS3
    if (!tagMap["FORMS"].isEmpty() || !tagMap["INTERFACES"].isEmpty()) {
        changesMade = true;
        lines += QString("#The following line was inserted by qt3to4");
        QString insertText = "CONFIG += uic3" + lineEnding;
        lines += insertText;
        QString logText = "In file "
                        + logger->globalState.value("currentFileName")
                        + ": Added entry "
                        + insertText;
        logger->addEntry(new PlainLogEntry("Info", "Porting", logText));

        const QString formsToForms3("#The following line was changed from FORMS to FORMS3 by qt3to4");
        const QString interfacesToForms3("#The following line was changed from INTERFACES to FORMS3 by qt3to4");
        for (int i = 0; i < lines.count(); ++i) {
            QString cLine = lines.at(i);
            cLine = cLine.trimmed();
            if (cLine.startsWith("FORMS")) {
                lines[i].replace("FORMS", "FORMS3");
                lines.insert(i, formsToForms3);
                ++i;
                QString logText = "In file "
                    + logger->globalState.value("currentFileName")
                    + ": Renamed FORMS to FORMS3";
                logger->addEntry(new PlainLogEntry("Info", "Porting", logText));
            } else if (cLine.startsWith("INTERFACES")) {
                lines[i].replace("INTERFACES", "FORMS3");
                lines.insert(i, interfacesToForms3);
                ++i;
                QString logText = "In file "
                    + logger->globalState.value("currentFileName")
                    + ": Renamed INTERFACES to FORMS3";
                logger->addEntry(new PlainLogEntry("Info", "Porting", logText));
            }
        }
    }

    // Comment out any REQUIRES tag.
    if (!tagMap["REQUIRES"].isEmpty()) {
        changesMade = true;
        QString insertText("#The following line was commented out by qt3to4");
        for (int i = 0; i < lines.count(); ++i) {
            if (lines.at(i).startsWith("REQUIRES")) {
                QString lineCopy = lines.at(i);
                lineCopy.prepend('#');
                lines[i] = lineCopy;
                lines.insert(i, insertText);
                ++i; //skip ahead, we just insertet a line at i.
                QString logText = "In file "
                            + logger->globalState.value("currentFileName")
                            + ": Commented out REQUIRES section";
                logger->addEntry(new PlainLogEntry("Info", "Porting", logText));
            }
        }
    }

    // Check if any changes has been made.
    if (!changesMade) {
        Logger::instance()->addEntry(
            new PlainLogEntry("Info", "Porting",  QLatin1String("No changes made to file ") + fileName));
        Logger::instance()->commitSection();
        return;
    }

    // Write lines to array.
    QByteArray bob;
    QTextStream outProFileStream(&bob);
    foreach(QString line, lines)
        outProFileStream << line << lineEnding;
    outProFileStream.flush();

    // Write array to file, commit log if write was successful.
    FileWriter::WriteResult result = FileWriter::instance()->writeFileVerbously(fileName, bob);
    if (result == FileWriter::WriteSucceeded) {
        logger->commitSection();
    } else if (result == FileWriter::WriteFailed) {
        logger->revertSection();
        logger->addEntry(
            new PlainLogEntry("Error", "Porting",  QLatin1String("Error writing to file ") + fileName));
    } else if (result == FileWriter::WriteSkipped) {
        logger->revertSection();
        logger->addEntry(
            new PlainLogEntry("Error", "Porting",  QLatin1String("User skipped file ") + fileName));
    } else {
        // Internal error.
        logger->revertSection();
        const QString errorString = QLatin1String("Internal error in qt3to4 - FileWriter returned invalid result code while writing to ") + fileName;
        logger->addEntry(new PlainLogEntry("Error", "Porting", errorString));
    }
}

Here is the call graph for this function:

void ProjectPorter::portFiles	(	QString	basePath,
		QStringList	fileNames
	)			[private]

Definition at line 192 of file projectporter.cpp.

References basePath, QDir::cleanPath(), constData(), QSet< T >::contains(), QFileInfo::exists(), filePorter, Logger::globalState, QSet< T >::insert(), Logger::instance(), QFileInfo::isAbsolute(), FilePorter::port(), printf, processedFilesSet, and QDir::toNativeSeparators().

Referenced by portFile(), and portProject().

{
    foreach(QString fileName, fileNames) {
        QString fullFilePath;
        QFileInfo fileInfo(fileName);
        if (fileInfo.isAbsolute()) {
            fullFilePath = QDir::cleanPath(fileName);
        } else {
            fullFilePath = QDir::cleanPath(basePath + "/" + fileName);
        }

        QFileInfo fullFilePathInfo(fullFilePath);
        if (!fullFilePathInfo.exists()) {
            printf("Could not find file: %s\n", QDir::toNativeSeparators(fullFilePath).toLocal8Bit().constData());
            continue;
        }

        if (!processedFilesSet.contains(fullFilePath)){
            Logger::instance()->globalState["currentFileName"] = fullFilePath;
            filePorter.port(fullFilePath);
            processedFilesSet.insert(fullFilePath);
        }
    }
}

Here is the call graph for this function:

void ProjectPorter::enableAttributes	(	const IncludeFiles &	includeFiles,
		const QString &	fileName
	)			[private]

Definition at line 381 of file projectporter.cpp.

References TokenEngine::TokenAttributes::addAttribute(), IncludeFiles::angleBracketLookup(), QFile::exists(), preprocessorCache, IncludeFiles::resolve(), PreprocessorCache::sourceTokens(), and TokenEngine::TokenContainer::tokenAttributes().

Referenced by portFile(), and portProject().

{
    QString resolvedFilePath = includeFiles.resolve(fileName);
    if (!QFile::exists(resolvedFilePath))
            resolvedFilePath = includeFiles.angleBracketLookup(fileName);
    if (!QFile::exists(resolvedFilePath))
        return;

    TokenContainer tokenContainer = preprocessorCache.sourceTokens(resolvedFilePath);
    TokenAttributes *attributes = tokenContainer.tokenAttributes();
    attributes->addAttribute("CreateAttributes", "True");
}

Here is the call graph for this function:

---

Member Data Documentation

QSet<QString> ProjectPorter::processedFilesSet [private]

Definition at line 49 of file projectporter.h.

Referenced by portFiles().

QString ProjectPorter::basePath [private]

Definition at line 50 of file projectporter.h.

Referenced by portFile(), portFiles(), and portProject().

QStringList ProjectPorter::includeDirectories [private]

Definition at line 51 of file projectporter.h.

Referenced by portFile(), and portProject().

PreprocessorCache ProjectPorter::preprocessorCache [private]

Definition at line 52 of file projectporter.h.

Referenced by enableAttributes(), portFile(), and portProject().

Rpp::DefineMap* ProjectPorter::defaultDefinitions [private]

Definition at line 53 of file projectporter.h.

Referenced by portFile(), and portProject().

FilePorter ProjectPorter::filePorter [private]

Definition at line 54 of file projectporter.h.

Referenced by portFiles(), and portProFile().

QStringList ProjectPorter::qt3HeadersFilenames [private]

Definition at line 55 of file projectporter.h.

Referenced by portFile(), and portProject().

bool ProjectPorter::analyze [private]

Definition at line 56 of file projectporter.h.

Referenced by enableCppParsing(), portFile(), and portProject().

bool ProjectPorter::warnings [private]

Definition at line 57 of file projectporter.h.

Referenced by enableMissingFilesWarnings(), and error().

---

The documentation for this class was generated from the following files:

• tools/porting/src/projectporter.h
• tools/porting/src/projectporter.cpp

---