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

**

** Copyright (C) 2009 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_dsp.h"

#include "option.h"

#include <qdir.h>

#include <qset.h>

#include <stdlib.h>

QT_BEGIN_NAMESPACE

DspMakefileGenerator::DspMakefileGenerator() : Win32MakefileGenerator(), init_flag(false)

{

}

bool DspMakefileGenerator::writeMakefile(QTextStream &t)

{

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

        /* for now just dump, I need to generated an empty dsp or something.. */

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

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

        return true;

    }

    // Generate workspace file

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

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

            debug_msg(1, "Generator: MSVC: Writing workspave file");

            writeSubDirs(t);

        } else {

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

        }

        return true;

    } else if (project->first("TEMPLATE") == "vcapp" || project->first("TEMPLATE") == "vclib") {

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

           return writeDspParts(t);

        return true;

    }

    return project->isActiveConfig("build_pass");

}

bool DspMakefileGenerator::hasBuiltinCompiler(const QString &filename) const

{

    for (int i = 0; i < Option::cpp_ext.count(); ++i)

        if (filename.endsWith(Option::cpp_ext.at(i)))

            return true;

    for (int i = 0; i < Option::c_ext.count(); ++i)

        if (filename.endsWith(Option::c_ext.at(i)))

            return true;

    return false;

}

QString DspMakefileGenerator::replaceExtraCompilerVariables(const QString &var, const QStringList &in, const QStringList &out)

{

    QString ret = MakefileGenerator::replaceExtraCompilerVariables(var, in, out);

    ret.replace("$(DEFINES)",  varGlue("PRL_EXPORT_DEFINES"," -D"," -D","") +

                varGlue("DEFINES"," -D"," -D",""));

    QString incpath = this->var("MSVCDSP_INCPATH");

    incpath.replace("/I", "-I");

    ret.replace("$(INCPATH)", incpath);

    return ret;

}

// if config is part of a multibuild thenthe gule (this) has the correct MSVCDSP_PROJECT

QString DspMakefileGenerator::configName(DspMakefileGenerator * config)

{

    return var("MSVCDSP_PROJECT") + config->var("MSVCDSP_CONFIG_NAME");

}

bool DspMakefileGenerator::writeDspHeader(QTextStream &t)

{

    DspMakefileGenerator * config = this;

    if (mergedProjects.count())

        config = mergedProjects.at(0);

    t << "# Microsoft Developer Studio Project File - Name=\"" << var("MSVCDSP_PROJECT") << "\" - Package Owner=<4>" << endl;

    t << "# Microsoft Developer Studio Generated Build File, Format Version 6.00" << endl;

    t << "# ** DO NOT EDIT **" << endl;

    t << endl;

    t << "# TARGTYPE \"Win32 (x86) " << var("MSVCDSP_TARGETTYPE") << "\" " << var("MSVCDSP_DSPTYPE") << endl;

    t << endl;

    t << "CFG=\"" << configName(config) << "\"" << endl;

    t << "!MESSAGE This is not a valid makefile. To build this project using NMAKE," << endl;

    t << "!MESSAGE use the Export Makefile command and run" << endl;

    t << "!MESSAGE " << endl;

    t << "!MESSAGE NMAKE /f " << escapeFilePath(var("TARGET")) << ".mak." << endl;

    t << "!MESSAGE " << endl;

    t << "!MESSAGE You can specify a configuration when running NMAKE" << endl;

    t << "!MESSAGE by defining the macro CFG on the command line. For example:" << endl;

    t << "!MESSAGE " << endl;

    t << "!MESSAGE NMAKE /f " << escapeFilePath(var("TARGET")) << ".mak CFG=\"" << configName(config) << "\"" << endl;

    t << "!MESSAGE " << endl;

    t << "!MESSAGE Possible choices for configuration are:" << endl;

    t << "!MESSAGE " << endl;

    if (mergedProjects.count()) {

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

            DspMakefileGenerator * config = mergedProjects.at(i);

            t << "!MESSAGE \"" << configName(config) << "\" (based on \"Win32 (x86) " << config->var("MSVCDSP_TARGETTYPE") << "\")" << endl;

        }

    } else {

        t << "!MESSAGE \"" << configName(config) << "\" (based on \"Win32 (x86) " << config->var("MSVCDSP_TARGETTYPE") << "\")" << endl;

    }

    t << "!MESSAGE " << endl;

    t << endl;

    t << "# Begin Project" << endl;

    t << "# PROP AllowPerConfigDependencies 0" << endl;

    t << "# PROP Scc_ProjName \"\"" << endl;

    t << "# PROP Scc_LocalPath \"\"" << endl;

    t << "CPP=" << config->var("QMAKE_CC") << endl;

    t << "MTL=" << config->var("QMAKE_IDL") << endl;

    t << "RSC=" << config->var("QMAKE_RC") << endl;

    t << "BSC32=bscmake.exe" << endl;

    return true;

}

bool DspMakefileGenerator::writeDspParts(QTextStream &t)

{

    //bool staticLibTarget = var("MSVCDSP_DSPTYPE") == "0x0104";

    writeDspHeader(t);

    writeDspConfig(t, this);

    t << endl;

    t << "# Begin Target" << endl;

    t << endl;

    t << "# Name \"" << configName(this) << "\"" << endl;

    t << endl;

    QStringList listNames = QString("SOURCES|DEF_FILE").split("|");

    QStringList allListNames = listNames;

    writeFileGroup(t, listNames, "Source Files", "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat");

    listNames = QStringList("HEADERS");

    allListNames += listNames;

    writeFileGroup(t, QStringList("HEADERS"), "Header Files", "h;hpp;hxx;hm;inl");

    listNames = QString("FORMS|INTERFACES|FORMS3").split("|");

    allListNames += listNames;

    writeFileGroup(t, listNames, "Form Files", "ui");

    listNames = QStringList("IMAGES");

    allListNames += listNames;

    writeFileGroup(t, QStringList("IMAGES"), "Image Files", "");

    listNames = QString("RC_FILE|RESOURCES").split("|");

    allListNames += listNames;

    writeFileGroup(t, listNames, "Resources", "rc;qrc");

    listNames = QStringList("TRANSLATIONS");

    allListNames += listNames;

    writeFileGroup(t, listNames, "Translations", "ts;xlf");

    listNames = QStringList("LEXSOURCES");

    allListNames += listNames;

    writeFileGroup(t, listNames, "Lexables", "l");

    listNames = QStringList("YACCSOURCES");

    allListNames += listNames;

    writeFileGroup(t, listNames, "Yaccables", "y");

    listNames = QStringList("TYPELIBS");

    allListNames += listNames;

    writeFileGroup(t, listNames, "Type Libraries", "tlb;olb");

    if (!project->isEmpty("QMAKE_EXTRA_COMPILERS")) {

         const QStringList &quc = project->values("QMAKE_EXTRA_COMPILERS");

         for (QStringList::ConstIterator it = quc.begin(); it != quc.end(); ++it) {

            const QStringList &inputs = project->values((*it)+".input");

            for (QStringList::ConstIterator input = inputs.begin(); input != inputs.end(); ++input) {

                if (!allListNames.contains((*input)) && *input != "UIC3_HEADERS")

                    writeFileGroup(t, QStringList((*input)), (*input) + " Files", "");

            }

        }

    }

    project->values("SWAPPED_BUILD_STEPS") = swappedBuildSteps.keys();

    writeFileGroup(t, QString("GENERATED_SOURCES|GENERATED_FILES|SWAPPED_BUILD_STEPS").split("|"), "Generated", "");

    t << "# End Target" << endl;

    t << "# End Project" << endl;

    return true;

}

void

DspMakefileGenerator::init()

{

    if(init_flag)

        return;

    QStringList::Iterator it;

    init_flag = true;

    platform = "Win32";

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

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

    // this should probably not be here, but I'm using it to wrap the .t files

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

        project->values("QMAKE_APP_FLAG").append("1");

    else if(project->first("TEMPLATE") == "vclib")

        project->values("QMAKE_LIB_FLAG").append("1");

    if(project->values("QMAKESPEC").isEmpty())

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

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

    processVars();

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

        QString version = project->values("VERSION").first();

        int firstDot = version.indexOf(".");

        QString major = version.left(firstDot);

        QString minor = version.right(version.length() - firstDot - 1);

        minor.replace(".", "");

        project->values("MSVCDSP_LFLAGS").append("/VERSION:" + major + "." + minor);

    }

    QString msvcdsp_project;

    if(!project->isEmpty("TARGET")) {

        project->values("TARGET") = unescapeFilePaths(project->values("TARGET"));

        msvcdsp_project = project->first("TARGET");

    }

    MakefileGenerator::init();

    if(msvcdsp_project.isEmpty())

        msvcdsp_project = Option::output.fileName();

    msvcdsp_project = msvcdsp_project.right(msvcdsp_project.length() - msvcdsp_project.lastIndexOf("\\") - 1);

    int dotFind = msvcdsp_project.lastIndexOf(".");

    if(dotFind != -1)

        msvcdsp_project = msvcdsp_project.left(dotFind);

    msvcdsp_project.replace("-", "");

    project->values("MSVCDSP_PROJECT").append(msvcdsp_project);

    QStringList &proj = project->values("MSVCDSP_PROJECT");

    for(QStringList::Iterator it = proj.begin(); it != proj.end(); ++it)

        (*it).replace(QRegExp("\\.[a-zA-Z0-9_]*$"), "");

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

        if(project->isActiveConfig("console")) {

            project->values("MSVCDSP_TARGETTYPE").append("Console Application");

            project->values("MSVCDSP_DSPTYPE").append("0x0103");

            project->values("MSVCDSP_DEFINES").append(" /D \"_CONSOLE\" ");

        } else {

            project->values("MSVCDSP_TARGETTYPE").append("Application");

            project->values("MSVCDSP_DSPTYPE").append("0x0101");

            project->values("MSVCDSP_DEFINES").append(" /D \"_WINDOWS\" ");

        }

    } else {

        if(project->isActiveConfig("dll")) {

            project->values("MSVCDSP_TARGETTYPE").append("Dynamic-Link Library");

            project->values("MSVCDSP_DSPTYPE").append("0x0102");

            project->values("MSVCDSP_DEFINES").append(" /D \"_USRDLL\" ");

        } else {

            project->values("MSVCDSP_TARGETTYPE").append("Static Library");

            project->values("MSVCDSP_DSPTYPE").append("0x0104");

            project->values("MSVCDSP_DEFINES").append(" /D \"_LIB\" ");

        }

    }

    project->values("MSVCDSP_LFLAGS") += project->values("QMAKE_LFLAGS");

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

        project->values("MSVCDSP_LFLAGS").append(valGlue(

                                                     escapeFilePaths(project->values("QMAKE_LIBDIR")),

                                                     "/LIBPATH:"," /LIBPATH:",""));

    project->values("MSVCDSP_DEFINES").append(varGlue("DEFINES","/D ","" " /D ",""));

    project->values("MSVCDSP_DEFINES").append(varGlue("PRL_EXPORT_DEFINES","/D ","" " /D ",""));

    project->values("MSVCDSP_DEFINES").append(" /D \"WIN32\" ");

    QStringList &libs = project->values("QMAKE_LIBS");

    for(QStringList::Iterator libit = libs.begin(); libit != libs.end(); ++libit) {

        project->values("MSVCDSP_LIBS").append(" " + escapeFilePath(*libit));

    }

    QStringList &incs = project->values("INCLUDEPATH");

    for(QStringList::Iterator incit = incs.begin(); incit != incs.end(); ++incit) {

        QString inc = (*incit);

        project->values("MSVCDSP_INCPATH").append("/I" + escapeFilePath(inc));

    }

    project->values("MSVCDSP_INCPATH").append("/I" + escapeFilePath(specdir()));

    QString dest;

    QString preLinkStep;

    QString postLinkStep;

    QString copyDllStep;

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

        preLinkStep += var("QMAKE_PRE_LINK");

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

        postLinkStep += var("QMAKE_POST_LINK");

    // don't destroy the target, it is used by prl writer.

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

        dest = project->first("DESTDIR");

        project->values("DESTDIR").first() = dest;

        dest = project->values("TARGET").first() + project->first("TARGET_EXT");

        dest.prepend(project->first("DESTDIR"));

        Option::fixPathToTargetOS(dest);

        dest = escapeFilePath(dest);

        project->values("MSVCDSP_TARGET").append(

            QString("/out:") + dest);

        if(project->isActiveConfig("dll")) {

            QString imp = dest;

            imp.replace(".dll", ".lib");

            project->values("MSVCDSP_TARGET").append(QString(" /implib:") + escapeFilePath(imp));

        }

    }

    if(project->isActiveConfig("dll") && !project->values("DLLDESTDIR").isEmpty()) {

        QStringList dlldirs = project->values("DLLDESTDIR");

        if(dlldirs.count())

            copyDllStep += "\t";

        for(QStringList::Iterator dlldir = dlldirs.begin(); dlldir != dlldirs.end(); ++dlldir) {

            copyDllStep += "copy \"$(TargetPath)\" " + escapeFilePath(Option::fixPathToTargetOS(*dlldir)) + "\t";

        }

    }

    if(!preLinkStep.isEmpty()) {

        project->values("MSVCDSP_PRE_LINK").append(

            "# Begin Special Build Tool\n"

            "SOURCE=$(InputPath)\n"

            "PreLink_Desc=Post Build Step\n"

            "PreLink_Cmds=" + preLinkStep + "\n"

            "# End Special Build Tool\n");

    }

    if(!postLinkStep.isEmpty() || !copyDllStep.isEmpty()) {

        project->values("MSVCDSP_POST_LINK").append(

            "# Begin Special Build Tool\n"

            "SOURCE=$(InputPath)\n"

            "PostBuild_Desc=Post Build Step\n"

            "PostBuild_Cmds=" + postLinkStep + copyDllStep + "\n"

            "# End Special Build Tool\n");

    }

    QStringList &formList = project->values("FORMS");

    for(QStringList::ConstIterator hit = formList.begin(); hit != formList.end(); ++hit) {

        if(exists(*hit + ".h"))

            project->values("SOURCES").append(*hit + ".h");

    }

    QStringList &form3List = project->values("FORMS3");

    for(QStringList::ConstIterator hit = form3List.begin(); hit != form3List.end(); ++hit) {

        if(exists(*hit + ".h"))

            project->values("SOURCES").append(*hit + ".h");

    }

    project->values("QMAKE_INTERNAL_PRL_LIBS") << "MSVCDSP_LIBS";

    // Move some files around //### is this compat?

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

        QString imageFactory(project->first("QMAKE_IMAGE_COLLECTION"));

        project->values("GENERATED_SOURCES") += imageFactory;

        project->values("SOURCES").removeAll(imageFactory);

    }

    // Setup PCH variables

    precompH = project->first("PRECOMPILED_HEADER");

    namePCH = fileInfo(precompH).fileName();

    usePCH = !precompH.isEmpty() && project->isActiveConfig("precompile_header");

    if (usePCH) {

        // Created files

        precompObj = var("PRECOMPILED_DIR") + project->first("TARGET") + "_pch" + Option::obj_ext;

        precompPch = var("PRECOMPILED_DIR") + project->first("TARGET") + "_pch.pch";

        // Add PRECOMPILED_HEADER to HEADERS

        if (!project->values("HEADERS").contains(precompH))

            project->values("HEADERS") += precompH;

        // Add precompile compiler options

        project->values("PRECOMPILED_FLAGS")  = QStringList("/Fp" + precompPch + " /Yu" + escapeFilePath(namePCH) + " /FI" + escapeFilePath(namePCH) + " ");

        // Return to variable pool

        project->values("PRECOMPILED_OBJECT") = QStringList(precompObj);

        project->values("PRECOMPILED_PCH")    = QStringList(precompPch);

    }

    QString buildName;

    if (!var("BUILD_NAME").isEmpty())

        buildName =  var("BUILD_NAME");

    else if (project->isActiveConfig("debug"))

        buildName = "Debug";

    else

        buildName = "Release";

    project->values("MSVCDSP_CONFIG_NAME") = QStringList(" - " + platform + " " + buildName);

}

void DspMakefileGenerator::processPrlVariable(const QString &var, const QStringList &l)

{

    if(var == "QMAKE_PRL_DEFINES") {

        QStringList &out = project->values("MSVCDSP_DEFINES");

        for(QStringList::ConstIterator it = l.begin(); it != l.end(); ++it) {

            if(out.indexOf((*it)) == -1)

                out.append((" /D \"" + *it + "\""));

        }

    } else {

        MakefileGenerator::processPrlVariable(var, l);

    }

}

bool DspMakefileGenerator::openOutput(QFile &file, const QString &build) const

{

    QString outdir;

    if(!file.fileName().isEmpty()) {

        if(QDir::isRelativePath(file.fileName()))

            file.setFileName(Option::output_dir + "/" + file.fileName()); //pwd when qmake was run

        QFileInfo fi(fileInfo(file.fileName()));

        if(fi.isDir())

            outdir = file.fileName() + QDir::separator();

    }

    if(!outdir.isEmpty() || file.fileName().isEmpty()) {

        QString ext = project->first("DSP_EXTENSION");

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

            if (!project->first("DSW_EXTENSION").isEmpty())

                ext = project->first("DSW_EXTENSION");

            else

                ext = ".dsw";

        }

        QString outputName = unescapeFilePath(project->first("QMAKE_DSP_PROJECT_NAME"));

        if (!project->first("MAKEFILE").isEmpty())

            outputName = unescapeFilePath(project->first("MAKEFILE"));

        if (outputName.isEmpty())

            outputName = unescapeFilePath(project->first("QMAKE_ORIG_TARGET"));

        file.setFileName(outdir + outputName + ext);

    }

    if(QDir::isRelativePath(file.fileName())) {

        QString ofile = Option::fixPathToLocalOS(file.fileName());

        int slashfind = ofile.lastIndexOf(Option::dir_sep);

        if(slashfind == -1) {

            ofile = ofile.replace(QRegExp("-"), "_");

        } else {

            int hypenfind = ofile.indexOf('-', slashfind);

            while (hypenfind != -1 && slashfind < hypenfind) {

                ofile = ofile.replace(hypenfind, 1, "_");

                hypenfind = ofile.indexOf('-', hypenfind + 1);

            }

        }

        file.setFileName(Option::fixPathToLocalOS(qmake_getpwd() + Option::dir_sep + ofile));

    }

    return Win32MakefileGenerator::openOutput(file, build);

}

bool DspMakefileGenerator::mergeBuildProject(MakefileGenerator *other)

{

    mergedProjects.prepend(static_cast<DspMakefileGenerator*>(other));

    return true;

}

bool DspMakefileGenerator::writeProjectMakefile()

{

    bool ret = true;

    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 DSP: no single configuration created, cannot output project!");

            return false;

        }

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

        writeDspHeader(t);

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

            DspMakefileGenerator* config = mergedProjects.at(i);

            t << endl;

            if (i == 0)

                t << "!IF";

            else

                t << "!ELSEIF";

            t << "  \"$(CFG)\" == \"" << configName(config) << "\"" << endl;

            t << endl;

            writeDspConfig(t, config);

        }

        t << endl;

        t << "!ENDIF " << endl;

        t << endl;