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

**

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

#include "option.h"

#include "xmloutput.h"

#include <qdir.h>

#include <qdiriterator.h>

#include <qcryptographichash.h>

#include <qregexp.h>

#include <qhash.h>

#include <quuid.h>

#include <stdlib.h>

//#define DEBUG_SOLUTION_GEN

//#define DEBUG_PROJECT_GEN

QT_BEGIN_NAMESPACE

// Filter GUIDs (Do NOT change these!) ------------------------------

const char _GUIDSourceFiles[]          = "{4FC737F1-C7A5-4376-A066-2A32D752A2FF}";

const char _GUIDHeaderFiles[]          = "{93995380-89BD-4b04-88EB-625FBE52EBFB}";

const char _GUIDGeneratedFiles[]       = "{71ED8ED8-ACB9-4CE9-BBE1-E00B30144E11}";

const char _GUIDResourceFiles[]        = "{D9D6E242-F8AF-46E4-B9FD-80ECBC20BA3E}";

const char _GUIDLexYaccFiles[]         = "{E12AE0D2-192F-4d59-BD23-7D3FA58D3183}";

const char _GUIDTranslationFiles[]     = "{639EADAA-A684-42e4-A9AD-28FC9BCB8F7C}";

const char _GUIDFormFiles[]            = "{99349809-55BA-4b9d-BF79-8FDBB0286EB3}";

const char _GUIDExtraCompilerFiles[]   = "{E0D8C965-CC5F-43d7-AD63-FAEF0BBC0F85}";

QT_END_NAMESPACE

#ifdef Q_OS_WIN32

#include <qt_windows.h>

#include <windows/registry.h>

QT_BEGIN_NAMESPACE

struct {

    DotNET version;

    const char *versionStr;

    const char *regKey;

} dotNetCombo[] = {

#ifdef Q_OS_WIN64

    {NET2010, "MSVC.NET 2010 (10.0)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\10.0\\Setup\\VC\\ProductDir"},

    {NET2010, "MSVC.NET 2010 Express Edition (10.0)", "Software\\Wow6432Node\\Microsoft\\VCExpress\\10.0\\Setup\\VC\\ProductDir"},

    {NET2008, "MSVC.NET 2008 (9.0)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\9.0\\Setup\\VC\\ProductDir"},

    {NET2008, "MSVC.NET 2008 Express Edition (9.0)", "Software\\Wow6432Node\\Microsoft\\VCExpress\\9.0\\Setup\\VC\\ProductDir"},

    {NET2005, "MSVC.NET 2005 (8.0)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\8.0\\Setup\\VC\\ProductDir"},

    {NET2005, "MSVC.NET 2005 Express Edition (8.0)", "Software\\Wow6432Node\\Microsoft\\VCExpress\\8.0\\Setup\\VC\\ProductDir"},

    {NET2003, "MSVC.NET 2003 (7.1)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\7.1\\Setup\\VC\\ProductDir"},

    {NET2002, "MSVC.NET 2002 (7.0)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\7.0\\Setup\\VC\\ProductDir"},

#else

    {NET2010, "MSVC.NET 2010 (10.0)", "Software\\Microsoft\\VisualStudio\\10.0\\Setup\\VC\\ProductDir"},

    {NET2010, "MSVC.NET 2010 Express Edition (10.0)", "Software\\Microsoft\\VCExpress\\10.0\\Setup\\VC\\ProductDir"},

    {NET2008, "MSVC.NET 2008 (9.0)", "Software\\Microsoft\\VisualStudio\\9.0\\Setup\\VC\\ProductDir"},

    {NET2008, "MSVC.NET 2008 Express Edition (9.0)", "Software\\Microsoft\\VCExpress\\9.0\\Setup\\VC\\ProductDir"},

    {NET2005, "MSVC.NET 2005 (8.0)", "Software\\Microsoft\\VisualStudio\\8.0\\Setup\\VC\\ProductDir"},

    {NET2005, "MSVC.NET 2005 Express Edition (8.0)", "Software\\Microsoft\\VCExpress\\8.0\\Setup\\VC\\ProductDir"},

    {NET2003, "MSVC.NET 2003 (7.1)", "Software\\Microsoft\\VisualStudio\\7.1\\Setup\\VC\\ProductDir"},

    {NET2002, "MSVC.NET 2002 (7.0)", "Software\\Microsoft\\VisualStudio\\7.0\\Setup\\VC\\ProductDir"},

#endif

    {NETUnknown, "", ""},

};

QT_END_NAMESPACE

#endif

QT_BEGIN_NAMESPACE

DotNET which_dotnet_version()

{

#ifndef Q_OS_WIN32

    return NET2002; // Always generate 7.0 versions on other platforms

#else

    // Only search for the version once

    static DotNET current_version = NETUnknown;

    if(current_version != NETUnknown)

        return current_version;

    // Fallback to .NET 2002

    current_version = NET2002;

    QStringList warnPath;

    int installed = 0;

    int i = 0;

    for(; dotNetCombo[i].version; ++i) {

        QString path = readRegistryKey(HKEY_LOCAL_MACHINE, dotNetCombo[i].regKey);

        if(!path.isEmpty()) {

            ++installed;

            current_version = dotNetCombo[i].version;

                        warnPath += QString("%1").arg(dotNetCombo[i].versionStr);

        }

    }

    if (installed < 2)

        return current_version;

    // More than one version installed, search directory path

    QString paths = qgetenv("PATH");

    QStringList pathlist = paths.toLower().split(";");

    i = installed = 0;

    for(; dotNetCombo[i].version; ++i) {

        QString productPath = readRegistryKey(HKEY_LOCAL_MACHINE, dotNetCombo[i].regKey).toLower();

                if (productPath.isEmpty())

                        continue;

        QStringList::iterator it;

        for(it = pathlist.begin(); it != pathlist.end(); ++it) {

            if((*it).contains(productPath)) {

                ++installed;

                current_version = dotNetCombo[i].version;

                warnPath += QString("%1 in path").arg(dotNetCombo[i].versionStr);

                                break;

            }

        }

    }

        switch(installed) {

        case 1:

                break;

        case 0:

                warn_msg(WarnLogic, "Generator: MSVC.NET: Found more than one version of Visual Studio, but"

                                 " none in your path! Fallback to lowest version (%s)", warnPath.join(", ").toLatin1().data());

                break;

        default:

                warn_msg(WarnLogic, "Generator: MSVC.NET: Found more than one version of Visual Studio in"

                                 " your path! Fallback to lowest version (%s)", warnPath.join(", ").toLatin1().data());

                break;

        }

    return current_version;

#endif

};

// Flatfile Tags ----------------------------------------------------

const char _slnHeader70[]       = "Microsoft Visual Studio Solution File, Format Version 7.00";

const char _slnHeader71[]       = "Microsoft Visual Studio Solution File, Format Version 8.00";

const char _slnHeader80[]       = "Microsoft Visual Studio Solution File, Format Version 9.00"

                                  "\n# Visual Studio 2005";

const char _slnHeader90[]       = "Microsoft Visual Studio Solution File, Format Version 10.00"

                                  "\n# Visual Studio 2008";

const char _slnHeader100[]      = "Microsoft Visual Studio Solution File, Format Version 11.00"

                                  "\n# Visual Studio 2010";

                                  // The following UUID _may_ change for later servicepacks...

                                  // If so we need to search through the registry at

                                  // HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\7.0\Projects

                                  // to find the subkey that contains a "PossibleProjectExtension"

                                  // containing "vcproj"...

                                  // Use the hardcoded value for now so projects generated on other

                                  // platforms are actually usable.

const char _slnMSVCvcprojGUID[] = "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}";

const char _slnProjectBeg[]     = "\nProject(\"";

const char _slnProjectMid[]     = "\") = ";

const char _slnProjectEnd[]     = "\nEndProject";

const char _slnGlobalBeg[]      = "\nGlobal";

const char _slnGlobalEnd[]      = "\nEndGlobal";

const char _slnSolutionConf[]   = "\n\tGlobalSection(SolutionConfiguration) = preSolution"

                                  "\n\t\tConfigName.0 = Debug|Win32"

                                  "\n\t\tConfigName.1 = Release|Win32"

                                  "\n\tEndGlobalSection";

const char _slnProjDepBeg[]     = "\n\tGlobalSection(ProjectDependencies) = postSolution";

const char _slnProjDepEnd[]     = "\n\tEndGlobalSection";

const char _slnProjConfBeg[]    = "\n\tGlobalSection(ProjectConfiguration) = postSolution";

const char _slnProjRelConfTag1[]= ".Release|%1.ActiveCfg = Release|";

const char _slnProjRelConfTag2[]= ".Release|%1.Build.0 = Release|";

const char _slnProjDbgConfTag1[]= ".Debug|%1.ActiveCfg = Debug|";

const char _slnProjDbgConfTag2[]= ".Debug|%1.Build.0 = Debug|";

const char _slnProjConfEnd[]    = "\n\tEndGlobalSection";

const char _slnExtSections[]    = "\n\tGlobalSection(ExtensibilityGlobals) = postSolution"

                                  "\n\tEndGlobalSection"

                                  "\n\tGlobalSection(ExtensibilityAddIns) = postSolution"

                                  "\n\tEndGlobalSection";

// ------------------------------------------------------------------

VcprojGenerator::VcprojGenerator() : Win32MakefileGenerator(), init_flag(false)

{

}

bool VcprojGenerator::writeMakefile(QTextStream &t)

{

    initProject(); // Fills the whole project with proper data

    // Generate solution file

    if(project->first("TEMPLATE") == "vcsubdirs") {

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

            debug_msg(1, "Generator: MSVC.NET: Writing solution file");

            writeSubDirs(t);

        } else {

            debug_msg(1, "Generator: MSVC.NET: Not writing solution file for build_pass configs");

        }

        return true;

    } else

    // Generate single configuration project file

    if (project->first("TEMPLATE") == "vcapp" ||

        project->first("TEMPLATE") == "vclib") {

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

            debug_msg(1, "Generator: MSVC.NET: Writing single configuration project file");

            XmlOutput xmlOut(t);

            xmlOut << vcProject;

        }

        return true;

    }

    return project->isActiveConfig("build_pass");

}

bool VcprojGenerator::writeProjectMakefile()

{

    usePlatformDir();

    QTextStream t(&Option::output);

    // Check if all requirements are fulfilled

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

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

                var("QMAKE_FAILED_REQUIREMENTS").toLatin1().constData());

        return true;

    }

    // Generate project file

    if(project->first("TEMPLATE") == "vcapp" ||

       project->first("TEMPLATE") == "vclib") {

        if (!mergedProjects.count()) {

            warn_msg(WarnLogic, "Generator: MSVC.NET: no single configuration created, cannot output project!");

            return false;

        }

        debug_msg(1, "Generator: MSVC.NET: Writing project file");

        VCProject mergedProject;

        for (int i = 0; i < mergedProjects.count(); ++i) {

            VCProjectSingleConfig *singleProject = &(mergedProjects.at(i)->vcProject);

            mergedProject.SingleProjects += *singleProject;

            for (int j = 0; j < singleProject->ExtraCompilersFiles.count(); ++j) {

                const QString &compilerName = singleProject->ExtraCompilersFiles.at(j).Name;

                if (!mergedProject.ExtraCompilers.contains(compilerName))

                    mergedProject.ExtraCompilers += compilerName;

            }

        }

        if(mergedProjects.count() > 1 &&

           mergedProjects.at(0)->vcProject.Name ==

           mergedProjects.at(1)->vcProject.Name)

            mergedProjects.at(0)->writePrlFile();

        mergedProject.Name = unescapeFilePath(project->first("QMAKE_ORIG_TARGET"));

        mergedProject.Version = mergedProjects.at(0)->vcProject.Version;

        mergedProject.ProjectGUID = project->isEmpty("QMAKE_UUID") ? getProjectUUID().toString().toUpper() : project->first("QMAKE_UUID");

        mergedProject.Keyword = project->first("VCPROJ_KEYWORD");

        mergedProject.SccProjectName = mergedProjects.at(0)->vcProject.SccProjectName;

        mergedProject.SccLocalPath = mergedProjects.at(0)->vcProject.SccLocalPath;

        mergedProject.PlatformName = mergedProjects.at(0)->vcProject.PlatformName;

        XmlOutput xmlOut(t);

        xmlOut << mergedProject;

        return true;

    } else if(project->first("TEMPLATE") == "vcsubdirs") {

        return writeMakefile(t);

    }

    return false;

}

struct VcsolutionDepend {

    QString uuid;

    QString vcprojFile, orig_target, target;

    Target targetType;

    QStringList dependencies;

};

QUuid VcprojGenerator::getProjectUUID(const QString &filename)

{

    bool validUUID = true;

    // Read GUID from variable-space

    QUuid uuid = project->first("GUID");

    // If none, create one based on the MD5 of absolute project path

    if(uuid.isNull() || !filename.isEmpty()) {

        QString abspath = Option::fixPathToLocalOS(filename.isEmpty()?project->first("QMAKE_MAKEFILE"):filename);

        QByteArray digest = QCryptographicHash::hash(abspath.toUtf8(), QCryptographicHash::Md5);

        memcpy((unsigned char*)(&uuid), digest.constData(), sizeof(QUuid));

        validUUID = !uuid.isNull();

        uuid.data4[0] = (uuid.data4[0] & 0x3F) | 0x80; // UV_DCE variant

        uuid.data3 = (uuid.data3 & 0x0FFF) | (QUuid::Name<<12);

    }

    // If still not valid, generate new one, and suggest adding to .pro

    if(uuid.isNull() || !validUUID) {

        uuid = QUuid::createUuid();

        fprintf(stderr,

                "qmake couldn't create a GUID based on filepath, and we couldn't\nfind a valid GUID in the .pro file (Consider adding\n'GUID = %s'  to the .pro file)\n",

                uuid.toString().toUpper().toLatin1().constData());

    }

    // Store GUID in variable-space

    project->values("GUID") = QStringList(uuid.toString().toUpper());

    return uuid;

}

QUuid VcprojGenerator::increaseUUID(const QUuid &id)

{

    QUuid result(id);

    qint64 dataFirst = (result.data4[0] << 24) +

                       (result.data4[1] << 16) +

                       (result.data4[2] << 8) +

                        result.data4[3];

    qint64 dataLast =  (result.data4[4] << 24) +

                       (result.data4[5] << 16) +

                       (result.data4[6] <<  8) +

                        result.data4[7];

    if(!(dataLast++))

        dataFirst++;

    result.data4[0] = uchar((dataFirst >> 24) & 0xff);

    result.data4[1] = uchar((dataFirst >> 16) & 0xff);

    result.data4[2] = uchar((dataFirst >>  8) & 0xff);

    result.data4[3] = uchar(dataFirst         & 0xff);

    result.data4[4] = uchar((dataLast  >> 24) & 0xff);

    result.data4[5] = uchar((dataLast  >> 16) & 0xff);

    result.data4[6] = uchar((dataLast  >>  8) & 0xff);

    result.data4[7] = uchar(dataLast          & 0xff);

    return result;

}

void VcprojGenerator::writeSubDirs(QTextStream &t)

{

    // Check if all requirements are fulfilled

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

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

                var("QMAKE_FAILED_REQUIREMENTS").toLatin1().constData());

        return;

    }

    switch(which_dotnet_version()) {

    case NET2010:

        t << _slnHeader100;

        break;

    case NET2008:

        t << _slnHeader90;

        break;

    case NET2005:

        t << _slnHeader80;

        break;

    case NET2003:

        t << _slnHeader71;

        break;

    case NET2002:

        t << _slnHeader70;

        break;

    default:

        t << _slnHeader70;

        warn_msg(WarnLogic, "Generator: MSVC.NET: Unknown version (%d) of MSVC detected for .sln", which_dotnet_version());

        break;

    }

    QHash<QString, VcsolutionDepend*> solution_depends;

    QList<VcsolutionDepend*> solution_cleanup;

    QStringList subdirs = project->values("SUBDIRS");

    QString oldpwd = qmake_getpwd();

    // Make sure that all temp projects are configured

    // for release so that the depends are created

    // without the debug <lib>dxxx.lib name mangling

    QStringList old_after_vars = Option::after_user_vars;

    Option::after_user_vars.append("CONFIG+=release");

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

        QString tmp = subdirs.at(i);

        if(!project->isEmpty(tmp + ".file")) {

            if(!project->isEmpty(tmp + ".subdir"))

                warn_msg(WarnLogic, "Cannot assign both file and subdir for subdir %s",

                         tmp.toLatin1().constData());

            tmp = project->first(tmp + ".file");

        } else if(!project->isEmpty(tmp + ".subdir")) {

            tmp = project->first(tmp + ".subdir");

        }

        QFileInfo fi(fileInfo(Option::fixPathToLocalOS(tmp, true)));

        if(fi.exists()) {

            if(fi.isDir()) {

                QString profile = tmp;

                if(!profile.endsWith(Option::dir_sep))

                    profile += Option::dir_sep;

                profile += fi.baseName() + Option::pro_ext;

                subdirs.append(profile);

            } else {

                QMakeProject tmp_proj;

                QString dir = fi.path(), fn = fi.fileName();

                if(!dir.isEmpty()) {

                    if(!qmake_setpwd(dir))

                        fprintf(stderr, "Cannot find directory: %s\n", dir.toLatin1().constData());

                }

                if(tmp_proj.read(fn)) {

                    // Check if all requirements are fulfilled

                    if(!tmp_proj.variables()["QMAKE_FAILED_REQUIREMENTS"].isEmpty()) {

                        fprintf(stderr, "Project file(%s) not added to Solution because all requirements not met:\n\t%s\n",

                                fn.toLatin1().constData(), tmp_proj.values("QMAKE_FAILED_REQUIREMENTS").join(" ").toLatin1().constData());

                        continue;

                    }

                    if(tmp_proj.first("TEMPLATE") == "vcsubdirs") {

                        QStringList tmp_proj_subdirs = tmp_proj.variables()["SUBDIRS"];

                        for(int x = 0; x < tmp_proj_subdirs.size(); ++x) {

                            QString tmpdir = tmp_proj_subdirs.at(x);

                            if(!tmp_proj.isEmpty(tmpdir + ".file")) {

                                if(!tmp_proj.isEmpty(tmpdir + ".subdir"))

                                    warn_msg(WarnLogic, "Cannot assign both file and subdir for subdir %s",

                                            tmpdir.toLatin1().constData());

                                tmpdir = tmp_proj.first(tmpdir + ".file");

                            } else if(!tmp_proj.isEmpty(tmpdir + ".subdir")) {

                                tmpdir = tmp_proj.first(tmpdir + ".subdir");

                            }

                            subdirs += fileFixify(tmpdir);

                        }

                    } else if(tmp_proj.first("TEMPLATE") == "vcapp" || tmp_proj.first("TEMPLATE") == "vclib") {

                        // Initialize a 'fake' project to get the correct variables

                        // and to be able to extract all the dependencies

                        Option::QMAKE_MODE old_mode = Option::qmake_mode;

                        Option::qmake_mode = Option::QMAKE_GENERATE_NOTHING;

                        VcprojGenerator tmp_vcproj;

                        tmp_vcproj.setNoIO(true);

                        tmp_vcproj.setProjectFile(&tmp_proj);

                        Option::qmake_mode = old_mode;

                        if(Option::debug_level) {

                            QMap<QString, QStringList> &vars = tmp_proj.variables();

                            for(QMap<QString, QStringList>::Iterator it = vars.begin();

                                it != vars.end(); ++it) {

                                if(it.key().left(1) != "." && !it.value().isEmpty())

                                    debug_msg(1, "%s: %s === %s", fn.toLatin1().constData(), it.key().toLatin1().constData(),

                                                it.value().join(" :: ").toLatin1().constData());

                            }

                        }

                        // We assume project filename is [QMAKE_ORIG_TARGET].vcproj

                        QString vcproj = unescapeFilePath(tmp_vcproj.project->first("QMAKE_ORIG_TARGET") + project->first("VCPROJ_EXTENSION"));

                        QString vcprojDir = qmake_getpwd();

                        // If file doesn't exsist, then maybe the users configuration

                        // doesn't allow it to be created. Skip to next...

                        if(!exists(vcprojDir + Option::dir_sep + vcproj)) {

                            // Try to find the directory which fits relative

                            // to the output path, which represents the shadow

                            // path in case we are shadow building

                            QStringList list = fi.path().split(QLatin1Char('/'));

                            QString tmpDir = QFileInfo(Option::output).path() + Option::dir_sep;

                            bool found = false;

                            for (int i = list.size() - 1; i >= 0; --i) {

                                QString curr;

                                for (int j = i; j < list.size(); ++j)

                                    curr += list.at(j) + Option::dir_sep;

                                if (exists(tmpDir + curr + vcproj)) {

                                    vcprojDir = QDir::cleanPath(tmpDir + curr);

                                    found = true;

                                    break;

                                }

                            }

                            if (!found) {

                                warn_msg(WarnLogic, "Ignored (not found) '%s'", QString(vcprojDir + Option::dir_sep + vcproj).toLatin1().constData());

                                goto nextfile; // # Dirty!

                            }

                        }

                        VcsolutionDepend *newDep = new VcsolutionDepend;

                        newDep->vcprojFile = vcprojDir + Option::dir_sep + vcproj;

                        newDep->orig_target = unescapeFilePath(tmp_proj.first("QMAKE_ORIG_TARGET"));

                        newDep->target = tmp_proj.first("MSVCPROJ_TARGET").section(Option::dir_sep, -1);

                        newDep->targetType = tmp_vcproj.projectTarget;

                        newDep->uuid = tmp_proj.isEmpty("QMAKE_UUID") ? getProjectUUID(Option::fixPathToLocalOS(vcprojDir + QDir::separator() + vcproj)).toString().toUpper(): tmp_proj.first("QMAKE_UUID");

                        // We want to store it as the .lib name.

                        if(newDep->target.endsWith(".dll"))

                            newDep->target = newDep->target.left(newDep->target.length()-3) + "lib";

                        // All ActiveQt Server projects are dependent on idc.exe

                        if(tmp_proj.variables()["CONFIG"].contains("qaxserver"))

                            newDep->dependencies << "idc.exe";

                        // All extra compilers which has valid input are considered dependencies

                        const QStringList &quc = tmp_proj.variables()["QMAKE_EXTRA_COMPILERS"];

                        for(QStringList::ConstIterator it = quc.constBegin(); it != quc.constEnd(); ++it) {

                            const QStringList &invar = tmp_proj.variables().value((*it) + ".input");

                            for(QStringList::ConstIterator iit = invar.constBegin(); iit != invar.constEnd(); ++iit) {

                                const QStringList fileList = tmp_proj.variables().value(*iit);

                                if (!fileList.isEmpty()) {

                                    const QStringList &cmdsParts = tmp_proj.variables().value((*it) + ".commands");

                                    bool startOfLine = true;

                                    foreach(QString cmd, cmdsParts) {

                                        if (!startOfLine) {

                                            if (cmd.contains("\r"))

                                                startOfLine = true;

                                            continue;

                                        }

                                        if (cmd.isEmpty())

                                            continue;

                                        startOfLine = false;

                                        // Extra compiler commands might be defined in variables, so