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

**

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

#include "option.h"

#include "project.h"

#include "meta.h"

#include <qtextstream.h>

#include <qstring.h>

#include <qhash.h>

#include <qregexp.h>

#include <qstringlist.h>

#include <qdir.h>

#include <stdlib.h>

QT_BEGIN_NAMESPACE

Win32MakefileGenerator::Win32MakefileGenerator() : MakefileGenerator()

{

}

int

Win32MakefileGenerator::findHighestVersion(const QString &d, const QString &stem, const QString &ext)

{

    QString bd = Option::fixPathToLocalOS(d, true);

    if(!exists(bd))

        return -1;

    QString dllStem = stem + QTDLL_POSTFIX;

    QMakeMetaInfo libinfo;

    bool libInfoRead = libinfo.readLib(bd + Option::dir_sep + dllStem);

    // If the library, for which we're trying to find the highest version

    // number, is a static library

    if (libInfoRead && libinfo.values("QMAKE_PRL_CONFIG").contains("staticlib"))

        return -1;

    if(!project->values("QMAKE_" + stem.toUpper() + "_VERSION_OVERRIDE").isEmpty())

        return project->values("QMAKE_" + stem.toUpper() + "_VERSION_OVERRIDE").first().toInt();

    int biggest=-1;

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

        QDir dir(bd);

        QStringList entries = dir.entryList();

        QRegExp regx(QString("((lib)?%1([0-9]*)).(%2|prl)$").arg(dllStem).arg(ext), Qt::CaseInsensitive);

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

            if(regx.exactMatch((*it))) {

				if (!regx.cap(3).isEmpty()) {

					bool ok = true;

					int num = regx.cap(3).toInt(&ok);

					biggest = qMax(biggest, (!ok ? -1 : num));

				}

			}

        }

    }

    if(libInfoRead

       && !libinfo.values("QMAKE_PRL_CONFIG").contains("staticlib")

       && !libinfo.isEmpty("QMAKE_PRL_VERSION"))

       biggest = qMax(biggest, libinfo.first("QMAKE_PRL_VERSION").replace(".", "").toInt());

    return biggest;

}

bool

Win32MakefileGenerator::findLibraries(const QString &where)

{

    QStringList &l = project->values(where);

    QList<QMakeLocalFileName> dirs;

    {

        QStringList &libpaths = project->values("QMAKE_LIBDIR");

        for(QStringList::Iterator libpathit = libpaths.begin();

            libpathit != libpaths.end(); ++libpathit)

            dirs.append(QMakeLocalFileName((*libpathit)));

    }

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

        QChar quote;

        bool modified_opt = false, remove = false;

        QString opt = (*it).trimmed();

        if((opt[0] == '\'' || opt[0] == '"') && opt[(int)opt.length()-1] == opt[0]) {

            quote = opt[0];

            opt = opt.mid(1, opt.length()-2);

        }

        if(opt.startsWith("/LIBPATH:")) {

            dirs.append(QMakeLocalFileName(opt.mid(9)));

        } else if(opt.startsWith("-L") || opt.startsWith("/L")) {

            QString libpath = opt.mid(2);

            QMakeLocalFileName l(libpath);

            if(!dirs.contains(l)) {

                dirs.append(l);

                modified_opt = true;

                if (!quote.isNull()) {

                    libpath = quote + libpath + quote;

                    quote = QChar();

                }

                (*it) = "/LIBPATH:" + libpath;

            } else {

                remove = true;

            }

        } else if(opt.startsWith("-l") || opt.startsWith("/l")) {

            QString lib = opt.right(opt.length() - 2), out;

            if(!lib.isEmpty()) {

                QString suffix;

                if(!project->isEmpty("QMAKE_" + lib.toUpper() + "_SUFFIX"))

                    suffix = project->first("QMAKE_" + lib.toUpper() + "_SUFFIX");

                for(QList<QMakeLocalFileName>::Iterator it = dirs.begin();

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

                    QString extension;

                    int ver = findHighestVersion((*it).local(), lib);

                    if(ver > 0)

                        extension += QString::number(ver);

                    extension += suffix;

                    extension += ".lib";

                    if(QMakeMetaInfo::libExists((*it).local() + Option::dir_sep + lib) ||

                       exists((*it).local() + Option::dir_sep + lib + extension)) {

                        out = (*it).real() + Option::dir_sep + lib + extension;

                        break;

                    }

                }

            }

            if(out.isEmpty())

                out = lib + ".lib";

            modified_opt = true;

            (*it) = out;

        } else if(!exists(Option::fixPathToLocalOS(opt))) {

            QList<QMakeLocalFileName> lib_dirs;

            QString file = opt;

            int slsh = file.lastIndexOf(Option::dir_sep);

            if(slsh != -1) {

                lib_dirs.append(QMakeLocalFileName(file.left(slsh+1)));

                file = file.right(file.length() - slsh - 1);

            } else {

                lib_dirs = dirs;

            }

            if(file.endsWith(".lib")) {

                file = file.left(file.length() - 4);

                if(!file.at(file.length()-1).isNumber()) {

                    QString suffix;

                    if(!project->isEmpty("QMAKE_" + file.section(Option::dir_sep, -1).toUpper() + "_SUFFIX"))

                        suffix = project->first("QMAKE_" + file.section(Option::dir_sep, -1).toUpper() + "_SUFFIX");

                    for(QList<QMakeLocalFileName>::Iterator dep_it = lib_dirs.begin(); dep_it != lib_dirs.end(); ++dep_it) {

                        QString lib_tmpl(file + "%1" + suffix + ".lib");

                        int ver = findHighestVersion((*dep_it).local(), file);

                        if(ver != -1) {

                            if(ver)

                                lib_tmpl = lib_tmpl.arg(ver);

                            else

                                lib_tmpl = lib_tmpl.arg("");

                            if(slsh != -1) {

                                QString dir = (*dep_it).real();

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

                                    dir += Option::dir_sep;

                                lib_tmpl.prepend(dir);

                            }

                            modified_opt = true;

                            (*it) = lib_tmpl;

                            break;

                        }

                    }

                }

            }

        }

        if(remove) {

            it = l.erase(it);

        } else {

            if(!quote.isNull() && modified_opt)

                (*it) = quote + (*it) + quote;

            ++it;

        }

    }

    return true;

}

void

Win32MakefileGenerator::processPrlFiles()

{

    QHash<QString, bool> processed;

    QList<QMakeLocalFileName> libdirs;

    {

        QStringList &libpaths = project->values("QMAKE_LIBDIR");

        for(QStringList::Iterator libpathit = libpaths.begin(); libpathit != libpaths.end(); ++libpathit)

            libdirs.append(QMakeLocalFileName((*libpathit)));

    }

    for(bool ret = false; true; ret = false) {

        //read in any prl files included..

        QStringList l_out;

        QString where = "QMAKE_LIBS";

        if(!project->isEmpty("QMAKE_INTERNAL_PRL_LIBS"))

            where = project->first("QMAKE_INTERNAL_PRL_LIBS");

        QStringList l = project->values(where);

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

            QString opt = (*it).trimmed();

            if((opt[0] == '\'' || opt[0] == '"') && opt[(int)opt.length()-1] == opt[0])

                opt = opt.mid(1, opt.length()-2);

            if(opt.startsWith("/")) {

                if(opt.startsWith("/LIBPATH:")) {

                    QMakeLocalFileName l(opt.mid(9));

                    if(!libdirs.contains(l))

                        libdirs.append(l);

                }

            } else if(!processed.contains(opt)) {

                if(processPrlFile(opt)) {

                    processed.insert(opt, true);

                    ret = true;

                } else if(QDir::isRelativePath(opt) || opt.startsWith("-l")) {

                    QString tmp;

                    if (opt.startsWith("-l"))

                        tmp = opt.mid(2);

                    else

                        tmp = opt;

                    for(QList<QMakeLocalFileName>::Iterator it = libdirs.begin(); it != libdirs.end(); ++it) {

                        QString prl = (*it).local() + Option::dir_sep + tmp;

                        // the original is used as the key

                        QString orgprl = prl;

                        if(processed.contains(prl)) {

                            break;

                        } else if(processPrlFile(prl)) {

                            processed.insert(orgprl, true);

                            ret = true;

                            break;

                        }

                    }

                }

            }

            if(!opt.isEmpty())

                l_out.append(opt);

        }

        if(ret)

            l = l_out;

        else

            break;

    }

}

void Win32MakefileGenerator::processVars()

{

    //If the TARGET looks like a path split it into DESTDIR and the resulting TARGET

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

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

        int slsh = qMax(targ.lastIndexOf('/'), targ.lastIndexOf(Option::dir_sep));

        if(slsh != -1) {

            if(project->isEmpty("DESTDIR"))

                project->values("DESTDIR").append("");

            else if(project->first("DESTDIR").right(1) != Option::dir_sep)

                project->values("DESTDIR") = QStringList(project->first("DESTDIR") + Option::dir_sep);

            project->values("DESTDIR") = QStringList(project->first("DESTDIR") + targ.left(slsh+1));

            project->values("TARGET") = QStringList(targ.mid(slsh+1));

        }

    }

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

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

        project->values("INCLUDEPATH") += project->values("QMAKE_INCDIR");

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

        QStringList l = project->first("VERSION").split('.');

        if (l.size() > 0)

            project->values("VER_MAJ").append(l[0]);

        if (l.size() > 1)

            project->values("VER_MIN").append(l[1]);

    }

    // TARGET_VERSION_EXT will be used to add a version number onto the target name

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

        && !project->values("VER_MAJ").isEmpty())

        project->values("TARGET_VERSION_EXT").append(project->values("VER_MAJ").first());

    if(project->isEmpty("QMAKE_COPY_FILE"))

        project->values("QMAKE_COPY_FILE").append("$(COPY)");

    if(project->isEmpty("QMAKE_COPY_DIR"))

        project->values("QMAKE_COPY_DIR").append("xcopy /s /q /y /i");

    if(project->isEmpty("QMAKE_INSTALL_FILE"))

        project->values("QMAKE_INSTALL_FILE").append("$(COPY_FILE)");

    if(project->isEmpty("QMAKE_INSTALL_PROGRAM"))

        project->values("QMAKE_INSTALL_PROGRAM").append("$(COPY_FILE)");

    if(project->isEmpty("QMAKE_INSTALL_DIR"))

        project->values("QMAKE_INSTALL_DIR").append("$(COPY_DIR)");

    fixTargetExt();

    processRcFileVar();

    processFileTagsVar();

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

    for(QStringList::Iterator incDir_it = incDir.begin(); incDir_it != incDir.end(); ++incDir_it) {

    if(!(*incDir_it).isEmpty())

        (*incDir_it) = Option::fixPathToTargetOS((*incDir_it), false, false);

    }

    QStringList &libDir = project->values("QMAKE_LIBDIR");

    for(QStringList::Iterator libDir_it = libDir.begin(); libDir_it != libDir.end(); ++libDir_it) {

    if(!(*libDir_it).isEmpty())

        (*libDir_it) = Option::fixPathToTargetOS((*libDir_it), false, false);

    }

}

void Win32MakefileGenerator::fixTargetExt()

{

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

        project->values("TARGET_EXT").append(".exe");

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

        project->values("TARGET_EXT").append(project->first("TARGET_VERSION_EXT") + ".dll");

    else

        project->values("TARGET_EXT").append(".lib");

}

void Win32MakefileGenerator::processRcFileVar()

{

    if (Option::qmake_mode == Option::QMAKE_GENERATE_NOTHING)

        return;

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

        && project->values("RC_FILE").isEmpty()

        && project->values("RES_FILE").isEmpty()

        && !project->isActiveConfig("no_generated_target_info")

        && (project->isActiveConfig("shared") || !project->values("QMAKE_APP_FLAG").isEmpty()))

        || !project->values("QMAKE_WRITE_DEFAULT_RC").isEmpty()){

        QByteArray rcString;

        QTextStream ts(&rcString, QFile::WriteOnly);

        QStringList vers = project->values("VERSION").first().split(".");

        for (int i = vers.size(); i < 4; i++)

            vers += "0";

        QString versionString = vers.join(".");

        QString companyName;

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

            companyName = project->values("QMAKE_TARGET_COMPANY").join(" ");

        QString description;

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

            description = project->values("QMAKE_TARGET_DESCRIPTION").join(" ");

        QString copyright;

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

            copyright = project->values("QMAKE_TARGET_COPYRIGHT").join(" ");

        QString productName;

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

            productName = project->values("QMAKE_TARGET_PRODUCT").join(" ");

        else

            productName = project->values("TARGET").first();

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

        ts << "# if defined(UNDER_CE)" << endl;

        ts << "#  include <winbase.h>" << endl;

        ts << "# else" << endl;

        ts << "#  include <winver.h>" << endl;

        ts << "# endif" << endl;

        ts << endl;

        ts << "VS_VERSION_INFO VERSIONINFO" << endl;

        ts << "\tFILEVERSION " << QString(versionString).replace(".", ",") << endl;

        ts << "\tPRODUCTVERSION " << QString(versionString).replace(".", ",") << endl;

        ts << "\tFILEFLAGSMASK 0x3fL" << endl;

        ts << "#ifdef _DEBUG" << endl;

        ts << "\tFILEFLAGS VS_FF_DEBUG" << endl;

        ts << "#else" << endl;

        ts << "\tFILEFLAGS 0x0L" << endl;

        ts << "#endif" << endl;

        ts << "\tFILEOS VOS__WINDOWS32" << endl;

        if (project->isActiveConfig("shared"))

            ts << "\tFILETYPE VFT_DLL" << endl;

        else

            ts << "\tFILETYPE VFT_APP" << endl;

        ts << "\tFILESUBTYPE 0x0L" << endl;

        ts << "\tBEGIN" << endl;

        ts << "\t\tBLOCK \"StringFileInfo\"" << endl;

        ts << "\t\tBEGIN" << endl;

        ts << "\t\t\tBLOCK \"040904B0\"" << endl;

        ts << "\t\t\tBEGIN" << endl;

        ts << "\t\t\t\tVALUE \"CompanyName\", \"" << companyName << "\\0\"" << endl;

        ts << "\t\t\t\tVALUE \"FileDescription\", \"" <<  description << "\\0\"" << endl;

        ts << "\t\t\t\tVALUE \"FileVersion\", \"" << versionString << "\\0\"" << endl;

        ts << "\t\t\t\tVALUE \"LegalCopyright\", \"" << copyright << "\\0\"" << endl;

        ts << "\t\t\t\tVALUE \"OriginalFilename\", \"" << originalName << "\\0\"" << endl;

        ts << "\t\t\t\tVALUE \"ProductName\", \"" << productName << "\\0\"" << endl;

        ts << "\t\t\tEND" << endl;

        ts << "\t\tEND" << endl;

        ts << "\tEND" << endl;

        ts << "/* End of Version info */" << endl;

        ts << endl;

        ts.flush();

        QString rcFilename = project->values("OUT_PWD").first()

                           + "/"

                           + project->values("TARGET").first()

                           + "_resource"

                           + ".rc";

        QFile rcFile(QDir::cleanPath(rcFilename));

        bool writeRcFile = true;

        if (rcFile.exists() && rcFile.open(QFile::ReadOnly)) {

            writeRcFile = rcFile.readAll() != rcString;

            rcFile.close();

        }

        if (writeRcFile) {

	    bool ok;

	    ok = rcFile.open(QFile::WriteOnly);

	    if (!ok) {

		// The file can't be opened... try creating the containing

		// directory first (needed for clean shadow builds)

		QDir().mkpath(QFileInfo(rcFile).path());

		ok = rcFile.open(QFile::WriteOnly);

	    }

	    if (!ok) {

		::fprintf(stderr, "Cannot open for writing: %s", rcFile.fileName().toLatin1().constData());

		::exit(1);

	    }

            if (Option::mkfile::listgen) {

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

            }

            rcFile.write(rcString);

	    rcFile.close();

        }

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

            project->values("RC_FILE").insert(0, rcFile.fileName());

    }

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

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

            fprintf(stderr, "Both rc and res file specified.\n");

            fprintf(stderr, "Please specify one of them, not both.");

            exit(1);

        }

        QString resFile = project->values("RC_FILE").first();

        // if this is a shadow build then use the absolute path of the rc file

        if (Option::output_dir != qmake_getpwd()) {

            QFileInfo fi(resFile);

            project->values("RC_FILE").first() = fi.absoluteFilePath();

        }

        resFile.replace(".rc", Option::res_ext);

        project->values("RES_FILE").prepend(fileInfo(resFile).fileName());

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

            if(project->isActiveConfig("staticlib"))

                project->values("RES_FILE").first().prepend(fileInfo(project->values("DESTDIR").first()).absoluteFilePath() + Option::dir_sep);

            else

              project->values("RES_FILE").first().prepend(project->values("OBJECTS_DIR").first() + Option::dir_sep);

        project->values("RES_FILE").first() = Option::fixPathToTargetOS(project->values("RES_FILE").first(), false, false);

	project->values("POST_TARGETDEPS") += project->values("RES_FILE");

        project->values("CLEAN_FILES") += project->values("RES_FILE");

    }

}

void Win32MakefileGenerator::processFileTagsVar()

{

    QStringList tags;

    tags << "SOURCES" << "GENERATED_SOURCES" << "DEF_FILE" << "RC_FILE"

         << "TARGET" << "QMAKE_LIBS" << "DESTDIR" << "DLLDESTDIR" << "INCLUDEPATH";

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

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

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

            tags += project->values((*it)+".input");

    }

    //clean path

    QStringList &filetags = project->values("QMAKE_FILETAGS");

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

        filetags += Option::fixPathToTargetOS(tags.at(i), false);

}

void Win32MakefileGenerator::writeCleanParts(QTextStream &t)

{

    t << "clean: compiler_clean " << var("CLEAN_DEPS");

    {

        const char *clean_targets[] = { "OBJECTS", "QMAKE_CLEAN", "CLEAN_FILES", 0 };

        for(int i = 0; clean_targets[i]; ++i) {

            const QStringList &list = project->values(clean_targets[i]);

            const QString del_statement("-$(DEL_FILE)");

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

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

                    t << "\n\t" << del_statement << " " << escapeFilePath((*it));

            } else {

                QString files, file;

                const int commandlineLimit = 2047; // NT limit, expanded

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

                    file = " " + escapeFilePath((*it));

                    if(del_statement.length() + files.length() +

                       qMax(fixEnvVariables(file).length(), file.length()) > commandlineLimit) {

                        t << "\n\t" << del_statement << files;

                        files.clear();

                    }

                    files += file;

                }

                if(!files.isEmpty())

                    t << "\n\t" << del_statement << files;

            }

        }

    }