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

**

** 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 qmake 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 "symmake.h"

#include <qstring.h>

#include <qhash.h>

#include <qstringlist.h>

#include <qdir.h>

#include <qdatetime.h>

#include <stdlib.h>

#include <qdebug.h>

#include <QSettings>

// Included from tools/shared

#include <symbian/epocroot.h>

#define RESOURCE_DIRECTORY_MMP "/resource/apps"

#define REGISTRATION_RESOURCE_DIRECTORY_HW "/private/10003a3f/import/apps"

#define PLUGIN_COMMON_DEF_FILE_FOR_MMP "./plugin_common.def"

#define BLD_INF_FILENAME_LEN (sizeof(BLD_INF_FILENAME) - 1)

#define BLD_INF_RULES_BASE "BLD_INF_RULES."

#define BLD_INF_TAG_PLATFORMS "prj_platforms"

#define BLD_INF_TAG_MMPFILES "prj_mmpfiles"

#define BLD_INF_TAG_TESTMMPFILES "prj_testmmpfiles"

#define BLD_INF_TAG_EXTENSIONS "prj_extensions"

#define BLD_INF_TAG_TESTEXTENSIONS "prj_testextensions"

#define MMP_TARGET "TARGET"

#define MMP_TARGETTYPE "TARGETTYPE"

#define MMP_SECUREID "SECUREID"

#define MMP_OPTION "OPTION"

#define MMP_LINKEROPTION "LINKEROPTION"

#define MMP_CAPABILITY "CAPABILITY"

#define MMP_EPOCALLOWDLLDATA "EPOCALLOWDLLDATA"

#define MMP_EPOCHEAPSIZE "EPOCHEAPSIZE"

#define MMP_EPOCSTACKSIZE "EPOCSTACKSIZE"

#define MMP_UID "UID"

#define MMP_VENDORID "VENDORID"

#define MMP_VERSION "VERSION"

#define MMP_START_RESOURCE "START RESOURCE"

#define MMP_END_RESOURCE "END"

#define VAR_CXXFLAGS "QMAKE_CXXFLAGS"

#define VAR_CFLAGS "QMAKE_CFLAGS"

#define VAR_LFLAGS "QMAKE_LFLAGS"

QString SymbianMakefileGenerator::fixPathForMmp(const QString& origPath, const QDir& parentDir)

{

    static QString epocRootStr;

    if (epocRootStr.isEmpty()) {

        epocRootStr = epocRoot();

        QFileInfo efi(epocRootStr);

        if (!efi.exists() || epocRootStr.isEmpty()) {

            fprintf(stderr, "Unable to resolve epocRoot '%s' to real dir on current drive, defaulting to '/' for mmp paths\n", qPrintable(epocRoot()));

            epocRootStr = "/";

        } else {

            epocRootStr = efi.absoluteFilePath();

        }

        if (!epocRootStr.endsWith("/"))

            epocRootStr += "/";

        epocRootStr += "epoc32/";

    }

    QString resultPath = origPath;

    // Make it relative, unless it starts with "%epocroot%/epoc32/"

    if (resultPath.startsWith(epocRootStr, Qt::CaseInsensitive)) {

        resultPath.replace(epocRootStr, "/epoc32/", Qt::CaseInsensitive);

    } else {

        resultPath = parentDir.relativeFilePath(resultPath);

    }

    resultPath = QDir::cleanPath(resultPath);

    if (resultPath.isEmpty())

        resultPath = ".";

    return resultPath;

}

QString SymbianMakefileGenerator::absolutizePath(const QString& origPath)

{

    // Prepend epocroot to any paths beginning with "/epoc32/"

    QString resultPath = QDir::fromNativeSeparators(origPath);

    if (resultPath.startsWith("/epoc32/", Qt::CaseInsensitive))

        resultPath = QDir::fromNativeSeparators(epocRoot()) + resultPath.mid(1);

    QFileInfo fi(fileInfo(resultPath));

    // Since origPath can be something given in HEADERS, we need to check if we are dealing

    // with a file or a directory. In case the origPath doesn't yet exist, isFile() returns

    // false and we default to assuming it is a dir.

    if (fi.isFile()) {

        resultPath = fi.absolutePath();

    } else {

        resultPath = fi.absoluteFilePath();

    }

    resultPath = QDir::cleanPath(resultPath);

    return resultPath;

}

SymbianMakefileGenerator::SymbianMakefileGenerator() : MakefileGenerator(), SymbianCommonGenerator(this) { }

SymbianMakefileGenerator::~SymbianMakefileGenerator() { }

void SymbianMakefileGenerator::writeHeader(QTextStream &t)

{

    t << "// ============================================================================" << endl;

    t << "// * Makefile for building: " << escapeFilePath(var("TARGET")) << endl;

    t << "// * Generated by qmake (" << qmake_version() << ") (Qt " QT_VERSION_STR ") on: ";

    t << QDateTime::currentDateTime().toString(Qt::ISODate) << endl;

    t << "// * This file is generated by qmake and should not be modified by the" << endl;

    t << "// * user." << endl;

    t << "// * Project:  " << fileFixify(project->projectFile()) << endl;

    t << "// * Template: " << var("TEMPLATE") << endl;

    t << "// ============================================================================" << endl;

    t << endl;

    // Defining define for bld.inf

    QString shortProFilename = project->projectFile();

    shortProFilename.replace(0, shortProFilename.lastIndexOf("/") + 1, QString(""));

    shortProFilename.replace(Option::pro_ext, QString(""));

    QString bldinfDefine = shortProFilename;

    bldinfDefine.append("_");

    bldinfDefine.append(generate_uid(project->projectFile()));

    bldinfDefine.prepend("BLD_INF_");

    removeEpocSpecialCharacters(bldinfDefine);

    t << "#define " << bldinfDefine.toUpper() << endl << endl;

}

bool SymbianMakefileGenerator::writeMakefile(QTextStream &t)

{

    if(!project->values("QMAKE_FAILED_REQUIREMENTS").isEmpty()) {

        fprintf(stderr, "Project files not generated because all requirements are not met:\n\t%s\n",

                qPrintable(var("QMAKE_FAILED_REQUIREMENTS")));

        return false;

    }

    writeHeader(t);

    QString numberOfIcons;

    QString iconFile;

    QMap<QString, QStringList> userRssRules;

    readRssRules(numberOfIcons, iconFile, userRssRules);

    // Get the application translations and convert to symbian OS lang code, i.e. decical number

    QStringList symbianLangCodes = symbianLangCodesFromTsFiles();

    // Generate pkg files if there are any actual files to deploy

    bool generatePkg = false;

    if (targetType == TypeExe) {

        generatePkg = true;

    } else {

        foreach(QString item, project->values("DEPLOYMENT")) {

            if (!project->values(item + ".sources").isEmpty()) {

                generatePkg = true;

                break;

            }

        }

    }

    if (generatePkg) {

        generatePkgFile(iconFile, true);

    }

    writeBldInfContent(t, generatePkg, iconFile);

    // Generate empty wrapper makefile here, because wrapper makefile must exist before writeMkFile,

    // but all required data is not yet available.

    bool isPrimaryMakefile = true;

    QString wrapperFileName = Option::output_dir + QLatin1Char('/') + QLatin1String("Makefile");

    QString outputFileName = fileInfo(Option::output.fileName()).fileName();

    if (outputFileName != BLD_INF_FILENAME) {

        wrapperFileName.append(".").append(outputFileName.startsWith(BLD_INF_FILENAME)

                                           ? outputFileName.mid(sizeof(BLD_INF_FILENAME))

                                           : outputFileName);

        isPrimaryMakefile = false;

    }

    QFile wrapperMakefile(wrapperFileName);

    if (wrapperMakefile.open(QIODevice::WriteOnly)) {

        generatedFiles << wrapperFileName;

        if (Option::mkfile::listgen) {

            generatePrint(fileInfo(wrapperMakefile.fileName()).absoluteFilePath());

        }

    } else {

        PRINT_FILE_CREATE_ERROR(wrapperFileName);

        return false;

    }

    if (targetType == TypeSubdirs) {

        // If we have something to deploy, generate extension makefile for just that, since

        // normal extension makefile is not getting generated and we need emulator deployment to be done.

        if (generatePkg)

            writeMkFile(wrapperFileName, true);

        writeWrapperMakefile(wrapperMakefile, isPrimaryMakefile);

        return true;

    }

    writeMkFile(wrapperFileName, false);

    if (targetType == TypeExe) {

        if (!project->isActiveConfig("no_icon")) {

            writeRegRssFile(userRssRules);

            writeRssFile(numberOfIcons, iconFile);

            writeLocFile(symbianLangCodes);

            if (!project->values("SYMBIANTRANSLATIONS").isEmpty())

                writeSymbianLocFile(symbianLangCodes);

        }

    }

    writeCustomDefFile();

    writeWrapperMakefile(wrapperMakefile, isPrimaryMakefile);

    return true;

}

void SymbianMakefileGenerator::init()

{

    MakefileGenerator::init();

    SymbianCommonGenerator::init();

    if (0 != project->values("QMAKE_PLATFORM").size())

        platform = varGlue("QMAKE_PLATFORM", "", " ", "");

    if (0 == project->values("QMAKESPEC").size())

        project->values("QMAKESPEC").append(qgetenv("QMAKESPEC"));

    project->values("QMAKE_LIBS") += escapeFilePaths(project->values("LIBS"));

    project->values("QMAKE_LIBS_PRIVATE") += escapeFilePaths(project->values("LIBS_PRIVATE"));

    // bld.inf

    project->values("MAKEFILE") += BLD_INF_FILENAME;

    // .mmp

    initMmpVariables();

    uid2 = project->first("TARGET.UID2");

    uid2 = uid2.trimmed();

}

QString SymbianMakefileGenerator::getTargetExtension()

{

    QString ret;

    if (targetType == TypeExe) {

        ret.append("exe");

    } else if (targetType == TypeLib) {

        ret.append("lib");

    } else if (targetType == TypeDll || targetType == TypePlugin) {

        ret.append("dll");

    } else if (targetType == TypeSubdirs) {

        // Not actually usable, so return empty

    } else {

        // If nothing else set, default to exe

        ret.append("exe");

    }

    return ret;

}

QString SymbianMakefileGenerator::generateUID3()

{

    QString target = project->first("TARGET");

    QString currPath = qmake_getpwd();

    target.prepend("/").prepend(currPath);

    return generate_test_uid(target);

}

void SymbianMakefileGenerator::initMmpVariables()

{

    QStringList sysincspaths;

    QStringList srcincpaths;

    QStringList srcpaths;

    srcpaths << project->values("SOURCES") << project->values("GENERATED_SOURCES");

    srcpaths << project->values("UNUSED_SOURCES") << project->values("UI_SOURCES_DIR");

    srcpaths << project->values("UI_DIR");

    QDir current = QDir::current();

    QString absolutizedCurrent = absolutizePath(".");

    for (int j = 0; j < srcpaths.size(); ++j) {

        QFileInfo fi(fileInfo(srcpaths.at(j)));

        // Sometimes sources have other than *.c* files (e.g. *.moc); prune them.

        if (fi.suffix().startsWith("c")) {

            if (fi.filePath().length() > fi.fileName().length()) {

                appendIfnotExist(srcincpaths, fi.path());

                sources[absolutizePath(fi.path())] += fi.fileName();

            } else {

                sources[absolutizedCurrent] += fi.fileName();

                appendIfnotExist(srcincpaths, absolutizedCurrent);

            }

        }

    }

    QStringList incpaths;

    incpaths << project->values("INCLUDEPATH");

    incpaths << QLibraryInfo::location(QLibraryInfo::HeadersPath);

    incpaths << project->values("HEADERS");

    incpaths << srcincpaths;

    incpaths << project->values("UI_HEADERS_DIR");

    incpaths << project->values("UI_DIR");

    for (int j = 0; j < incpaths.size(); ++j) {

        QString includepath = absolutizePath(incpaths.at(j));

        appendIfnotExist(sysincspaths, includepath);

        appendAbldTempDirs(sysincspaths, includepath);

    }

    // Remove duplicate include path entries

    QStringList temporary;

    for (int i = 0; i < sysincspaths.size(); ++i) {

        QString origPath = sysincspaths.at(i);

        QFileInfo origPathInfo(fileInfo(origPath));

        bool bFound = false;

        for (int j = 0; j < temporary.size(); ++j) {

            QString tmpPath = temporary.at(j);

            QFileInfo tmpPathInfo(fileInfo(tmpPath));

            if (origPathInfo.absoluteFilePath() == tmpPathInfo.absoluteFilePath()) {

                bFound = true;

                if (!tmpPathInfo.isRelative() && origPathInfo.isRelative()) {

                    // We keep the relative notation

                    temporary.removeOne(tmpPath);

                    temporary << origPath;

                }

            }

        }

        if (!bFound)

            temporary << origPath;

    }

    sysincspaths.clear();

    sysincspaths << temporary;

    systeminclude.insert("SYSTEMINCLUDE", sysincspaths);

    // Check MMP_RULES for singleton keywords that are overridden

    QStringList overridableMmpKeywords;

    QStringList restrictableMmpKeywords;

    QStringList restrictedMmpKeywords;

    bool inResourceBlock = false;

    overridableMmpKeywords << QLatin1String(MMP_TARGETTYPE) << QLatin1String(MMP_EPOCHEAPSIZE);

    restrictableMmpKeywords << QLatin1String(MMP_TARGET) << QLatin1String(MMP_SECUREID)

       << QLatin1String(MMP_OPTION) << QLatin1String(MMP_LINKEROPTION)

       << QLatin1String(MMP_CAPABILITY) << QLatin1String(MMP_EPOCALLOWDLLDATA)

       << QLatin1String(MMP_EPOCSTACKSIZE) << QLatin1String(MMP_UID)

       << QLatin1String(MMP_VENDORID) << QLatin1String(MMP_VERSION);

    foreach (QString item, project->values("MMP_RULES")) {

        if (project->values(item).isEmpty()) {

            handleMmpRulesOverrides(item, inResourceBlock, restrictedMmpKeywords,

                                    restrictableMmpKeywords, overridableMmpKeywords);

        } else {

            foreach (QString itemRow, project->values(item)) {

                handleMmpRulesOverrides(itemRow, inResourceBlock, restrictedMmpKeywords,

                                        restrictableMmpKeywords, overridableMmpKeywords);

            }

        }

    }

    if (restrictedMmpKeywords.size()) {

        fprintf(stderr, "Warning: Restricted statements detected in MMP_RULES:\n"

                "         (%s)\n"

                "         Use corresponding qmake variable(s) instead.\n",

                qPrintable(restrictedMmpKeywords.join(", ")));

        }

}

void SymbianMakefileGenerator::handleMmpRulesOverrides(QString &checkString,

                                                       bool &inResourceBlock,

                                                       QStringList &restrictedMmpKeywords,

                                                       const QStringList &restrictableMmpKeywords,

                                                       const QStringList &overridableMmpKeywords)

{

    QString simplifiedString = checkString.simplified();

    if (!inResourceBlock && simplifiedString.startsWith(MMP_START_RESOURCE, Qt::CaseInsensitive))

        inResourceBlock = true;

    else if (inResourceBlock && simplifiedString.startsWith(MMP_END_RESOURCE, Qt::CaseInsensitive))

        inResourceBlock = false;

    // Allow restricted and overridable items in RESOURCE blocks as those do not actually

    // override anything.

    if (!inResourceBlock) {

        appendKeywordIfMatchFound(overriddenMmpKeywords, overridableMmpKeywords, simplifiedString);

        appendKeywordIfMatchFound(restrictedMmpKeywords, restrictableMmpKeywords, simplifiedString);

    }

}

void SymbianMakefileGenerator::appendKeywordIfMatchFound(QStringList &list,

                                                         const QStringList &keywordList,

                                                         QString &checkString)

{

    // Check if checkString starts with any supplied keyword and

    // add the found keyword to list if it does.

    foreach (QString item, keywordList) {

        if (checkString.startsWith(QString(item).append(" "), Qt::CaseInsensitive)

            || checkString.compare(item, Qt::CaseInsensitive) == 0) {

            appendIfnotExist(list, item);

        }

    }

}

bool SymbianMakefileGenerator::removeDuplicatedStrings(QStringList &stringList)

{

    QStringList tmpStringList;

    for (int i = 0; i < stringList.size(); ++i) {

        QString string = stringList.at(i);

        if (tmpStringList.contains(string))

            continue;

        else

            tmpStringList.append(string);

    }

    stringList.clear();

    stringList = tmpStringList;

    return true;

}

void SymbianMakefileGenerator::writeMmpFileHeader(QTextStream &t)

{

    t << "// ==============================================================================" << endl;

    t << "// Generated by qmake (" << qmake_version() << ") (Qt " QT_VERSION_STR ") on: ";

    t << QDateTime::currentDateTime().toString(Qt::ISODate) << endl;

    t << "// This file is generated by qmake and should not be modified by the" << endl;

    t << "// user." << endl;

    t << "// ==============================================================================" << endl << endl;

}

void SymbianMakefileGenerator::writeMmpFile(QString &filename, QStringList &symbianLangCodes)

{

    QFile ft(filename);

    if (ft.open(QIODevice::WriteOnly)) {

        if (Option::mkfile::listgen) {

            generatePrint(fileInfo(ft.fileName()).absoluteFilePath());

        }

        generatedFiles << ft.fileName();

        QTextStream t(&ft);

        writeMmpFileHeader(t);

        writeMmpFileTargetPart(t);