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

**

** 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 tools applications 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 "configureapp.h"

#include "environment.h"

#ifdef COMMERCIAL_VERSION

#  include "tools.h"

#endif

#include <QDate>

#include <qdir.h>

#include <qtemporaryfile.h>

#include <qstack.h>

#include <qdebug.h>

#include <qfileinfo.h>

#include <qtextstream.h>

#include <qregexp.h>

#include <qhash.h>

#include <iostream>

#include <windows.h>

#include <conio.h>

QT_BEGIN_NAMESPACE

std::ostream &operator<<(std::ostream &s, const QString &val) {

    s << val.toLocal8Bit().data();

    return s;

}

using namespace std;

// Macros to simplify options marking

#define MARK_OPTION(x,y) ( dictionary[ #x ] == #y ? "*" : " " )

bool writeToFile(const char* text, const QString &filename)

{

    QByteArray symFile(text);

    QFile file(filename);

    QDir dir(QFileInfo(file).absoluteDir());

    if (!dir.exists())

        dir.mkpath(dir.absolutePath());

    if (!file.open(QFile::WriteOnly)) {

        cout << "Couldn't write to " << qPrintable(filename) << ": " << qPrintable(file.errorString())

             << endl;

        return false;

    }

    file.write(symFile);

    return true;

}

Configure::Configure(int& argc, char** argv)

{

    useUnixSeparators = false;

    // Default values for indentation

    optionIndent = 4;

    descIndent   = 25;

    outputWidth  = 0;

    // Get console buffer output width

    CONSOLE_SCREEN_BUFFER_INFO info;

    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);

    if (GetConsoleScreenBufferInfo(hStdout, &info))

        outputWidth = info.dwSize.X - 1;

    outputWidth = qMin(outputWidth, 79); // Anything wider gets unreadable

    if (outputWidth < 35) // Insanely small, just use 79

        outputWidth = 79;

    int i;

    /*

    ** Set up the initial state, the default

    */

    dictionary[ "CONFIGCMD" ] = argv[ 0 ];

    for (i = 1; i < argc; i++)

        configCmdLine += argv[ i ];

    // Get the path to the executable

    wchar_t module_name[MAX_PATH];

    GetModuleFileName(0, module_name, sizeof(module_name) / sizeof(wchar_t));

    QFileInfo sourcePathInfo = QString::fromWCharArray(module_name);

    sourcePath = sourcePathInfo.absolutePath();

    sourceDir = sourcePathInfo.dir();

    buildPath = QDir::currentPath();

#if 0

    const QString installPath = QString("C:\\Qt\\%1").arg(QT_VERSION_STR);

#else

    const QString installPath = buildPath;

#endif

    if (sourceDir != buildDir) { //shadow builds!

        if (!findFile("perl") && !findFile("perl.exe")) {

            cout << "Error: Creating a shadow build of Qt requires" << endl

                 << "perl to be in the PATH environment";

            exit(0); // Exit cleanly for Ctrl+C

        }

        cout << "Preparing build tree..." << endl;

        QDir(buildPath).mkpath("bin");

        { //duplicate qmake

            QStack<QString> qmake_dirs;

            qmake_dirs.push("qmake");

            while (!qmake_dirs.isEmpty()) {

                QString dir = qmake_dirs.pop();

                QString od(buildPath + "/" + dir);

                QString id(sourcePath + "/" + dir);

                QFileInfoList entries = QDir(id).entryInfoList(QDir::NoDotAndDotDot|QDir::AllEntries);

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

                    QFileInfo fi(entries.at(i));

                    if (fi.isDir()) {

                        qmake_dirs.push(dir + "/" + fi.fileName());

                        QDir().mkpath(od + "/" + fi.fileName());

                    } else {

                        QDir().mkpath(od);

                        bool justCopy = true;

                        const QString fname = fi.fileName();

                        const QString outFile(od + "/" + fname), inFile(id + "/" + fname);

                        if (fi.fileName() == "Makefile") { //ignore

                        } else if (fi.suffix() == "h" || fi.suffix() == "cpp") {

                            QTemporaryFile tmpFile;

                            if (tmpFile.open()) {

                                QTextStream stream(&tmpFile);

                                stream << "#include \"" << inFile << "\"" << endl;

                                justCopy = false;

                                stream.flush();

                                tmpFile.flush();

                                if (filesDiffer(tmpFile.fileName(), outFile)) {

                                    QFile::remove(outFile);

                                    tmpFile.copy(outFile);

                                }

                            }

                        }

                        if (justCopy && filesDiffer(inFile, outFile))

                            QFile::copy(inFile, outFile);

                    }

                }

            }

        }

        { //make a syncqt script(s) that can be used in the shadow

            QFile syncqt(buildPath + "/bin/syncqt");

            if (syncqt.open(QFile::WriteOnly)) {

                QTextStream stream(&syncqt);

                stream << "#!/usr/bin/perl -w" << endl

                       << "require \"" << sourcePath + "/bin/syncqt\";" << endl;

            }

            QFile syncqt_bat(buildPath + "/bin/syncqt.bat");

            if (syncqt_bat.open(QFile::WriteOnly)) {

                QTextStream stream(&syncqt_bat);

                stream << "@echo off" << endl

                       << "set QTDIR=" << QDir::toNativeSeparators(sourcePath) << endl

                       << "call " << fixSeparators(sourcePath) << fixSeparators("/bin/syncqt.bat -outdir \"") << fixSeparators(buildPath) << "\"" << endl

                       << "set QTDIR=" << QDir::toNativeSeparators(buildPath) << endl;

                syncqt_bat.close();

            }

        }

        // make patch_capabilities and createpackage scripts for Symbian that can be used from the shadow build

        QFile patch_capabilities(buildPath + "/bin/patch_capabilities");

        if (patch_capabilities.open(QFile::WriteOnly)) {

            QTextStream stream(&patch_capabilities);

            stream << "#!/usr/bin/perl -w" << endl

                   << "require \"" << sourcePath + "/bin/patch_capabilities\";" << endl;

        }

        QFile patch_capabilities_bat(buildPath + "/bin/patch_capabilities.bat");

        if (patch_capabilities_bat.open(QFile::WriteOnly)) {

            QTextStream stream(&patch_capabilities_bat);

            stream << "@echo off" << endl

                   << "call " << fixSeparators(sourcePath) << fixSeparators("/bin/patch_capabilities.bat %*") << endl;

            patch_capabilities_bat.close();

        }

        QFile createpackage(buildPath + "/bin/createpackage");

        if (createpackage.open(QFile::WriteOnly)) {

            QTextStream stream(&createpackage);

            stream << "#!/usr/bin/perl -w" << endl

                   << "require \"" << sourcePath + "/bin/createpackage\";" << endl;

        }

        QFile createpackage_bat(buildPath + "/bin/createpackage.bat");

        if (createpackage_bat.open(QFile::WriteOnly)) {

            QTextStream stream(&createpackage_bat);

            stream << "@echo off" << endl

                   << "call " << fixSeparators(sourcePath) << fixSeparators("/bin/createpackage.bat %*") << endl;

            createpackage_bat.close();

        }

        // For Windows CE and shadow builds we need to copy these to the

        // build directory.

        QFile::copy(sourcePath + "/bin/setcepaths.bat" , buildPath + "/bin/setcepaths.bat");

        //copy the mkspecs

        buildDir.mkpath("mkspecs");

        if (!Environment::cpdir(sourcePath + "/mkspecs", buildPath + "/mkspecs")){

            cout << "Couldn't copy mkspecs!" << sourcePath << " " << buildPath << endl;

            dictionary["DONE"] = "error";

            return;

        }

    }

    dictionary[ "QT_SOURCE_TREE" ]    = fixSeparators(sourcePath);

    dictionary[ "QT_BUILD_TREE" ]     = fixSeparators(buildPath);

    dictionary[ "QT_INSTALL_PREFIX" ] = fixSeparators(installPath);

    dictionary[ "QMAKESPEC" ] = getenv("QMAKESPEC");

    if (dictionary[ "QMAKESPEC" ].size() == 0) {

        dictionary[ "QMAKESPEC" ] = Environment::detectQMakeSpec();

        dictionary[ "QMAKESPEC_FROM" ] = "detected";

    } else {

        dictionary[ "QMAKESPEC_FROM" ] = "env";

    }

    dictionary[ "ARCHITECTURE" ]    = "windows";

    dictionary[ "QCONFIG" ]         = "full";

    dictionary[ "EMBEDDED" ]        = "no";

    dictionary[ "BUILD_QMAKE" ]     = "yes";

    dictionary[ "DSPFILES" ]        = "yes";

    dictionary[ "VCPROJFILES" ]     = "yes";

    dictionary[ "QMAKE_INTERNAL" ]  = "no";

    dictionary[ "FAST" ]            = "no";

    dictionary[ "NOPROCESS" ]       = "no";

    dictionary[ "STL" ]             = "yes";

    dictionary[ "EXCEPTIONS" ]      = "yes";

    dictionary[ "RTTI" ]            = "yes";

    dictionary[ "MMX" ]             = "auto";

    dictionary[ "3DNOW" ]           = "auto";

    dictionary[ "SSE" ]             = "auto";

    dictionary[ "SSE2" ]            = "auto";

    dictionary[ "IWMMXT" ]          = "auto";

    dictionary[ "SYNCQT" ]          = "auto";

    dictionary[ "CE_CRT" ]          = "no";

    dictionary[ "CETEST" ]          = "auto";

    dictionary[ "CE_SIGNATURE" ]    = "no";

    dictionary[ "SCRIPT" ]          = "auto";

    dictionary[ "SCRIPTTOOLS" ]     = "auto";

    dictionary[ "XMLPATTERNS" ]     = "auto";

    dictionary[ "PHONON" ]          = "auto";

    dictionary[ "PHONON_BACKEND" ]  = "yes";

    dictionary[ "MULTIMEDIA" ]      = "yes";

    dictionary[ "AUDIO_BACKEND" ]   = "auto";

    dictionary[ "WMSDK" ]           = "auto";

    dictionary[ "DIRECTSHOW" ]      = "no";

    dictionary[ "WEBKIT" ]          = "auto";

    dictionary[ "DECLARATIVE" ]     = "auto";

    dictionary[ "PLUGIN_MANIFESTS" ] = "yes";

    QString version;

    QFile qglobal_h(sourcePath + "/src/corelib/global/qglobal.h");

    if (qglobal_h.open(QFile::ReadOnly)) {

        QTextStream read(&qglobal_h);

        QRegExp version_regexp("^# *define *QT_VERSION_STR *\"([^\"]*)\"");

        QString line;

        while (!read.atEnd()) {

            line = read.readLine();

            if (version_regexp.exactMatch(line)) {

                version = version_regexp.cap(1).trimmed();

                if (!version.isEmpty())

                    break;

            }

        }

        qglobal_h.close();

    }

    if (version.isEmpty())

        version = QString("%1.%2.%3").arg(QT_VERSION>>16).arg(((QT_VERSION>>8)&0xff)).arg(QT_VERSION&0xff);

    dictionary[ "VERSION" ]         = version;

    {

        QRegExp version_re("([0-9]*)\\.([0-9]*)\\.([0-9]*)(|-.*)");

        if (version_re.exactMatch(version)) {

            dictionary[ "VERSION_MAJOR" ] = version_re.cap(1);

            dictionary[ "VERSION_MINOR" ] = version_re.cap(2);

            dictionary[ "VERSION_PATCH" ] = version_re.cap(3);

        }

    }

    dictionary[ "REDO" ]            = "no";

    dictionary[ "DEPENDENCIES" ]    = "no";

    dictionary[ "BUILD" ]           = "debug";

    dictionary[ "BUILDALL" ]        = "auto"; // Means yes, but not explicitly

    dictionary[ "BUILDTYPE" ]      = "none";

    dictionary[ "BUILDDEV" ]        = "no";

    dictionary[ "BUILDNOKIA" ]      = "no";

    dictionary[ "SHARED" ]          = "yes";

    dictionary[ "ZLIB" ]            = "auto";

    dictionary[ "GIF" ]             = "auto";

    dictionary[ "TIFF" ]            = "auto";

    dictionary[ "JPEG" ]            = "auto";

    dictionary[ "PNG" ]             = "auto";

    dictionary[ "MNG" ]             = "auto";

    dictionary[ "LIBTIFF" ]         = "auto";

    dictionary[ "LIBJPEG" ]         = "auto";

    dictionary[ "LIBPNG" ]          = "auto";

    dictionary[ "LIBMNG" ]          = "auto";

    dictionary[ "FREETYPE" ]        = "no";

    dictionary[ "QT3SUPPORT" ]      = "yes";

    dictionary[ "ACCESSIBILITY" ]   = "yes";

    dictionary[ "OPENGL" ]          = "yes";

    dictionary[ "OPENVG" ]          = "no";

    dictionary[ "OPENSSL" ]         = "auto";

    dictionary[ "DBUS" ]            = "auto";

    dictionary[ "S60" ]             = "yes";

    dictionary[ "STYLE_WINDOWS" ]   = "yes";

    dictionary[ "STYLE_WINDOWSXP" ] = "auto";

    dictionary[ "STYLE_WINDOWSVISTA" ] = "auto";

    dictionary[ "STYLE_PLASTIQUE" ] = "yes";

    dictionary[ "STYLE_CLEANLOOKS" ]= "yes";

    dictionary[ "STYLE_WINDOWSCE" ] = "no";

    dictionary[ "STYLE_WINDOWSMOBILE" ] = "no";

    dictionary[ "STYLE_MOTIF" ]     = "yes";

    dictionary[ "STYLE_CDE" ]       = "yes";

    dictionary[ "STYLE_S60" ]       = "no";

    dictionary[ "STYLE_GTK" ]       = "no";

    dictionary[ "SQL_MYSQL" ]       = "no";

    dictionary[ "SQL_ODBC" ]        = "no";

    dictionary[ "SQL_OCI" ]         = "no";

    dictionary[ "SQL_PSQL" ]        = "no";

    dictionary[ "SQL_TDS" ]         = "no";

    dictionary[ "SQL_DB2" ]         = "no";

    dictionary[ "SQL_SQLITE" ]      = "auto";

    dictionary[ "SQL_SQLITE_LIB" ]  = "qt";

    dictionary[ "SQL_SQLITE2" ]     = "no";

    dictionary[ "SQL_IBASE" ]       = "no";

    dictionary[ "GRAPHICS_SYSTEM" ] = "raster";

    QString tmp = dictionary[ "QMAKESPEC" ];

    if (tmp.contains("\\")) {

        tmp = tmp.mid(tmp.lastIndexOf("\\") + 1);

    } else {

        tmp = tmp.mid(tmp.lastIndexOf("/") + 1);

    }

    dictionary[ "QMAKESPEC" ] = tmp;

    dictionary[ "INCREDIBUILD_XGE" ] = "auto";

    dictionary[ "LTCG" ]            = "no";

    dictionary[ "NATIVE_GESTURES" ] = "yes";

}

Configure::~Configure()

{

    for (int i=0; i<3; ++i) {

        QList<MakeItem*> items = makeList[i];

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

            delete items[j];

    }

}

QString Configure::fixSeparators(const QString &somePath, bool escape)

{

    if (useUnixSeparators)

        return QDir::fromNativeSeparators(somePath);

    QString ret = QDir::toNativeSeparators(somePath);

    return escape ? escapeSeparators(ret) : ret;

}

QString Configure::escapeSeparators(const QString &somePath)

{

    QString out = somePath;

    out.replace(QLatin1Char('\\'), QLatin1String("\\\\"));

    return out;

}

// We could use QDir::homePath() + "/.qt-license", but

// that will only look in the first of $HOME,$USERPROFILE

// or $HOMEDRIVE$HOMEPATH. So, here we try'em all to be

// more forgiving for the end user..

QString Configure::firstLicensePath()

{

    QStringList allPaths;

    allPaths << "./.qt-license"

             << QString::fromLocal8Bit(getenv("HOME")) + "/.qt-license"

             << QString::fromLocal8Bit(getenv("USERPROFILE")) + "/.qt-license"

             << QString::fromLocal8Bit(getenv("HOMEDRIVE")) + QString::fromLocal8Bit(getenv("HOMEPATH")) + "/.qt-license";

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

        if (QFile::exists(allPaths.at(i)))

            return allPaths.at(i);

    return QString();

}

// #### somehow I get a compiler error about vc++ reaching the nesting limit without

// undefining the ansi for scoping.

#ifdef for

#undef for

#endif

void Configure::parseCmdLine()

{

    int argCount = configCmdLine.size();

    int i = 0;

#if !defined(EVAL)

    if (argCount < 1) // skip rest if no arguments

        ;

    else if (configCmdLine.at(i) == "-redo") {

        dictionary[ "REDO" ] = "yes";

        configCmdLine.clear();

        reloadCmdLine();

    }

    else if (configCmdLine.at(i) == "-loadconfig") {

        ++i;

        if (i != argCount) {

            dictionary[ "REDO" ] = "yes";

            dictionary[ "CUSTOMCONFIG" ] = "_" + configCmdLine.at(i);

            configCmdLine.clear();

            reloadCmdLine();

        } else {

            dictionary[ "HELP" ] = "yes";

        }

        i = 0;

    }

    argCount = configCmdLine.size();

#endif

    // Look first for XQMAKESPEC

    for (int j = 0 ; j < argCount; ++j)

    {

        if (configCmdLine.at(j) == "-xplatform") {

            ++j;

            if (j == argCount)

                break;

            dictionary["XQMAKESPEC"] = configCmdLine.at(j);

            if (!dictionary[ "XQMAKESPEC" ].isEmpty())

                applySpecSpecifics();

        }

    }

    for (; i<configCmdLine.size(); ++i) {

        bool continueElse[] = {false, false};

        if (configCmdLine.at(i) == "-help"

            || configCmdLine.at(i) == "-h"

            || configCmdLine.at(i) == "-?")

            dictionary[ "HELP" ] = "yes";

#if !defined(EVAL)

        else if (configCmdLine.at(i) == "-qconfig") {

            ++i;

            if (i == argCount)

                break;

            dictionary[ "QCONFIG" ] = configCmdLine.at(i);

        }

        else if (configCmdLine.at(i) == "-buildkey") {

            ++i;

            if (i == argCount)

                break;

            dictionary[ "USER_BUILD_KEY" ] = configCmdLine.at(i);

        }

        else if (configCmdLine.at(i) == "-release") {

            dictionary[ "BUILD" ] = "release";

            if (dictionary[ "BUILDALL" ] == "auto")

                dictionary[ "BUILDALL" ] = "no";

        } else if (configCmdLine.at(i) == "-debug") {

            dictionary[ "BUILD" ] = "debug";

            if (dictionary[ "BUILDALL" ] == "auto")

                dictionary[ "BUILDALL" ] = "no";

        } else if (configCmdLine.at(i) == "-debug-and-release")

            dictionary[ "BUILDALL" ] = "yes";

        else if (configCmdLine.at(i) == "-shared")

            dictionary[ "SHARED" ] = "yes";

        else if (configCmdLine.at(i) == "-static")

            dictionary[ "SHARED" ] = "no";

        else if (configCmdLine.at(i) == "-developer-build")

            dictionary[ "BUILDDEV" ] = "yes";

        else if (configCmdLine.at(i) == "-nokia-developer") {

            cout << "Detected -nokia-developer option" << endl;