tools/configure/configureapp.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the tools applications of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "configureapp.h"
  43 #include "environment.h"
  44 #ifdef COMMERCIAL_VERSION
  45 #  include "tools.h"
  46 #endif
  47
  48 #include <QDate>
  49 #include <qdir.h>
  50 #include <qdiriterator.h>
  51 #include <qtemporaryfile.h>
  52 #include <qstack.h>
  53 #include <qdebug.h>
  54 #include <qfileinfo.h>
  55 #include <qtextstream.h>
  56 #include <qregexp.h>
  57 #include <qhash.h>
  58
  59 #include <iostream>
  60 #include <string>
  61 #include <fstream>
  62 #include <windows.h>
  63 #include <conio.h>
  64
  65 QT_BEGIN_NAMESPACE
  66
  67 enum Platforms {
  68     WINDOWS,
  69     WINDOWS_CE,
  70     QNX,
  71     BLACKBERRY
  72 };
  73
  74 std::ostream &operator<<(std::ostream &s, const QString &val) {
  75     s << val.toLocal8Bit().data();
  76     return s;
  77 }
  78
  79
  80 using namespace std;
  81
  82 // Macros to simplify options marking
  83 #define MARK_OPTION(x,y) ( dictionary[ #x ] == #y ? "*" : " " )
  84
  85
  86 bool writeToFile(const char* text, const QString &filename)
  87 {
  88     QByteArray symFile(text);
  89     QFile file(filename);
  90     QDir dir(QFileInfo(file).absoluteDir());
  91     if (!dir.exists())
  92         dir.mkpath(dir.absolutePath());
  93     if (!file.open(QFile::WriteOnly | QFile::Text)) {
  94         cout << "Couldn't write to " << qPrintable(filename) << ": " << qPrintable(file.errorString())
  95              << endl;
  96         return false;
  97     }
  98     file.write(symFile);
  99     return true;
 100 }
 101
 102 Configure::Configure(int& argc, char** argv)
 103 {
 104     // Default values for indentation
 105     optionIndent = 4;
 106     descIndent   = 25;
 107     outputWidth  = 0;
 108     // Get console buffer output width
 109     CONSOLE_SCREEN_BUFFER_INFO info;
 110     HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
 111     if (GetConsoleScreenBufferInfo(hStdout, &info))
 112         outputWidth = info.dwSize.X - 1;
 113     outputWidth = qMin(outputWidth, 79); // Anything wider gets unreadable
 114     if (outputWidth < 35) // Insanely small, just use 79
 115         outputWidth = 79;
 116     int i;
 117
 118     /*
 119     ** Set up the initial state, the default
 120     */
 121     dictionary[ "CONFIGCMD" ] = argv[ 0 ];
 122
 123     for (i = 1; i < argc; i++)
 124         configCmdLine += argv[ i ];
 125
 126     if (configCmdLine.size() >= 2 && configCmdLine.at(0) == "-srcdir") {
 127         sourcePath = QDir::cleanPath(configCmdLine.at(1));
 128         sourceDir = QDir(sourcePath);
 129         configCmdLine.erase(configCmdLine.begin(), configCmdLine.begin() + 2);
 130     } else {
 131         // Get the path to the executable
 132         wchar_t module_name[MAX_PATH];
 133         GetModuleFileName(0, module_name, sizeof(module_name) / sizeof(wchar_t));
 134         QFileInfo sourcePathInfo = QString::fromWCharArray(module_name);
 135         sourcePath = sourcePathInfo.absolutePath();
 136         sourceDir = sourcePathInfo.dir();
 137     }
 138     buildPath = QDir::currentPath();
 139 #if 0
 140     const QString installPath = QString("C:\\Qt\\%1").arg(QT_VERSION_STR);
 141 #else
 142     const QString installPath = buildPath;
 143 #endif
 144     if (sourceDir != buildDir) { //shadow builds!
 145         if (!findFile("perl") && !findFile("perl.exe")) {
 146             cout << "Error: Creating a shadow build of Qt requires" << endl
 147                  << "perl to be in the PATH environment";
 148             exit(0); // Exit cleanly for Ctrl+C
 149         }
 150
 151         cout << "Preparing build tree..." << endl;
 152         QDir(buildPath).mkpath("bin");
 153
 154         { //make a syncqt script(s) that can be used in the shadow
 155             QFile syncqt(buildPath + "/bin/syncqt");
 156             // no QFile::Text, just in case the perl interpreter can't cope with them (unlikely)
 157             if (syncqt.open(QFile::WriteOnly)) {
 158                 QTextStream stream(&syncqt);
 159                 stream << "#!/usr/bin/perl -w" << endl
 160                        << "require \"" << sourcePath + "/bin/syncqt\";" << endl;
 161             }
 162             QFile syncqt_bat(buildPath + "/bin/syncqt.bat");
 163             if (syncqt_bat.open(QFile::WriteOnly | QFile::Text)) {
 164                 QTextStream stream(&syncqt_bat);
 165                 stream << "@echo off" << endl
 166                        << "call " << QDir::toNativeSeparators(sourcePath + "/bin/syncqt.bat")
 167                        << " -qtdir \"" << QDir::toNativeSeparators(buildPath) << "\" %*" << endl;
 168                 syncqt_bat.close();
 169             }
 170         }
 171
 172         QFile configtests(buildPath + "/bin/qtmodule-configtests");
 173         // no QFile::Text, just in case the perl interpreter can't cope with them (unlikely)
 174         if (configtests.open(QFile::WriteOnly)) {
 175             QTextStream stream(&configtests);
 176             stream << "#!/usr/bin/perl -w" << endl
 177                    << "require \"" << sourcePath + "/bin/qtmodule-configtests\";" << endl;
 178         }
 179         // For Windows CE and shadow builds we need to copy these to the
 180         // build directory.
 181         QFile::copy(sourcePath + "/bin/setcepaths.bat" , buildPath + "/bin/setcepaths.bat");
 182         //copy the mkspecs
 183         buildDir.mkpath("mkspecs");
 184         if (!Environment::cpdir(sourcePath + "/mkspecs", buildPath + "/mkspecs")){
 185             cout << "Couldn't copy mkspecs!" << sourcePath << " " << buildPath << endl;
 186             dictionary["DONE"] = "error";
 187             return;
 188         }
 189     }
 190
 191     defaultBuildParts << QStringLiteral("libs") << QStringLiteral("tools") << QStringLiteral("examples");
 192     dictionary[ "QT_SOURCE_TREE" ]    = sourcePath;
 193     dictionary[ "QT_BUILD_TREE" ]     = buildPath;
 194     dictionary[ "QT_INSTALL_PREFIX" ] = installPath;
 195
 196     dictionary[ "QMAKESPEC" ] = getenv("QMAKESPEC");
 197     if (dictionary[ "QMAKESPEC" ].size() == 0) {
 198         dictionary[ "QMAKESPEC" ] = Environment::detectQMakeSpec();
 199         dictionary[ "QMAKESPEC_FROM" ] = "detected";
 200     } else {
 201         dictionary[ "QMAKESPEC_FROM" ] = "env";
 202     }
 203
 204     dictionary[ "QCONFIG" ]         = "full";
 205     dictionary[ "EMBEDDED" ]        = "no";
 206     dictionary[ "BUILD_QMAKE" ]     = "yes";
 207     dictionary[ "DSPFILES" ]        = "yes";
 208     dictionary[ "VCPROJFILES" ]     = "yes";
 209     dictionary[ "QMAKE_INTERNAL" ]  = "no";
 210     dictionary[ "FAST" ]            = "no";
 211     dictionary[ "NOPROCESS" ]       = "no";
 212     dictionary[ "WIDGETS" ]         = "yes";
 213     dictionary[ "RTTI" ]            = "yes";
 214     dictionary[ "SSE2" ]            = "auto";
 215     dictionary[ "SSE3" ]            = "auto";
 216     dictionary[ "SSSE3" ]           = "auto";
 217     dictionary[ "SSE4_1" ]          = "auto";
 218     dictionary[ "SSE4_2" ]          = "auto";
 219     dictionary[ "AVX" ]             = "auto";
 220     dictionary[ "AVX2" ]            = "auto";
 221     dictionary[ "IWMMXT" ]          = "auto";
 222     dictionary[ "SYNCQT" ]          = "auto";
 223     dictionary[ "CE_CRT" ]          = "no";
 224     dictionary[ "CETEST" ]          = "auto";
 225     dictionary[ "CE_SIGNATURE" ]    = "no";
 226     dictionary[ "PHONON_BACKEND" ]  = "yes";
 227     dictionary[ "AUDIO_BACKEND" ]   = "auto";
 228     dictionary[ "WMSDK" ]           = "auto";
 229     dictionary[ "DIRECTSHOW" ]      = "no";
 230     dictionary[ "V8SNAPSHOT" ]      = "auto";
 231     dictionary[ "QML_DEBUG" ]       = "yes";
 232     dictionary[ "PLUGIN_MANIFESTS" ] = "yes";
 233     dictionary[ "DIRECTWRITE" ]     = "no";
 234     dictionary[ "NIS" ]             = "no";
 235     dictionary[ "NEON" ]            = "no";
 236     dictionary[ "LARGE_FILE" ]      = "yes";
 237     dictionary[ "FONT_CONFIG" ]     = "no";
 238     dictionary[ "POSIX_IPC" ]       = "no";
 239     dictionary[ "QT_GLIB" ]         = "no";
 240     dictionary[ "QT_ICONV" ]        = "auto";
 241     dictionary[ "QT_CUPS" ]         = "auto";
 242     dictionary[ "CFG_GCC_SYSROOT" ] = "yes";
 243
 244     //Only used when cross compiling.
 245     dictionary[ "QT_INSTALL_SETTINGS" ] = "/etc/xdg";
 246
 247     QString version;
 248     QFile qglobal_h(sourcePath + "/src/corelib/global/qglobal.h");
 249     if (qglobal_h.open(QFile::ReadOnly)) {
 250         QTextStream read(&qglobal_h);
 251         QRegExp version_regexp("^# *define *QT_VERSION_STR *\"([^\"]*)\"");
 252         QString line;
 253         while (!read.atEnd()) {
 254             line = read.readLine();
 255             if (version_regexp.exactMatch(line)) {
 256                 version = version_regexp.cap(1).trimmed();
 257                 if (!version.isEmpty())
 258                     break;
 259             }
 260         }
 261         qglobal_h.close();
 262     }
 263
 264     if (version.isEmpty())
 265         version = QString("%1.%2.%3").arg(QT_VERSION>>16).arg(((QT_VERSION>>8)&0xff)).arg(QT_VERSION&0xff);
 266
 267     dictionary[ "VERSION" ]         = version;
 268     {
 269         QRegExp version_re("([0-9]*)\\.([0-9]*)\\.([0-9]*)(|-.*)");
 270         if (version_re.exactMatch(version)) {
 271             dictionary[ "VERSION_MAJOR" ] = version_re.cap(1);
 272             dictionary[ "VERSION_MINOR" ] = version_re.cap(2);
 273             dictionary[ "VERSION_PATCH" ] = version_re.cap(3);
 274         }
 275     }
 276
 277     dictionary[ "REDO" ]            = "no";
 278     dictionary[ "DEPENDENCIES" ]    = "no";
 279
 280     dictionary[ "BUILD" ]           = "debug";
 281     dictionary[ "BUILDALL" ]        = "auto"; // Means yes, but not explicitly
 282
 283     dictionary[ "BUILDTYPE" ]      = "none";
 284
 285     dictionary[ "BUILDDEV" ]        = "no";
 286
 287     dictionary[ "SHARED" ]          = "yes";
 288
 289     dictionary[ "ZLIB" ]            = "auto";
 290
 291     dictionary[ "PCRE" ]            = "auto";
 292
 293     dictionary[ "ICU" ]             = "auto";
 294
 295     dictionary[ "GIF" ]             = "auto";
 296     dictionary[ "JPEG" ]            = "auto";
 297     dictionary[ "PNG" ]             = "auto";
 298     dictionary[ "LIBJPEG" ]         = "auto";
 299     dictionary[ "LIBPNG" ]          = "auto";
 300     dictionary[ "FREETYPE" ]        = "yes";
 301
 302     dictionary[ "ACCESSIBILITY" ]   = "yes";
 303     dictionary[ "OPENGL" ]          = "yes";
 304     dictionary[ "OPENVG" ]          = "no";
 305     dictionary[ "OPENSSL" ]         = "auto";
 306     dictionary[ "DBUS" ]            = "auto";
 307
 308     dictionary[ "STYLE_WINDOWS" ]   = "yes";
 309     dictionary[ "STYLE_WINDOWSXP" ] = "auto";
 310     dictionary[ "STYLE_WINDOWSVISTA" ] = "auto";
 311     dictionary[ "STYLE_PLASTIQUE" ] = "yes";
 312     dictionary[ "STYLE_CLEANLOOKS" ]= "yes";
 313     dictionary[ "STYLE_WINDOWSCE" ] = "no";
 314     dictionary[ "STYLE_WINDOWSMOBILE" ] = "no";
 315     dictionary[ "STYLE_MOTIF" ]     = "yes";
 316     dictionary[ "STYLE_CDE" ]       = "yes";
 317     dictionary[ "STYLE_GTK" ]       = "no";
 318
 319     dictionary[ "SQL_MYSQL" ]       = "no";
 320     dictionary[ "SQL_ODBC" ]        = "no";
 321     dictionary[ "SQL_OCI" ]         = "no";
 322     dictionary[ "SQL_PSQL" ]        = "no";
 323     dictionary[ "SQL_TDS" ]         = "no";
 324     dictionary[ "SQL_DB2" ]         = "no";
 325     dictionary[ "SQL_SQLITE" ]      = "auto";
 326     dictionary[ "SQL_SQLITE_LIB" ]  = "qt";
 327     dictionary[ "SQL_SQLITE2" ]     = "no";
 328     dictionary[ "SQL_IBASE" ]       = "no";
 329
 330     QString tmp = dictionary[ "QMAKESPEC" ];
 331     if (tmp.contains("\\")) {
 332         tmp = tmp.mid(tmp.lastIndexOf("\\") + 1);
 333     } else {
 334         tmp = tmp.mid(tmp.lastIndexOf("/") + 1);
 335     }
 336     dictionary[ "QMAKESPEC" ] = tmp;
 337
 338     dictionary[ "INCREDIBUILD_XGE" ] = "auto";
 339     dictionary[ "LTCG" ]            = "no";
 340     dictionary[ "NATIVE_GESTURES" ] = "yes";
 341     dictionary[ "MSVC_MP" ] = "no";
 342 }
 343
 344 Configure::~Configure()
 345 {
 346     for (int i=0; i<3; ++i) {
 347         QList<MakeItem*> items = makeList[i];
 348         for (int j=0; j<items.size(); ++j)
 349             delete items[j];
 350     }
 351 }
 352
 353 QString Configure::formatPath(const QString &path)
 354 {
 355     QString ret = QDir::cleanPath(path);
 356     // This amount of quoting is deemed sufficient.
 357     if (ret.contains(QLatin1Char(' '))) {
 358         ret.prepend(QLatin1Char('"'));
 359         ret.append(QLatin1Char('"'));
 360     }
 361     return ret;
 362 }
 363
 364 QString Configure::formatPaths(const QStringList &paths)
 365 {
 366     QString ret;
 367     foreach (const QString &path, paths) {
 368         if (!ret.isEmpty())
 369             ret += QLatin1Char(' ');
 370         ret += formatPath(path);
 371     }
 372     return ret;
 373 }
 374
 375 // We could use QDir::homePath() + "/.qt-license", but
 376 // that will only look in the first of $HOME,$USERPROFILE
 377 // or $HOMEDRIVE$HOMEPATH. So, here we try'em all to be
 378 // more forgiving for the end user..
 379 QString Configure::firstLicensePath()
 380 {
 381     QStringList allPaths;
 382     allPaths << "./.qt-license"
 383              << QString::fromLocal8Bit(getenv("HOME")) + "/.qt-license"
 384              << QString::fromLocal8Bit(getenv("USERPROFILE")) + "/.qt-license"
 385              << QString::fromLocal8Bit(getenv("HOMEDRIVE")) + QString::fromLocal8Bit(getenv("HOMEPATH")) + "/.qt-license";
 386     for (int i = 0; i< allPaths.count(); ++i)
 387         if (QFile::exists(allPaths.at(i)))
 388             return allPaths.at(i);
 389     return QString();
 390 }
 391
 392 // #### somehow I get a compiler error about vc++ reaching the nesting limit without
 393 // undefining the ansi for scoping.
 394 #ifdef for
 395 #undef for
 396 #endif
 397
 398 void Configure::parseCmdLine()
 399 {
 400     int argCount = configCmdLine.size();
 401     int i = 0;
 402     const QStringList imageFormats = QStringList() << "gif" << "png" << "jpeg";
 403
 404 #if !defined(EVAL)
 405     if (argCount < 1) // skip rest if no arguments
 406         ;
 407     else if (configCmdLine.at(i) == "-redo") {
 408         dictionary[ "REDO" ] = "yes";
 409         configCmdLine.clear();
 410         reloadCmdLine();
 411     }
 412     else if (configCmdLine.at(i) == "-loadconfig") {
 413         ++i;
 414         if (i != argCount) {
 415             dictionary[ "REDO" ] = "yes";
 416             dictionary[ "CUSTOMCONFIG" ] = "_" + configCmdLine.at(i);
 417             configCmdLine.clear();
 418             reloadCmdLine();
 419         } else {
 420             dictionary[ "HELP" ] = "yes";
 421         }
 422         i = 0;
 423     }
 424     argCount = configCmdLine.size();
 425 #endif
 426
 427     // Look first for XQMAKESPEC
 428     for (int j = 0 ; j < argCount; ++j)
 429     {
 430         if (configCmdLine.at(j) == "-xplatform") {
 431             ++j;
 432             if (j == argCount)
 433                 break;
 434             dictionary["XQMAKESPEC"] = configCmdLine.at(j);
 435             if (!dictionary[ "XQMAKESPEC" ].isEmpty())
 436                 applySpecSpecifics();
 437         }
 438     }
 439
 440     for (; i<configCmdLine.size(); ++i) {
 441         bool continueElse[] = {false, false};
 442         if (configCmdLine.at(i) == "-help"
 443             || configCmdLine.at(i) == "-h"
 444             || configCmdLine.at(i) == "-?")
 445             dictionary[ "HELP" ] = "yes";
 446
 447 #if !defined(EVAL)
 448         else if (configCmdLine.at(i) == "-qconfig") {
 449             ++i;
 450             if (i == argCount)
 451                 break;
 452             dictionary[ "QCONFIG" ] = configCmdLine.at(i);
 453         }
 454
 455         else if (configCmdLine.at(i) == "-release") {
 456             dictionary[ "BUILD" ] = "release";
 457             if (dictionary[ "BUILDALL" ] == "auto")
 458                 dictionary[ "BUILDALL" ] = "no";
 459         } else if (configCmdLine.at(i) == "-debug") {
 460             dictionary[ "BUILD" ] = "debug";
 461             if (dictionary[ "BUILDALL" ] == "auto")
 462                 dictionary[ "BUILDALL" ] = "no";
 463         } else if (configCmdLine.at(i) == "-debug-and-release")
 464             dictionary[ "BUILDALL" ] = "yes";
 465
 466         else if (configCmdLine.at(i) == "-shared")
 467             dictionary[ "SHARED" ] = "yes";
 468         else if (configCmdLine.at(i) == "-static")
 469             dictionary[ "SHARED" ] = "no";
 470         else if (configCmdLine.at(i) == "-developer-build")
 471             dictionary[ "BUILDDEV" ] = "yes";
 472         else if (configCmdLine.at(i) == "-opensource") {
 473             dictionary[ "BUILDTYPE" ] = "opensource";
 474         }
 475         else if (configCmdLine.at(i) == "-commercial") {
 476             dictionary[ "BUILDTYPE" ] = "commercial";
 477         }
 478         else if (configCmdLine.at(i) == "-ltcg") {
 479             dictionary[ "LTCG" ] = "yes";
 480         }
 481         else if (configCmdLine.at(i) == "-no-ltcg") {
 482             dictionary[ "LTCG" ] = "no";
 483         }
 484         else if (configCmdLine.at(i) == "-mp") {
 485             dictionary[ "MSVC_MP" ] = "yes";
 486         }
 487         else if (configCmdLine.at(i) == "-no-mp") {
 488             dictionary[ "MSVC_MP" ] = "no";
 489         }
 490         else if (configCmdLine.at(i) == "-force-asserts") {
 491             dictionary[ "FORCE_ASSERTS" ] = "yes";
 492         }
 493
 494
 495 #endif
 496
 497         else if (configCmdLine.at(i) == "-platform") {
 498             ++i;
 499             if (i == argCount)
 500                 break;
 501             dictionary[ "QMAKESPEC" ] = configCmdLine.at(i);
 502         dictionary[ "QMAKESPEC_FROM" ] = "commandline";
 503         } else if (configCmdLine.at(i) == "-arch") {
 504             ++i;
 505             if (i == argCount)
 506                 break;
 507             dictionary["OBSOLETE_ARCH_ARG"] = "yes";
 508         } else if (configCmdLine.at(i) == "-embedded") {
 509             dictionary[ "EMBEDDED" ] = "yes";
 510         } else if (configCmdLine.at(i) == "-xplatform") {
 511             ++i;
 512             // do nothing
 513         }
 514
 515
 516 #if !defined(EVAL)
 517         else if (configCmdLine.at(i) == "-no-zlib") {
 518             // No longer supported since Qt 4.4.0
 519             // But save the information for later so that we can print a warning
 520             //
 521             // If you REALLY really need no zlib support, you can still disable
 522             // it by doing the following:
 523             //   add "no-zlib" to mkspecs/qconfig.pri
 524             //   #define QT_NO_COMPRESS (probably by adding to src/corelib/global/qconfig.h)
 525             //
 526             // There's no guarantee that Qt will build under those conditions
 527
 528             dictionary[ "ZLIB_FORCED" ] = "yes";
 529         } else if (configCmdLine.at(i) == "-qt-zlib") {
 530             dictionary[ "ZLIB" ] = "qt";
 531         } else if (configCmdLine.at(i) == "-system-zlib") {
 532             dictionary[ "ZLIB" ] = "system";
 533         }
 534
 535         else if (configCmdLine.at(i) == "-qt-pcre") {
 536             dictionary[ "PCRE" ] = "qt";
 537         } else if (configCmdLine.at(i) == "-system-pcre") {
 538             dictionary[ "PCRE" ] = "system";
 539         }
 540
 541         else if (configCmdLine.at(i) == "-icu") {
 542             dictionary[ "ICU" ] = "yes";
 543         } else if (configCmdLine.at(i) == "-no-icu") {
 544             dictionary[ "ICU" ] = "no";
 545         }
 546
 547         // Image formats --------------------------------------------
 548         else if (configCmdLine.at(i) == "-no-gif")
 549             dictionary[ "GIF" ] = "no";
 550
 551         else if (configCmdLine.at(i) == "-no-libjpeg") {
 552             dictionary[ "JPEG" ] = "no";
 553             dictionary[ "LIBJPEG" ] = "no";
 554         } else if (configCmdLine.at(i) == "-qt-libjpeg") {
 555             dictionary[ "LIBJPEG" ] = "qt";
 556         } else if (configCmdLine.at(i) == "-system-libjpeg") {
 557             dictionary[ "LIBJPEG" ] = "system";
 558         }
 559
 560         else if (configCmdLine.at(i) == "-no-libpng") {
 561             dictionary[ "PNG" ] = "no";
 562             dictionary[ "LIBPNG" ] = "no";
 563         } else if (configCmdLine.at(i) == "-qt-libpng") {
 564             dictionary[ "LIBPNG" ] = "qt";
 565         } else if (configCmdLine.at(i) == "-system-libpng") {
 566             dictionary[ "LIBPNG" ] = "system";
 567         }
 568
 569         // Text Rendering --------------------------------------------
 570         else if (configCmdLine.at(i) == "-no-freetype")
 571             dictionary[ "FREETYPE" ] = "no";
 572         else if (configCmdLine.at(i) == "-qt-freetype")
 573             dictionary[ "FREETYPE" ] = "yes";
 574         else if (configCmdLine.at(i) == "-system-freetype")
 575             dictionary[ "FREETYPE" ] = "system";
 576
 577         // CE- C runtime --------------------------------------------
 578         else if (configCmdLine.at(i) == "-crt") {
 579             ++i;
 580             if (i == argCount)
 581                 break;
 582             QDir cDir(configCmdLine.at(i));
 583             if (!cDir.exists())
 584                 cout << "WARNING: Could not find directory (" << qPrintable(configCmdLine.at(i)) << ")for C runtime deployment" << endl;
 585             else
 586                 dictionary[ "CE_CRT" ] = QDir::toNativeSeparators(cDir.absolutePath());
 587         } else if (configCmdLine.at(i) == "-qt-crt") {
 588             dictionary[ "CE_CRT" ] = "yes";
 589         } else if (configCmdLine.at(i) == "-no-crt") {
 590             dictionary[ "CE_CRT" ] = "no";
 591         }
 592         // cetest ---------------------------------------------------
 593         else if (configCmdLine.at(i) == "-no-cetest") {
 594             dictionary[ "CETEST" ] = "no";
 595             dictionary[ "CETEST_REQUESTED" ] = "no";
 596         } else if (configCmdLine.at(i) == "-cetest") {
 597             // although specified to use it, we stay at "auto" state
 598             // this is because checkAvailability() adds variables
 599             // we need for crosscompilation; but remember if we asked
 600             // for it.
 601             dictionary[ "CETEST_REQUESTED" ] = "yes";
 602         }
 603         // Qt/CE - signing tool -------------------------------------
 604         else if (configCmdLine.at(i) == "-signature") {
 605             ++i;
 606             if (i == argCount)
 607                 break;
 608             QFileInfo info(configCmdLine.at(i));
 609             if (!info.exists())
 610                 cout << "WARNING: Could not find signature file (" << qPrintable(configCmdLine.at(i)) << ")" << endl;
 611             else
 612                 dictionary[ "CE_SIGNATURE" ] = QDir::toNativeSeparators(info.absoluteFilePath());
 613         }
 614         // Styles ---------------------------------------------------
 615         else if (configCmdLine.at(i) == "-qt-style-windows")
 616             dictionary[ "STYLE_WINDOWS" ] = "yes";
 617         else if (configCmdLine.at(i) == "-no-style-windows")
 618             dictionary[ "STYLE_WINDOWS" ] = "no";
 619
 620         else if (configCmdLine.at(i) == "-qt-style-windowsce")
 621             dictionary[ "STYLE_WINDOWSCE" ] = "yes";
 622         else if (configCmdLine.at(i) == "-no-style-windowsce")
 623             dictionary[ "STYLE_WINDOWSCE" ] = "no";
 624         else if (configCmdLine.at(i) == "-qt-style-windowsmobile")
 625             dictionary[ "STYLE_WINDOWSMOBILE" ] = "yes";
 626         else if (configCmdLine.at(i) == "-no-style-windowsmobile")
 627             dictionary[ "STYLE_WINDOWSMOBILE" ] = "no";
 628
 629         else if (configCmdLine.at(i) == "-qt-style-windowsxp")
 630             dictionary[ "STYLE_WINDOWSXP" ] = "yes";
 631         else if (configCmdLine.at(i) == "-no-style-windowsxp")
 632             dictionary[ "STYLE_WINDOWSXP" ] = "no";
 633
 634         else if (configCmdLine.at(i) == "-qt-style-windowsvista")
 635             dictionary[ "STYLE_WINDOWSVISTA" ] = "yes";
 636         else if (configCmdLine.at(i) == "-no-style-windowsvista")
 637             dictionary[ "STYLE_WINDOWSVISTA" ] = "no";
 638
 639         else if (configCmdLine.at(i) == "-qt-style-plastique")
 640             dictionary[ "STYLE_PLASTIQUE" ] = "yes";
 641         else if (configCmdLine.at(i) == "-no-style-plastique")
 642             dictionary[ "STYLE_PLASTIQUE" ] = "no";
 643
 644         else if (configCmdLine.at(i) == "-qt-style-cleanlooks")
 645             dictionary[ "STYLE_CLEANLOOKS" ] = "yes";
 646         else if (configCmdLine.at(i) == "-no-style-cleanlooks")
 647             dictionary[ "STYLE_CLEANLOOKS" ] = "no";
 648
 649         else if (configCmdLine.at(i) == "-qt-style-motif")
 650             dictionary[ "STYLE_MOTIF" ] = "yes";
 651         else if (configCmdLine.at(i) == "-no-style-motif")
 652             dictionary[ "STYLE_MOTIF" ] = "no";
 653
 654         else if (configCmdLine.at(i) == "-qt-style-cde")
 655             dictionary[ "STYLE_CDE" ] = "yes";
 656         else if (configCmdLine.at(i) == "-no-style-cde")
 657             dictionary[ "STYLE_CDE" ] = "no";
 658
 659         // Work around compiler nesting limitation
 660         else
 661             continueElse[1] = true;
 662         if (!continueElse[1]) {
 663         }
 664
 665         // OpenGL Support -------------------------------------------
 666         else if (configCmdLine.at(i) == "-no-opengl") {
 667             dictionary[ "OPENGL" ]    = "no";
 668         } else if (configCmdLine.at(i) == "-opengl-es-cm") {
 669             dictionary[ "OPENGL" ]          = "yes";
 670             dictionary[ "OPENGL_ES_CM" ]    = "yes";
 671         } else if (configCmdLine.at(i) == "-opengl-es-2") {
 672             dictionary[ "OPENGL" ]          = "yes";
 673             dictionary[ "OPENGL_ES_2" ]     = "yes";
 674         } else if (configCmdLine.at(i) == "-opengl") {
 675             dictionary[ "OPENGL" ]          = "yes";
 676             i++;
 677             if (i == argCount)
 678                 break;
 679
 680             if (configCmdLine.at(i) == "es1") {
 681                 dictionary[ "OPENGL_ES_CM" ]    = "yes";
 682             } else if ( configCmdLine.at(i) == "es2" ) {
 683                 dictionary[ "OPENGL_ES_2" ]     = "yes";
 684             } else if ( configCmdLine.at(i) == "desktop" ) {
 685                 // OPENGL=yes suffices
 686             } else {
 687                 cout << "Argument passed to -opengl option is not valid." << endl;
 688                 dictionary[ "DONE" ] = "error";
 689                 break;
 690             }
 691         // External location of ANGLE library  (Open GL ES 2)
 692         } else if (configCmdLine.at(i) == QStringLiteral("-angle")) {
 693             if (++i == argCount)
 694               break;
 695             const QFileInfo fi(configCmdLine.at(i));
 696             if (!fi.isDir()) {
 697                 cout << "Argument passed to -angle option is not a directory." << endl;
 698                 dictionary.insert(QStringLiteral("DONE"), QStringLiteral( "error"));
 699             }
 700             dictionary.insert(QStringLiteral("ANGLE_DIR"), fi.absoluteFilePath());
 701         }
 702
 703         // OpenVG Support -------------------------------------------
 704         else if (configCmdLine.at(i) == "-openvg") {
 705             dictionary[ "OPENVG" ]    = "yes";
 706         } else if (configCmdLine.at(i) == "-no-openvg") {
 707             dictionary[ "OPENVG" ]    = "no";
 708         }
 709
 710         // Databases ------------------------------------------------
 711         else if (configCmdLine.at(i) == "-qt-sql-mysql")
 712             dictionary[ "SQL_MYSQL" ] = "yes";
 713         else if (configCmdLine.at(i) == "-plugin-sql-mysql")
 714             dictionary[ "SQL_MYSQL" ] = "plugin";
 715         else if (configCmdLine.at(i) == "-no-sql-mysql")
 716             dictionary[ "SQL_MYSQL" ] = "no";
 717
 718         else if (configCmdLine.at(i) == "-qt-sql-odbc")
 719             dictionary[ "SQL_ODBC" ] = "yes";
 720         else if (configCmdLine.at(i) == "-plugin-sql-odbc")
 721             dictionary[ "SQL_ODBC" ] = "plugin";
 722         else if (configCmdLine.at(i) == "-no-sql-odbc")
 723             dictionary[ "SQL_ODBC" ] = "no";
 724
 725         else if (configCmdLine.at(i) == "-qt-sql-oci")
 726             dictionary[ "SQL_OCI" ] = "yes";
 727         else if (configCmdLine.at(i) == "-plugin-sql-oci")
 728             dictionary[ "SQL_OCI" ] = "plugin";
 729         else if (configCmdLine.at(i) == "-no-sql-oci")
 730             dictionary[ "SQL_OCI" ] = "no";
 731
 732         else if (configCmdLine.at(i) == "-qt-sql-psql")
 733             dictionary[ "SQL_PSQL" ] = "yes";
 734         else if (configCmdLine.at(i) == "-plugin-sql-psql")
 735             dictionary[ "SQL_PSQL" ] = "plugin";
 736         else if (configCmdLine.at(i) == "-no-sql-psql")
 737             dictionary[ "SQL_PSQL" ] = "no";
 738
 739         else if (configCmdLine.at(i) == "-qt-sql-tds")
 740             dictionary[ "SQL_TDS" ] = "yes";
 741         else if (configCmdLine.at(i) == "-plugin-sql-tds")
 742             dictionary[ "SQL_TDS" ] = "plugin";
 743         else if (configCmdLine.at(i) == "-no-sql-tds")
 744             dictionary[ "SQL_TDS" ] = "no";
 745
 746         else if (configCmdLine.at(i) == "-qt-sql-db2")
 747             dictionary[ "SQL_DB2" ] = "yes";
 748         else if (configCmdLine.at(i) == "-plugin-sql-db2")
 749             dictionary[ "SQL_DB2" ] = "plugin";
 750         else if (configCmdLine.at(i) == "-no-sql-db2")
 751             dictionary[ "SQL_DB2" ] = "no";
 752
 753         else if (configCmdLine.at(i) == "-qt-sql-sqlite")
 754             dictionary[ "SQL_SQLITE" ] = "yes";
 755         else if (configCmdLine.at(i) == "-plugin-sql-sqlite")
 756             dictionary[ "SQL_SQLITE" ] = "plugin";
 757         else if (configCmdLine.at(i) == "-no-sql-sqlite")
 758             dictionary[ "SQL_SQLITE" ] = "no";
 759         else if (configCmdLine.at(i) == "-system-sqlite")
 760             dictionary[ "SQL_SQLITE_LIB" ] = "system";
 761         else if (configCmdLine.at(i) == "-qt-sql-sqlite2")
 762             dictionary[ "SQL_SQLITE2" ] = "yes";
 763         else if (configCmdLine.at(i) == "-plugin-sql-sqlite2")
 764             dictionary[ "SQL_SQLITE2" ] = "plugin";
 765         else if (configCmdLine.at(i) == "-no-sql-sqlite2")
 766             dictionary[ "SQL_SQLITE2" ] = "no";
 767
 768         else if (configCmdLine.at(i) == "-qt-sql-ibase")
 769             dictionary[ "SQL_IBASE" ] = "yes";
 770         else if (configCmdLine.at(i) == "-plugin-sql-ibase")
 771             dictionary[ "SQL_IBASE" ] = "plugin";
 772         else if (configCmdLine.at(i) == "-no-sql-ibase")
 773             dictionary[ "SQL_IBASE" ] = "no";
 774
 775         // Image formats --------------------------------------------
 776         else if (configCmdLine.at(i).startsWith("-qt-imageformat-") &&
 777                  imageFormats.contains(configCmdLine.at(i).section('-', 3)))
 778             dictionary[ configCmdLine.at(i).section('-', 3).toUpper() ] = "yes";
 779         else if (configCmdLine.at(i).startsWith("-plugin-imageformat-") &&
 780                  imageFormats.contains(configCmdLine.at(i).section('-', 3)))
 781             dictionary[ configCmdLine.at(i).section('-', 3).toUpper() ] = "plugin";
 782         else if (configCmdLine.at(i).startsWith("-no-imageformat-") &&
 783                  imageFormats.contains(configCmdLine.at(i).section('-', 3)))
 784             dictionary[ configCmdLine.at(i).section('-', 3).toUpper() ] = "no";
 785 #endif
 786         // IDE project generation -----------------------------------
 787         else if (configCmdLine.at(i) == "-no-dsp")
 788             dictionary[ "DSPFILES" ] = "no";
 789         else if (configCmdLine.at(i) == "-dsp")
 790             dictionary[ "DSPFILES" ] = "yes";
 791
 792         else if (configCmdLine.at(i) == "-no-vcp")
 793             dictionary[ "VCPFILES" ] = "no";
 794         else if (configCmdLine.at(i) == "-vcp")
 795             dictionary[ "VCPFILES" ] = "yes";
 796
 797         else if (configCmdLine.at(i) == "-no-vcproj")
 798             dictionary[ "VCPROJFILES" ] = "no";
 799         else if (configCmdLine.at(i) == "-vcproj")
 800             dictionary[ "VCPROJFILES" ] = "yes";
 801
 802         else if (configCmdLine.at(i) == "-no-incredibuild-xge")
 803             dictionary[ "INCREDIBUILD_XGE" ] = "no";
 804         else if (configCmdLine.at(i) == "-incredibuild-xge")
 805             dictionary[ "INCREDIBUILD_XGE" ] = "yes";
 806         else if (configCmdLine.at(i) == "-native-gestures")
 807             dictionary[ "NATIVE_GESTURES" ] = "yes";
 808         else if (configCmdLine.at(i) == "-no-native-gestures")
 809             dictionary[ "NATIVE_GESTURES" ] = "no";
 810 #if !defined(EVAL)
 811         // Others ---------------------------------------------------
 812         else if (configCmdLine.at(i) == "-fast")
 813             dictionary[ "FAST" ] = "yes";
 814         else if (configCmdLine.at(i) == "-no-fast")
 815             dictionary[ "FAST" ] = "no";
 816
 817         else if (configCmdLine.at(i) == "-widgets")
 818             dictionary[ "WIDGETS" ] = "yes";
 819         else if (configCmdLine.at(i) == "-no-widgets")
 820             dictionary[ "WIDGETS" ] = "no";
 821
 822         else if (configCmdLine.at(i) == "-rtti")
 823             dictionary[ "RTTI" ] = "yes";
 824         else if (configCmdLine.at(i) == "-no-rtti")
 825             dictionary[ "RTTI" ] = "no";
 826
 827         else if (configCmdLine.at(i) == "-accessibility")
 828             dictionary[ "ACCESSIBILITY" ] = "yes";
 829         else if (configCmdLine.at(i) == "-no-accessibility") {
 830             dictionary[ "ACCESSIBILITY" ] = "no";
 831             cout << "Setting accessibility to NO" << endl;
 832         }
 833
 834         else if (configCmdLine.at(i) == "-no-sse2")
 835             dictionary[ "SSE2" ] = "no";
 836         else if (configCmdLine.at(i) == "-sse2")
 837             dictionary[ "SSE2" ] = "yes";
 838         else if (configCmdLine.at(i) == "-no-sse3")
 839             dictionary[ "SSE3" ] = "no";
 840         else if (configCmdLine.at(i) == "-sse3")
 841             dictionary[ "SSE3" ] = "yes";
 842         else if (configCmdLine.at(i) == "-no-ssse3")
 843             dictionary[ "SSSE3" ] = "no";
 844         else if (configCmdLine.at(i) == "-ssse3")
 845             dictionary[ "SSSE3" ] = "yes";
 846         else if (configCmdLine.at(i) == "-no-sse4.1")
 847             dictionary[ "SSE4_1" ] = "no";
 848         else if (configCmdLine.at(i) == "-sse4.1")
 849             dictionary[ "SSE4_1" ] = "yes";
 850         else if (configCmdLine.at(i) == "-no-sse4.2")
 851             dictionary[ "SSE4_2" ] = "no";
 852         else if (configCmdLine.at(i) == "-sse4.2")
 853             dictionary[ "SSE4_2" ] = "yes";
 854         else if (configCmdLine.at(i) == "-no-avx")
 855             dictionary[ "AVX" ] = "no";
 856         else if (configCmdLine.at(i) == "-avx")
 857             dictionary[ "AVX" ] = "yes";
 858         else if (configCmdLine.at(i) == "-no-avx2")
 859             dictionary[ "AVX2" ] = "no";
 860         else if (configCmdLine.at(i) == "-avx2")
 861             dictionary[ "AVX2" ] = "yes";
 862         else if (configCmdLine.at(i) == "-no-iwmmxt")
 863             dictionary[ "IWMMXT" ] = "no";
 864         else if (configCmdLine.at(i) == "-iwmmxt")
 865             dictionary[ "IWMMXT" ] = "yes";
 866
 867         else if (configCmdLine.at(i) == "-no-openssl") {
 868               dictionary[ "OPENSSL"] = "no";
 869         } else if (configCmdLine.at(i) == "-openssl") {
 870               dictionary[ "OPENSSL" ] = "yes";
 871         } else if (configCmdLine.at(i) == "-openssl-linked") {
 872               dictionary[ "OPENSSL" ] = "linked";
 873         } else if (configCmdLine.at(i) == "-no-qdbus") {
 874             dictionary[ "DBUS" ] = "no";
 875         } else if (configCmdLine.at(i) == "-qdbus") {
 876             dictionary[ "DBUS" ] = "yes";
 877         } else if (configCmdLine.at(i) == "-no-dbus") {
 878             dictionary[ "DBUS" ] = "no";
 879         } else if (configCmdLine.at(i) == "-dbus") {
 880             dictionary[ "DBUS" ] = "yes";
 881         } else if (configCmdLine.at(i) == "-dbus-linked") {
 882             dictionary[ "DBUS" ] = "linked";
 883         } else if (configCmdLine.at(i) == "-audio-backend") {
 884             dictionary[ "AUDIO_BACKEND" ] = "yes";
 885         } else if (configCmdLine.at(i) == "-no-audio-backend") {
 886             dictionary[ "AUDIO_BACKEND" ] = "no";
 887         } else if (configCmdLine.at(i) == "-no-phonon-backend") {
 888             dictionary[ "PHONON_BACKEND" ] = "no";
 889         } else if (configCmdLine.at(i) == "-phonon-backend") {
 890             dictionary[ "PHONON_BACKEND" ] = "yes";
 891         } else if (configCmdLine.at(i) == "-phonon-wince-ds9") {
 892             dictionary[ "DIRECTSHOW" ] = "yes";
 893         } else if (configCmdLine.at(i) == "-no-qml-debug") {
 894             dictionary[ "QML_DEBUG" ] = "no";
 895         } else if (configCmdLine.at(i) == "-qml-debug") {
 896             dictionary[ "QML_DEBUG" ] = "yes";
 897         } else if (configCmdLine.at(i) == "-no-plugin-manifests") {
 898             dictionary[ "PLUGIN_MANIFESTS" ] = "no";
 899         } else if (configCmdLine.at(i) == "-plugin-manifests") {
 900             dictionary[ "PLUGIN_MANIFESTS" ] = "yes";
 901         }
 902
 903         // Work around compiler nesting limitation
 904         else
 905             continueElse[0] = true;
 906         if (!continueElse[0]) {
 907         }
 908
 909         else if (configCmdLine.at(i) == "-internal")
 910             dictionary[ "QMAKE_INTERNAL" ] = "yes";
 911
 912         else if (configCmdLine.at(i) == "-no-syncqt")
 913             dictionary[ "SYNCQT" ] = "no";
 914
 915         else if (configCmdLine.at(i) == "-no-qmake")
 916             dictionary[ "BUILD_QMAKE" ] = "no";
 917         else if (configCmdLine.at(i) == "-qmake")
 918             dictionary[ "BUILD_QMAKE" ] = "yes";
 919
 920         else if (configCmdLine.at(i) == "-dont-process")
 921             dictionary[ "NOPROCESS" ] = "yes";
 922         else if (configCmdLine.at(i) == "-process")
 923             dictionary[ "NOPROCESS" ] = "no";
 924
 925         else if (configCmdLine.at(i) == "-no-qmake-deps")
 926             dictionary[ "DEPENDENCIES" ] = "no";
 927         else if (configCmdLine.at(i) == "-qmake-deps")
 928             dictionary[ "DEPENDENCIES" ] = "yes";
 929
 930
 931         else if (configCmdLine.at(i) == "-qtnamespace") {
 932             ++i;
 933             if (i == argCount)
 934                 break;
 935             dictionary[ "QT_NAMESPACE" ] = configCmdLine.at(i);
 936         } else if (configCmdLine.at(i) == "-qtlibinfix") {
 937             ++i;
 938             if (i == argCount)
 939                 break;
 940             dictionary[ "QT_LIBINFIX" ] = configCmdLine.at(i);
 941         } else if (configCmdLine.at(i) == "-D") {
 942             ++i;
 943             if (i == argCount)
 944                 break;
 945             qmakeDefines += configCmdLine.at(i);
 946         } else if (configCmdLine.at(i) == "-I") {
 947             ++i;
 948             if (i == argCount)
 949                 break;
 950             qmakeIncludes += configCmdLine.at(i);
 951         } else if (configCmdLine.at(i) == "-L") {
 952             ++i;
 953             if (i == argCount)
 954                 break;
 955             QFileInfo checkDirectory(configCmdLine.at(i));
 956             if (!checkDirectory.isDir()) {
 957                 cout << "Argument passed to -L option is not a directory path. Did you mean the -l option?" << endl;
 958                 dictionary[ "DONE" ] = "error";
 959                 break;
 960             }
 961             qmakeLibs += QString("-L" + configCmdLine.at(i));
 962         } else if (configCmdLine.at(i) == "-l") {
 963             ++i;
 964             if (i == argCount)
 965                 break;
 966             qmakeLibs += QString("-l" + configCmdLine.at(i));
 967         } else if (configCmdLine.at(i).startsWith("OPENSSL_LIBS=")) {
 968             opensslLibs = configCmdLine.at(i);
 969         } else if (configCmdLine.at(i).startsWith("OPENSSL_LIBS_DEBUG=")) {
 970             opensslLibsDebug = configCmdLine.at(i);
 971         } else if (configCmdLine.at(i).startsWith("OPENSSL_LIBS_RELEASE=")) {
 972             opensslLibsRelease = configCmdLine.at(i);
 973         } else if (configCmdLine.at(i).startsWith("PSQL_LIBS=")) {
 974             psqlLibs = configCmdLine.at(i);
 975         } else if (configCmdLine.at(i).startsWith("SYBASE=")) {
 976             sybase = configCmdLine.at(i);
 977         } else if (configCmdLine.at(i).startsWith("SYBASE_LIBS=")) {
 978             sybaseLibs = configCmdLine.at(i);
 979         }
 980
 981         else if ((configCmdLine.at(i) == "-override-version") || (configCmdLine.at(i) == "-version-override")){
 982             ++i;
 983             if (i == argCount)
 984                 break;
 985             dictionary[ "VERSION" ] = configCmdLine.at(i);
 986         }
 987
 988         else if (configCmdLine.at(i) == "-saveconfig") {
 989             ++i;
 990             if (i == argCount)
 991                 break;
 992             dictionary[ "CUSTOMCONFIG" ] = "_" + configCmdLine.at(i);
 993         }
 994
 995         else if (configCmdLine.at(i) == "-confirm-license") {
 996             dictionary["LICENSE_CONFIRMED"] = "yes";
 997         }
 998
 999         else if (configCmdLine.at(i) == "-make") {
1000             ++i;
1001             if (i == argCount)
1002                 break;
1003             buildParts += configCmdLine.at(i);
1004         } else if (configCmdLine.at(i) == "-nomake") {
1005             ++i;
1006             if (i == argCount)
1007                 break;
1008             nobuildParts.append(configCmdLine.at(i));
1009         }
1010
1011         // Directories ----------------------------------------------
1012         else if (configCmdLine.at(i) == "-prefix") {
1013             ++i;
1014             if (i == argCount)
1015                 break;
1016             dictionary[ "QT_INSTALL_PREFIX" ] = configCmdLine.at(i);
1017         }
1018
1019         else if (configCmdLine.at(i) == "-bindir") {
1020             ++i;
1021             if (i == argCount)
1022                 break;
1023             dictionary[ "QT_INSTALL_BINS" ] = configCmdLine.at(i);
1024         }
1025
1026         else if (configCmdLine.at(i) == "-libdir") {
1027             ++i;
1028             if (i == argCount)
1029                 break;
1030             dictionary[ "QT_INSTALL_LIBS" ] = configCmdLine.at(i);
1031         }
1032
1033         else if (configCmdLine.at(i) == "-docdir") {
1034             ++i;
1035             if (i == argCount)
1036                 break;
1037             dictionary[ "QT_INSTALL_DOCS" ] = configCmdLine.at(i);
1038         }
1039
1040         else if (configCmdLine.at(i) == "-headerdir") {
1041             ++i;
1042             if (i == argCount)
1043                 break;
1044             dictionary[ "QT_INSTALL_HEADERS" ] = configCmdLine.at(i);
1045         }
1046
1047         else if (configCmdLine.at(i) == "-plugindir") {
1048             ++i;
1049             if (i == argCount)
1050                 break;
1051             dictionary[ "QT_INSTALL_PLUGINS" ] = configCmdLine.at(i);
1052         }
1053
1054         else if (configCmdLine.at(i) == "-importdir") {
1055             ++i;
1056             if (i == argCount)
1057                 break;
1058             dictionary[ "QT_INSTALL_IMPORTS" ] = configCmdLine.at(i);
1059         }
1060         else if (configCmdLine.at(i) == "-datadir") {
1061             ++i;
1062             if (i == argCount)
1063                 break;
1064             dictionary[ "QT_INSTALL_DATA" ] = configCmdLine.at(i);
1065         }
1066
1067         else if (configCmdLine.at(i) == "-translationdir") {
1068             ++i;
1069             if (i == argCount)
1070                 break;
1071             dictionary[ "QT_INSTALL_TRANSLATIONS" ] = configCmdLine.at(i);
1072         }
1073
1074         else if (configCmdLine.at(i) == "-examplesdir") {
1075             ++i;
1076             if (i == argCount)
1077                 break;
1078             dictionary[ "QT_INSTALL_EXAMPLES" ] = configCmdLine.at(i);
1079         }
1080
1081         else if (configCmdLine.at(i) == "-testsdir") {
1082             ++i;
1083             if (i == argCount)
1084                 break;
1085             dictionary[ "QT_INSTALL_TESTS" ] = configCmdLine.at(i);
1086         }
1087
1088         else if (configCmdLine.at(i) == "-sysroot") {
1089             ++i;
1090             if (i == argCount)
1091                 break;
1092             dictionary[ "CFG_SYSROOT" ] = configCmdLine.at(i);
1093         }
1094         else if (configCmdLine.at(i) == "-no-gcc-sysroot") {
1095             dictionary[ "CFG_GCC_SYSROOT" ] = "no";
1096         }
1097
1098         else if (configCmdLine.at(i) == "-hostprefix") {
1099             ++i;
1100             if (i == argCount || configCmdLine.at(i).startsWith('-'))
1101                 dictionary[ "QT_HOST_PREFIX" ] = dictionary[ "QT_BUILD_TREE" ];
1102             else
1103                 dictionary[ "QT_HOST_PREFIX" ] = configCmdLine.at(i);
1104         }
1105
1106         else if (configCmdLine.at(i) == "-hostbindir") {
1107             ++i;
1108             if (i == argCount)
1109                 break;
1110             dictionary[ "QT_HOST_BINS" ] = configCmdLine.at(i);
1111         }
1112
1113         else if (configCmdLine.at(i) == "-hostdatadir") {
1114             ++i;
1115             if (i == argCount)
1116                 break;
1117             dictionary[ "QT_HOST_DATA" ] = configCmdLine.at(i);
1118         }
1119
1120         else if (configCmdLine.at(i) == "-make-tool") {
1121             ++i;
1122             if (i == argCount)
1123                 break;
1124             dictionary[ "MAKE" ] = configCmdLine.at(i);
1125         }
1126
1127         else if (configCmdLine.at(i).indexOf(QRegExp("^-(en|dis)able-")) != -1) {
1128             // Scan to see if any specific modules and drivers are enabled or disabled
1129             for (QStringList::Iterator module = modules.begin(); module != modules.end(); ++module) {
1130                 if (configCmdLine.at(i) == QString("-enable-") + (*module)) {
1131                     enabledModules += (*module);
1132                     break;
1133                 }
1134                 else if (configCmdLine.at(i) == QString("-disable-") + (*module)) {
1135                     disabledModules += (*module);
1136                     break;
1137                 }
1138             }
1139         }
1140
1141         else if (configCmdLine.at(i) == "-directwrite") {
1142             dictionary["DIRECTWRITE"] = "yes";
1143         } else if (configCmdLine.at(i) == "-no-directwrite") {
1144             dictionary["DIRECTWRITE"] = "no";
1145         }
1146
1147         else if (configCmdLine.at(i) == "-nis") {
1148             dictionary["NIS"] = "yes";
1149         } else if (configCmdLine.at(i) == "-no-nis") {
1150             dictionary["NIS"] = "no";
1151         }
1152
1153         else if (configCmdLine.at(i) == "-cups") {
1154             dictionary["QT_CUPS"] = "yes";
1155         } else if (configCmdLine.at(i) == "-no-cups") {
1156             dictionary["QT_CUPS"] = "no";
1157         }
1158
1159         else if (configCmdLine.at(i) == "-iconv") {
1160             dictionary["QT_ICONV"] = "yes";
1161         } else if (configCmdLine.at(i) == "-no-iconv") {
1162             dictionary["QT_ICONV"] = "no";
1163         } else if (configCmdLine.at(i) == "-sun-iconv") {
1164             dictionary["QT_ICONV"] = "sun";
1165         } else if (configCmdLine.at(i) == "-gnu-iconv") {
1166             dictionary["QT_ICONV"] = "gnu";
1167         }
1168
1169         else if (configCmdLine.at(i) == "-neon") {
1170             dictionary["NEON"] = "yes";
1171         } else if (configCmdLine.at(i) == "-no-neon") {
1172             dictionary["NEON"] = "no";
1173         }
1174
1175         else if (configCmdLine.at(i) == "-largefile") {
1176             dictionary["LARGE_FILE"] = "yes";
1177         }
1178
1179         else if (configCmdLine.at(i) == "-fontconfig") {
1180             dictionary["FONT_CONFIG"] = "yes";
1181         } else if (configCmdLine.at(i) == "-no-fontconfig") {
1182             dictionary["FONT_CONFIG"] = "no";
1183         }
1184
1185         else if (configCmdLine.at(i) == "-posix-ipc") {
1186             dictionary["POSIX_IPC"] = "yes";
1187         }
1188
1189         else if (configCmdLine.at(i) == "-glib") {
1190             dictionary["QT_GLIB"] = "yes";
1191         }
1192
1193         else if (configCmdLine.at(i) == "-sysconfdir") {
1194             ++i;
1195             if (i == argCount)
1196                 break;
1197
1198             dictionary["QT_INSTALL_SETTINGS"] = configCmdLine.at(i);
1199         }
1200
1201         else {
1202             dictionary[ "HELP" ] = "yes";
1203             cout << "Unknown option " << configCmdLine.at(i) << endl;
1204             break;
1205         }
1206
1207 #endif
1208     }
1209
1210     // Ensure that QMAKESPEC exists in the mkspecs folder
1211     const QString mkspecPath(sourcePath + "/mkspecs");
1212     QDirIterator itMkspecs(mkspecPath, QDir::AllDirs | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
1213     QStringList mkspecs;
1214
1215     while (itMkspecs.hasNext()) {
1216         QString mkspec = itMkspecs.next();
1217         // Remove base PATH
1218         mkspec.remove(0, mkspecPath.length() + 1);
1219         mkspecs << mkspec;
1220     }
1221
1222     if (dictionary["QMAKESPEC"].toLower() == "features"
1223         || !mkspecs.contains(dictionary["QMAKESPEC"], Qt::CaseInsensitive)) {
1224         dictionary[ "HELP" ] = "yes";
1225         if (dictionary ["QMAKESPEC_FROM"] == "commandline") {
1226             cout << "Invalid option \"" << dictionary["QMAKESPEC"] << "\" for -platform." << endl;
1227         } else if (dictionary ["QMAKESPEC_FROM"] == "env") {
1228             cout << "QMAKESPEC environment variable is set to \"" << dictionary["QMAKESPEC"]
1229                  << "\" which is not a supported platform" << endl;
1230         } else { // was autodetected from environment
1231             cout << "Unable to detect the platform from environment. Use -platform command line"
1232                     "argument or set the QMAKESPEC environment variable and run configure again" << endl;
1233         }
1234         cout << "See the README file for a list of supported operating systems and compilers." << endl;
1235     } else {
1236         if (dictionary[ "QMAKESPEC" ].endsWith("-icc") ||
1237             dictionary[ "QMAKESPEC" ].endsWith("-msvc") ||
1238             dictionary[ "QMAKESPEC" ].endsWith("-msvc.net") ||
1239             dictionary[ "QMAKESPEC" ].endsWith("-msvc2002") ||
1240             dictionary[ "QMAKESPEC" ].endsWith("-msvc2003") ||
1241             dictionary[ "QMAKESPEC" ].endsWith("-msvc2005") ||
1242             dictionary[ "QMAKESPEC" ].endsWith("-msvc2008") ||
1243             dictionary[ "QMAKESPEC" ].endsWith("-msvc2010") ||
1244             dictionary[ "QMAKESPEC" ].endsWith("-msvc11")) {
1245             if (dictionary[ "MAKE" ].isEmpty()) dictionary[ "MAKE" ] = "nmake";
1246             dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32";
1247         } else if (dictionary[ "QMAKESPEC" ] == QString("win32-g++")) {
1248             if (dictionary[ "MAKE" ].isEmpty()) dictionary[ "MAKE" ] = "mingw32-make";
1249             dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32-g++";
1250         } else {
1251             if (dictionary[ "MAKE" ].isEmpty()) dictionary[ "MAKE" ] = "make";
1252             dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32";
1253         }
1254     }
1255
1256     // Tell the user how to proceed building Qt after configure finished its job
1257     dictionary["QTBUILDINSTRUCTION"] = dictionary["MAKE"];
1258     if (dictionary.contains("XQMAKESPEC")) {
1259         if (dictionary["XQMAKESPEC"].startsWith("wince")) {
1260             dictionary["QTBUILDINSTRUCTION"] =
1261                 QString("setcepaths.bat ") + dictionary["XQMAKESPEC"] + QString(" && ") + dictionary["MAKE"];
1262         }
1263     }
1264
1265     // Tell the user how to confclean before the next configure
1266     dictionary["CONFCLEANINSTRUCTION"] = dictionary["MAKE"] + QString(" confclean");
1267
1268     // Ensure that -spec (XQMAKESPEC) exists in the mkspecs folder as well
1269     if (dictionary.contains("XQMAKESPEC") &&
1270         !mkspecs.contains(dictionary["XQMAKESPEC"], Qt::CaseInsensitive)) {
1271             dictionary["HELP"] = "yes";
1272             cout << "Invalid option \"" << dictionary["XQMAKESPEC"] << "\" for -xplatform." << endl;
1273     }
1274
1275     // Ensure that the crt to be deployed can be found
1276     if (dictionary["CE_CRT"] != QLatin1String("yes") && dictionary["CE_CRT"] != QLatin1String("no")) {
1277         QDir cDir(dictionary["CE_CRT"]);
1278         QStringList entries = cDir.entryList();
1279         bool hasDebug = entries.contains("msvcr80.dll");
1280         bool hasRelease = entries.contains("msvcr80d.dll");
1281         if ((dictionary["BUILDALL"] == "auto") && (!hasDebug || !hasRelease)) {
1282             cout << "Could not find debug and release c-runtime." << endl;
1283             cout << "You need to have msvcr80.dll and msvcr80d.dll in" << endl;
1284             cout << "the path specified. Setting to -no-crt";
1285             dictionary[ "CE_CRT" ] = "no";
1286         } else if ((dictionary["BUILD"] == "debug") && !hasDebug) {
1287             cout << "Could not find debug c-runtime (msvcr80d.dll) in the directory specified." << endl;
1288             cout << "Setting c-runtime automatic deployment to -no-crt" << endl;
1289             dictionary[ "CE_CRT" ] = "no";
1290         } else if ((dictionary["BUILD"] == "release") && !hasRelease) {
1291             cout << "Could not find release c-runtime (msvcr80.dll) in the directory specified." << endl;
1292             cout << "Setting c-runtime automatic deployment to -no-crt" << endl;
1293             dictionary[ "CE_CRT" ] = "no";
1294         }
1295     }
1296
1297     // Allow tests for private classes to be compiled against internal builds
1298     if (dictionary["BUILDDEV"] == "yes")
1299         qtConfig += "private_tests";
1300
1301     if (dictionary["FORCE_ASSERTS"] == "yes")
1302         qtConfig += "force_asserts";
1303
1304 #if !defined(EVAL)
1305     for (QStringList::Iterator dis = disabledModules.begin(); dis != disabledModules.end(); ++dis) {
1306         modules.removeAll((*dis));
1307     }
1308     for (QStringList::Iterator ena = enabledModules.begin(); ena != enabledModules.end(); ++ena) {
1309         if (modules.indexOf((*ena)) == -1)
1310             modules += (*ena);
1311     }
1312     qtConfig += modules;
1313
1314     for (QStringList::Iterator it = disabledModules.begin(); it != disabledModules.end(); ++it)
1315         qtConfig.removeAll(*it);
1316
1317     if ((dictionary[ "REDO" ] != "yes") && (dictionary[ "HELP" ] != "yes"))
1318         saveCmdLine();
1319 #endif
1320 }
1321
1322 #if !defined(EVAL)
1323 void Configure::validateArgs()
1324 {
1325     // Validate the specified config
1326
1327     // Get all possible configurations from the file system.
1328     QDir dir;
1329     QStringList filters;
1330     filters << "qconfig-*.h";
1331     dir.setNameFilters(filters);
1332     dir.setPath(sourcePath + "/src/corelib/global/");
1333
1334     QStringList stringList =  dir.entryList();
1335
1336     QStringList::Iterator it;
1337     for (it = stringList.begin(); it != stringList.end(); ++it)
1338         allConfigs << it->remove("qconfig-").remove(".h");
1339     allConfigs << "full";
1340
1341     // Try internal configurations first.
1342     QStringList possible_configs = QStringList()
1343         << "minimal"
1344         << "small"
1345         << "medium"
1346         << "large"
1347         << "full";
1348     int index = possible_configs.indexOf(dictionary["QCONFIG"]);
1349     if (index >= 0) {
1350         for (int c = 0; c <= index; c++) {
1351             qmakeConfig += possible_configs[c] + "-config";
1352         }
1353         return;
1354     }
1355
1356     // If the internal configurations failed, try others.
1357     QStringList::Iterator config;
1358     for (config = allConfigs.begin(); config != allConfigs.end(); ++config) {
1359         if ((*config) == dictionary[ "QCONFIG" ])
1360             break;
1361     }
1362     if (config == allConfigs.end()) {
1363         dictionary[ "HELP" ] = "yes";
1364         cout << "No such configuration \"" << qPrintable(dictionary[ "QCONFIG" ]) << "\"" << endl ;
1365     }
1366     else
1367         qmakeConfig += (*config) + "-config";
1368 }
1369 #endif
1370
1371
1372 // Output helper functions --------------------------------[ Start ]-
1373 /*!
1374     Determines the length of a string token.
1375 */
1376 static int tokenLength(const char *str)
1377 {
1378     if (*str == 0)
1379         return 0;
1380
1381     const char *nextToken = strpbrk(str, " _/\n\r");
1382     if (nextToken == str || !nextToken)
1383         return 1;
1384
1385     return int(nextToken - str);
1386 }
1387
1388 /*!
1389     Prints out a string which starts at position \a startingAt, and
1390     indents each wrapped line with \a wrapIndent characters.
1391     The wrap point is set to the console width, unless that width
1392     cannot be determined, or is too small.
1393 */
1394 void Configure::desc(const char *description, int startingAt, int wrapIndent)
1395 {
1396     int linePos = startingAt;
1397
1398     bool firstLine = true;
1399     const char *nextToken = description;
1400     while (*nextToken) {
1401         int nextTokenLen = tokenLength(nextToken);
1402         if (*nextToken == '\n'                         // Wrap on newline, duh
1403             || (linePos + nextTokenLen > outputWidth)) // Wrap at outputWidth
1404         {
1405             printf("\n");
1406             linePos = 0;
1407             firstLine = false;
1408             if (*nextToken == '\n')
1409                 ++nextToken;
1410             continue;
1411         }
1412         if (!firstLine && linePos < wrapIndent) {  // Indent to wrapIndent
1413             printf("%*s", wrapIndent , "");
1414             linePos = wrapIndent;
1415             if (*nextToken == ' ') {
1416                 ++nextToken;
1417                 continue;
1418             }
1419         }
1420         printf("%.*s", nextTokenLen, nextToken);
1421         linePos += nextTokenLen;
1422         nextToken += nextTokenLen;
1423     }
1424 }
1425
1426 /*!
1427     Prints out an option with its description wrapped at the
1428     description starting point. If \a skipIndent is true, the
1429     indentation to the option is not outputted (used by marked option
1430     version of desc()). Extra spaces between option and its
1431     description is filled with\a fillChar, if there's available
1432     space.
1433 */
1434 void Configure::desc(const char *option, const char *description, bool skipIndent, char fillChar)
1435 {
1436     if (!skipIndent)
1437         printf("%*s", optionIndent, "");
1438
1439     int remaining  = descIndent - optionIndent - strlen(option);
1440     int wrapIndent = descIndent + qMax(0, 1 - remaining);
1441     printf("%s", option);
1442
1443     if (remaining > 2) {
1444         printf(" "); // Space in front
1445         for (int i = remaining; i > 2; --i)
1446             printf("%c", fillChar); // Fill, if available space
1447     }
1448     printf(" "); // Space between option and description
1449
1450     desc(description, wrapIndent, wrapIndent);
1451     printf("\n");
1452 }
1453
1454 /*!
1455     Same as above, except it also marks an option with an '*', if
1456     the option is default action.
1457 */
1458 void Configure::desc(const char *mark_option, const char *mark, const char *option, const char *description, char fillChar)
1459 {
1460     const QString markedAs = dictionary.value(mark_option);
1461     if (markedAs == "auto" && markedAs == mark) // both "auto", always => +
1462         printf(" +  ");
1463     else if (markedAs == "auto")                // setting marked as "auto" and option is default => +
1464         printf(" %c  " , (defaultTo(mark_option) == QLatin1String(mark))? '+' : ' ');
1465     else if (QLatin1String(mark) == "auto" && markedAs != "no")     // description marked as "auto" and option is available => +
1466         printf(" %c  " , checkAvailability(mark_option) ? '+' : ' ');
1467     else                                        // None are "auto", (markedAs == mark) => *
1468         printf(" %c  " , markedAs == QLatin1String(mark) ? '*' : ' ');
1469
1470     desc(option, description, true, fillChar);
1471 }
1472
1473 /*!
1474     Modifies the default configuration based on given -platform option.
1475     Eg. switches to different default styles for Windows CE.
1476 */
1477 void Configure::applySpecSpecifics()
1478 {
1479     if (!dictionary[ "XQMAKESPEC" ].isEmpty()) {
1480         //Disable building tools, docs and translations when cross compiling.
1481         nobuildParts << "docs" << "translations" << "tools";
1482     }
1483
1484     if (dictionary[ "XQMAKESPEC" ].startsWith("wince")) {
1485         dictionary[ "STYLE_WINDOWSXP" ]     = "no";
1486         dictionary[ "STYLE_WINDOWSVISTA" ]  = "no";
1487         dictionary[ "STYLE_PLASTIQUE" ]     = "no";
1488         dictionary[ "STYLE_CLEANLOOKS" ]    = "no";
1489         dictionary[ "STYLE_WINDOWSCE" ]     = "yes";
1490         dictionary[ "STYLE_WINDOWSMOBILE" ] = "yes";
1491         dictionary[ "STYLE_MOTIF" ]         = "no";
1492         dictionary[ "STYLE_CDE" ]           = "no";
1493         dictionary[ "FREETYPE" ]            = "no";
1494         dictionary[ "OPENGL" ]              = "no";
1495         dictionary[ "OPENSSL" ]             = "no";
1496         dictionary[ "RTTI" ]                = "no";
1497         dictionary[ "SSE2" ]                = "no";
1498         dictionary[ "SSE3" ]                = "no";
1499         dictionary[ "SSSE3" ]               = "no";
1500         dictionary[ "SSE4_1" ]              = "no";
1501         dictionary[ "SSE4_2" ]              = "no";
1502         dictionary[ "AVX" ]                 = "no";
1503         dictionary[ "AVX2" ]                = "no";
1504         dictionary[ "IWMMXT" ]              = "no";
1505         dictionary[ "CE_CRT" ]              = "yes";
1506         dictionary[ "DIRECTSHOW" ]          = "no";
1507         dictionary[ "LARGE_FILE" ]          = "no";
1508         // We only apply MMX/IWMMXT for mkspecs we know they work
1509         if (dictionary[ "XQMAKESPEC" ].startsWith("wincewm")) {
1510             dictionary[ "MMX" ]    = "yes";
1511             dictionary[ "IWMMXT" ] = "yes";
1512             dictionary[ "DIRECTSHOW" ] = "yes";
1513         }
1514     } else if (dictionary[ "XQMAKESPEC" ].startsWith("linux")) { //TODO actually wrong.
1515       //TODO
1516         dictionary[ "STYLE_WINDOWSXP" ]     = "no";
1517         dictionary[ "STYLE_WINDOWSVISTA" ]  = "no";
1518         dictionary[ "KBD_DRIVERS" ]         = "tty";
1519         dictionary[ "GFX_DRIVERS" ]         = "linuxfb";
1520         dictionary[ "MOUSE_DRIVERS" ]       = "pc linuxtp";
1521         dictionary[ "OPENGL" ]              = "no";
1522         dictionary[ "DBUS"]                 = "no";
1523         dictionary[ "QT_INOTIFY" ]          = "no";
1524         dictionary[ "QT_CUPS" ]             = "no";
1525         dictionary[ "QT_GLIB" ]             = "no";
1526         dictionary[ "QT_ICONV" ]            = "no";
1527
1528         dictionary["DECORATIONS"]           = "default windows styled";
1529     }
1530 }
1531
1532 QString Configure::locateFileInPaths(const QString &fileName, const QStringList &paths)
1533 {
1534     QDir d;
1535     for (QStringList::ConstIterator it = paths.begin(); it != paths.end(); ++it) {
1536         // Remove any leading or trailing ", this is commonly used in the environment
1537         // variables
1538         QString path = (*it);
1539         if (path.startsWith("\""))
1540             path = path.right(path.length() - 1);
1541         if (path.endsWith("\""))
1542             path = path.left(path.length() - 1);
1543         if (d.exists(path + QDir::separator() + fileName)) {
1544             return (path);
1545         }
1546     }
1547     return QString();
1548 }
1549
1550 QString Configure::locateFile(const QString &fileName)
1551 {
1552     QString file = fileName.toLower();
1553     QStringList paths;
1554 #if defined(Q_OS_WIN32)
1555     QRegExp splitReg("[;,]");
1556 #else
1557     QRegExp splitReg("[:]");
1558 #endif
1559     if (file.endsWith(".h"))
1560         paths = QString::fromLocal8Bit(getenv("INCLUDE")).split(splitReg, QString::SkipEmptyParts);
1561     else if (file.endsWith(".lib"))
1562         paths = QString::fromLocal8Bit(getenv("LIB")).split(splitReg, QString::SkipEmptyParts);
1563     else
1564         paths = QString::fromLocal8Bit(getenv("PATH")).split(splitReg, QString::SkipEmptyParts);
1565     return locateFileInPaths(file, paths);
1566 }
1567
1568 // Output helper functions ---------------------------------[ Stop ]-
1569
1570
1571 bool Configure::displayHelp()
1572 {
1573     if (dictionary[ "HELP" ] == "yes") {
1574         desc("Usage: configure\n"
1575                     "[-release] [-debug] [-debug-and-release] [-shared] [-static]\n"
1576                     "[-no-fast] [-fast] \n"
1577                     "[-no-accessibility] [-accessibility] [-no-rtti] [-rtti]\n"
1578                     "[-no-sql-<driver>] [-qt-sql-<driver>]\n"
1579                     "[-plugin-sql-<driver>] [-system-sqlite]\n"
1580                     "[-D <define>] [-I <includepath>] [-L <librarypath>]\n"
1581                     "[-help] [-no-dsp] [-dsp] [-no-vcproj] [-vcproj]\n"
1582                     "[-no-qmake] [-qmake] [-dont-process] [-process]\n"
1583                     "[-no-style-<style>] [-qt-style-<style>] [-redo]\n"
1584                     "[-saveconfig <config>] [-loadconfig <config>]\n"
1585                     "[-qt-zlib] [-system-zlib] [-qt-pcre] [-system-pcre] [-no-gif]\n"
1586                     "[-no-libpng] [-qt-libpng] [-system-libpng]\n"
1587                     "[-no-libjpeg] [-qt-libjpeg] [-system-libjpeg]\n"
1588                     "[-sse2] [-no-sse2] [-sse3] [-no-sse3]\n"
1589                     "[-ssse3] [-no-ssse3]\n"
1590                     "[-sse4.1] [-no-sse4.1] [-sse4.2] [-no-sse4.2]\n"
1591                     "[-avx] [-no-avx] [-avx2] [-no-avx2]\n"
1592                     "[-no-iwmmxt] [-iwmmxt] [-openssl] [-openssl-linked]\n"
1593                     "[-no-openssl] [-no-dbus] [-dbus] [-dbus-linked] [-platform <spec>]\n"
1594                     "[-qtnamespace <namespace>] [-qtlibinfix <infix>] [-no-phonon]\n"
1595                     "[-phonon] [-no-phonon-backend] [-phonon-backend]\n"
1596                     "[-no-multimedia] [-multimedia] [-no-audio-backend] [-audio-backend]\n"
1597                     "[-no-script] [-script] [-no-scripttools] [-scripttools]\n"
1598                     "[-no-webkit] [-webkit] [-webkit-debug]\n"
1599                     "[-no-directwrite] [-directwrite] [-no-widgets] [-icu]\n"
1600                     "[-no-nis] [-nis] [-no-cups] [-cups] [-no-iconv]\n"
1601                     "[-iconv] [-sun-iconv] [-gnu-iconv] [-neon] [-no-neon]\n"
1602                     "[-largefile] [-font-config] [-no-fontconfig] [-posix-ipc]\n"
1603                     "[-glib] [-sysconfdir <dir>]\n\n", 0, 7);
1604
1605         desc("Installation options:\n\n");
1606
1607         desc("These are optional, but you may specify install directories.\n\n", 0, 1);
1608
1609         desc(       "-prefix <dir>",                    "This will install everything relative to <dir> (default $QT_INSTALL_PREFIX)\n\n");
1610
1611         desc(       "-hostprefix [dir]",                "Tools and libraries needed when developing applications are installed in [dir]. "
1612                                                         "If [dir] is not given, the current build directory will be used. (default PREFIX)\n");
1613
1614         desc("You may use these to separate different parts of the install:\n\n");
1615
1616         desc(       "-bindir <dir>",                    "Executables will be installed to <dir> (default PREFIX/bin)");
1617         desc(       "-libdir <dir>",                    "Libraries will be installed to <dir> (default PREFIX/lib)");
1618         desc(       "-docdir <dir>",                    "Documentation will be installed to <dir> (default PREFIX/doc)");
1619         desc(       "-headerdir <dir>",                 "Headers will be installed to <dir> (default PREFIX/include)");
1620         desc(       "-plugindir <dir>",                 "Plugins will be installed to <dir> (default PREFIX/plugins)");
1621         desc(       "-importdir <dir>",                 "Imports for QML will be installed to <dir> (default PREFIX/imports)");
1622         desc(       "-datadir <dir>",                   "Data used by Qt programs will be installed to <dir> (default PREFIX)");
1623         desc(       "-translationdir <dir>",            "Translations of Qt programs will be installed to <dir> (default PREFIX/translations)");
1624         desc(       "-examplesdir <dir>",               "Examples will be installed to <dir> (default PREFIX/examples)");
1625         desc(       "-testsdir <dir>",                  "Tests will be installed to <dir> (default PREFIX/tests)");
1626
1627         desc(       "-hostbindir <dir>",                "Host executables will be installed to <dir> (default HOSTPREFIX/bin)");
1628         desc(       "-hostdatadir <dir>",               "Data used by qmake will be installed to <dir> (default HOSTPREFIX)");
1629
1630 #if !defined(EVAL)
1631         desc("Configure options:\n\n");
1632
1633         desc(" The defaults (*) are usually acceptable. A plus (+) denotes a default value"
1634              " that needs to be evaluated. If the evaluation succeeds, the feature is"
1635              " included. Here is a short explanation of each option:\n\n", 0, 1);
1636
1637         desc("BUILD", "release","-release",             "Compile and link Qt with debugging turned off.");
1638         desc("BUILD", "debug",  "-debug",               "Compile and link Qt with debugging turned on.");
1639         desc("BUILDALL", "yes", "-debug-and-release",   "Compile and link two Qt libraries, with and without debugging turned on.\n");
1640
1641         desc("OPENSOURCE", "opensource", "-opensource",   "Compile and link the Open-Source Edition of Qt.");
1642         desc("COMMERCIAL", "commercial", "-commercial",   "Compile and link the Commercial Edition of Qt.\n");
1643
1644         desc("BUILDDEV", "yes", "-developer-build",      "Compile and link Qt with Qt developer options (including auto-tests exporting)\n");
1645
1646         desc("SHARED", "yes",   "-shared",              "Create and use shared Qt libraries.");
1647         desc("SHARED", "no",    "-static",              "Create and use static Qt libraries.\n");
1648
1649         desc("LTCG", "yes",   "-ltcg",                  "Use Link Time Code Generation. (Release builds only)");
1650         desc("LTCG", "no",    "-no-ltcg",               "Do not use Link Time Code Generation.\n");
1651
1652         desc("FAST", "no",      "-no-fast",             "Configure Qt normally by generating Makefiles for all project files.");
1653         desc("FAST", "yes",     "-fast",                "Configure Qt quickly by generating Makefiles only for library and "
1654                                                         "subdirectory targets.  All other Makefiles are created as wrappers "
1655                                                         "which will in turn run qmake\n");
1656
1657         desc(                   "-make <part>",         "Add part to the list of parts to be built at make time.");
1658         for (int i=0; i<defaultBuildParts.size(); ++i)
1659             desc(               "",                     qPrintable(QString("  %1").arg(defaultBuildParts.at(i))), false, ' ');
1660         desc(                   "-nomake <part>",       "Exclude part from the list of parts to be built.\n");
1661
1662         desc("WIDGETS", "no", "-no-widgets",            "Disable QtWidgets module\n");
1663
1664         desc("ACCESSIBILITY", "no",  "-no-accessibility", "Do not compile Windows Active Accessibility support.");
1665         desc("ACCESSIBILITY", "yes", "-accessibility",    "Compile Windows Active Accessibility support.\n");
1666
1667         desc(                   "-no-sql-<driver>",     "Disable SQL <driver> entirely, by default none are turned on.");
1668         desc(                   "-qt-sql-<driver>",     "Enable a SQL <driver> in the Qt Library.");
1669         desc(                   "-plugin-sql-<driver>", "Enable SQL <driver> as a plugin to be linked to at run time.\n"
1670                                                         "Available values for <driver>:");
1671         desc("SQL_MYSQL", "auto", "",                   "  mysql", ' ');
1672         desc("SQL_PSQL", "auto", "",                    "  psql", ' ');
1673         desc("SQL_OCI", "auto", "",                     "  oci", ' ');
1674         desc("SQL_ODBC", "auto", "",                    "  odbc", ' ');
1675         desc("SQL_TDS", "auto", "",                     "  tds", ' ');
1676         desc("SQL_DB2", "auto", "",                     "  db2", ' ');
1677         desc("SQL_SQLITE", "auto", "",                  "  sqlite", ' ');
1678         desc("SQL_SQLITE2", "auto", "",                 "  sqlite2", ' ');
1679         desc("SQL_IBASE", "auto", "",                   "  ibase", ' ');
1680         desc(                   "",                     "(drivers marked with a '+' have been detected as available on this system)\n", false, ' ');
1681
1682         desc(                   "-system-sqlite",       "Use sqlite from the operating system.\n");
1683
1684         desc("OPENGL", "no","-no-opengl",               "Disables OpenGL functionality\n");
1685         desc("OPENGL", "no","-opengl <api>",            "Enable OpenGL support with specified API version.\n"
1686                                                         "Available values for <api>:");
1687         desc("", "", "",                                "  desktop - Enable support for Desktop OpenGL", ' ');
1688         desc("OPENGL_ES_CM", "no", "",                  "  es1 - Enable support for OpenGL ES Common Profile", ' ');
1689         desc("OPENGL_ES_2",  "no", "",                  "  es2 - Enable support for OpenGL ES 2.0", ' ');
1690
1691         desc("OPENVG", "no","-no-openvg",               "Disables OpenVG functionality\n");
1692         desc("OPENVG", "yes","-openvg",                 "Enables OpenVG functionality");
1693         desc(                   "-force-asserts",       "Activate asserts in release mode.\n");
1694 #endif
1695         desc(                   "-platform <spec>",     "The operating system and compiler you are building on.\n(default %QMAKESPEC%)\n");
1696         desc(                   "-xplatform <spec>",    "The operating system and compiler you are cross compiling to.\n");
1697         desc(                   "",                     "See the README file for a list of supported operating systems and compilers.\n", false, ' ');
1698         desc(                   "-sysroot <dir>",       "Sets <dir> as the target compiler's and qmake's sysroot and also sets pkg-config paths.");
1699         desc(                   "-no-gcc-sysroot",      "When using -sysroot, it disables the passing of --sysroot to the compiler ");
1700
1701         desc("NIS",  "no",      "-no-nis",              "Do not build NIS support.");
1702         desc("NIS",  "yes",     "-nis",                 "Build NIS support.");
1703
1704         desc("NEON", "yes",     "-neon",                "Enable the use of NEON instructions.");
1705         desc("NEON", "no",      "-no-neon",             "Do not enable the use of NEON instructions.");
1706
1707         desc("QT_ICONV",    "disable", "-no-iconv",     "Do not enable support for iconv(3).");
1708         desc("QT_ICONV",    "yes",     "-iconv",        "Enable support for iconv(3).");
1709         desc("QT_ICONV",    "yes",     "-sun-iconv",    "Enable support for iconv(3) using sun-iconv.");
1710         desc("QT_ICONV",    "yes",     "-gnu-iconv",    "Enable support for iconv(3) using gnu-libiconv");
1711
1712         desc("LARGE_FILE",  "yes",     "-largefile",    "Enables Qt to access files larger than 4 GB.");
1713
1714         desc("FONT_CONFIG", "yes",     "-fontconfig",   "Build with FontConfig support.");
1715         desc("FONT_CONFIG", "no",      "-no-fontconfig" "Do not build with FontConfig support.");
1716
1717         desc("POSIX_IPC",   "yes",     "-posix-ipc",    "Enable POSIX IPC.");
1718
1719         desc("QT_GLIB",     "yes",     "-glib",         "Enable Glib support.");
1720
1721         desc("QT_INSTALL_SETTINGS", "auto", "-sysconfdir", "Settings used by Qt programs will be looked for in <dir>.");
1722
1723 #if !defined(EVAL)
1724         desc(                   "-qtnamespace <namespace>", "Wraps all Qt library code in 'namespace name {...}");
1725         desc(                   "-qtlibinfix <infix>",  "Renames all Qt* libs to Qt*<infix>\n");
1726         desc(                   "-D <define>",          "Add an explicit define to the preprocessor.");
1727         desc(                   "-I <includepath>",     "Add an explicit include path.");
1728         desc(                   "-L <librarypath>",     "Add an explicit library path.");
1729         desc(                   "-l <libraryname>",     "Add an explicit library name, residing in a librarypath.\n");
1730 #endif
1731
1732         desc(                   "-help, -h, -?",        "Display this information.\n");
1733
1734 #if !defined(EVAL)
1735         // 3rd party stuff options go below here --------------------------------------------------------------------------------
1736         desc("Third Party Libraries:\n\n");
1737
1738         desc("ZLIB", "qt",      "-qt-zlib",             "Use the zlib bundled with Qt.");
1739         desc("ZLIB", "system",  "-system-zlib",         "Use zlib from the operating system.\nSee http://www.gzip.org/zlib\n");
1740
1741         desc("PCRE", "qt",       "-qt-pcre",            "Use the PCRE library bundled with Qt.");
1742         desc("PCRE", "qt",       "-system-pcre",        "Use the PCRE library from the operating system.\nSee http://pcre.org/\n");
1743
1744         desc("ICU", "yes",       "-icu",                "Use the ICU library.");
1745         desc("ICU", "no",        "-no-icu",             "Do not use the ICU library.\nSee http://site.icu-project.org/\n");
1746
1747         desc("GIF", "no",       "-no-gif",              "Do not compile GIF reading support.");
1748
1749         desc("LIBPNG", "no",    "-no-libpng",           "Do not compile PNG support.");
1750         desc("LIBPNG", "qt",    "-qt-libpng",           "Use the libpng bundled with Qt.");
1751         desc("LIBPNG", "system","-system-libpng",       "Use libpng from the operating system.\nSee http://www.libpng.org/pub/png\n");
1752
1753         desc("LIBJPEG", "no",    "-no-libjpeg",         "Do not compile JPEG support.");
1754         desc("LIBJPEG", "qt",    "-qt-libjpeg",         "Use the libjpeg bundled with Qt.");
1755         desc("LIBJPEG", "system","-system-libjpeg",     "Use libjpeg from the operating system.\nSee http://www.ijg.org\n");
1756
1757         desc("FREETYPE", "no",   "-no-freetype",        "Do not compile in Freetype2 support.");
1758         desc("FREETYPE", "yes",  "-qt-freetype",        "Use the libfreetype bundled with Qt.");
1759         desc("FREETYPE", "yes",  "-system-freetype",    "Use the libfreetype provided by the system.");
1760 #endif
1761         // Qt\Windows only options go below here --------------------------------------------------------------------------------
1762         desc("Qt for Windows only:\n\n");
1763
1764         desc("DSPFILES", "no",  "-no-dsp",              "Do not generate VC++ .dsp files.");
1765         desc("DSPFILES", "yes", "-dsp",                 "Generate VC++ .dsp files, only if spec \"win32-msvc\".\n");
1766
1767         desc("VCPROJFILES", "no", "-no-vcproj",         "Do not generate VC++ .vcproj files.");
1768         desc("VCPROJFILES", "yes", "-vcproj",           "Generate VC++ .vcproj files, only if platform \"win32-msvc.net\".\n");
1769
1770         desc("INCREDIBUILD_XGE", "no", "-no-incredibuild-xge", "Do not add IncrediBuild XGE distribution commands to custom build steps.");
1771         desc("INCREDIBUILD_XGE", "yes", "-incredibuild-xge",   "Add IncrediBuild XGE distribution commands to custom build steps. This will distribute MOC and UIC steps, and other custom buildsteps which are added to the INCREDIBUILD_XGE variable.\n(The IncrediBuild distribution commands are only added to Visual Studio projects)\n");
1772
1773         desc("PLUGIN_MANIFESTS", "no", "-no-plugin-manifests", "Do not embed manifests in plugins.");
1774         desc("PLUGIN_MANIFESTS", "yes", "-plugin-manifests",   "Embed manifests in plugins.\n");
1775         desc(       "-angle <dir>",                     "Use ANGLE library from location <dir>.\n");
1776 #if !defined(EVAL)
1777         desc("BUILD_QMAKE", "no", "-no-qmake",          "Do not compile qmake.");
1778         desc("BUILD_QMAKE", "yes", "-qmake",            "Compile qmake.\n");
1779
1780         desc("NOPROCESS", "yes", "-dont-process",       "Do not generate Makefiles/Project files. This will override -no-fast if specified.");
1781         desc("NOPROCESS", "no",  "-process",            "Generate Makefiles/Project files.\n");
1782
1783         desc("RTTI", "no",      "-no-rtti",             "Do not compile runtime type information.");
1784         desc("RTTI", "yes",     "-rtti",                "Compile runtime type information.\n");
1785         desc("SSE2", "no",      "-no-sse2",             "Do not compile with use of SSE2 instructions");
1786         desc("SSE2", "yes",     "-sse2",                "Compile with use of SSE2 instructions");
1787         desc("SSE3", "no",      "-no-sse3",             "Do not compile with use of SSE3 instructions");
1788         desc("SSE3", "yes",     "-sse3",                "Compile with use of SSE3 instructions");
1789         desc("SSSE3", "no",     "-no-ssse3",            "Do not compile with use of SSSE3 instructions");
1790         desc("SSSE3", "yes",    "-ssse3",               "Compile with use of SSSE3 instructions");
1791         desc("SSE4_1", "no",    "-no-sse4.1",           "Do not compile with use of SSE4.1 instructions");
1792         desc("SSE4_1", "yes",   "-sse4.1",              "Compile with use of SSE4.1 instructions");
1793         desc("SSE4_2", "no",    "-no-sse4.2",           "Do not compile with use of SSE4.2 instructions");
1794         desc("SSE4_2", "yes",   "-sse4.2",              "Compile with use of SSE4.2 instructions");
1795         desc("AVX", "no",       "-no-avx",              "Do not compile with use of AVX instructions");
1796         desc("AVX", "yes",      "-avx",                 "Compile with use of AVX instructions");
1797         desc("AVX2", "no",      "-no-avx2",             "Do not compile with use of AVX2 instructions");
1798         desc("AVX2", "yes",     "-avx2",                "Compile with use of AVX2 instructions");
1799         desc("OPENSSL", "no",    "-no-openssl",         "Do not compile in OpenSSL support");
1800         desc("OPENSSL", "yes",   "-openssl",            "Compile in run-time OpenSSL support");
1801         desc("OPENSSL", "linked","-openssl-linked",     "Compile in linked OpenSSL support");
1802         desc("DBUS", "no",       "-no-dbus",            "Do not compile in D-Bus support");
1803         desc("DBUS", "yes",      "-dbus",               "Compile in D-Bus support and load libdbus-1 dynamically");
1804         desc("DBUS", "linked",   "-dbus-linked",        "Compile in D-Bus support and link to libdbus-1");
1805         desc("PHONON_BACKEND","no", "-no-phonon-backend","Do not compile the platform-specific Phonon backend-plugin");
1806         desc("PHONON_BACKEND","yes","-phonon-backend",  "Compile in the platform-specific Phonon backend-plugin");
1807         desc("AUDIO_BACKEND", "no","-no-audio-backend", "Do not compile in the platform audio backend into QtMultimedia");
1808         desc("AUDIO_BACKEND", "yes","-audio-backend",   "Compile in the platform audio backend into QtMultimedia");
1809         desc("QML_DEBUG", "no",    "-no-qml-debug",     "Do not build the QML debugging support");
1810         desc("QML_DEBUG", "yes",   "-qml-debug",        "Build the QML debugging support");
1811         desc("DIRECTWRITE", "no", "-no-directwrite", "Do not build support for DirectWrite font rendering");
1812         desc("DIRECTWRITE", "yes", "-directwrite", "Build support for DirectWrite font rendering (experimental, requires DirectWrite availability on target systems, e.g. Windows Vista with Platform Update, Windows 7, etc.)");
1813
1814         desc(                   "-no-style-<style>",    "Disable <style> entirely.");
1815         desc(                   "-qt-style-<style>",    "Enable <style> in the Qt Library.\nAvailable styles: ");
1816
1817         desc("STYLE_WINDOWS", "yes", "",                "  windows", ' ');
1818         desc("STYLE_WINDOWSXP", "auto", "",             "  windowsxp", ' ');
1819         desc("STYLE_WINDOWSVISTA", "auto", "",          "  windowsvista", ' ');
1820         desc("STYLE_PLASTIQUE", "yes", "",              "  plastique", ' ');
1821         desc("STYLE_CLEANLOOKS", "yes", "",             "  cleanlooks", ' ');
1822         desc("STYLE_MOTIF", "yes", "",                  "  motif", ' ');
1823         desc("STYLE_CDE", "yes", "",                    "  cde", ' ');
1824         desc("STYLE_WINDOWSCE", "yes", "",              "  windowsce", ' ');
1825         desc("STYLE_WINDOWSMOBILE" , "yes", "",         "  windowsmobile", ' ');
1826         desc("NATIVE_GESTURES", "no", "-no-native-gestures", "Do not use native gestures on Windows 7.");
1827         desc("NATIVE_GESTURES", "yes", "-native-gestures", "Use native gestures on Windows 7.");
1828         desc("MSVC_MP", "no", "-no-mp",                 "Do not use multiple processors for compiling with MSVC");
1829         desc("MSVC_MP", "yes", "-mp",                   "Use multiple processors for compiling with MSVC (-MP)");
1830
1831 /*      We do not support -qconfig on Windows yet
1832
1833         desc(                   "-qconfig <local>",     "Use src/tools/qconfig-local.h rather than the default.\nPossible values for local:");
1834         for (int i=0; i<allConfigs.size(); ++i)
1835             desc(               "",                     qPrintable(QString("  %1").arg(allConfigs.at(i))), false, ' ');
1836         printf("\n");
1837 */
1838 #endif
1839         desc(                   "-loadconfig <config>", "Run configure with the parameters from file configure_<config>.cache.");
1840         desc(                   "-saveconfig <config>", "Run configure and save the parameters in file configure_<config>.cache.");
1841         desc(                   "-redo",                "Run configure with the same parameters as last time.\n");
1842
1843         // Qt\Windows CE only options go below here -----------------------------------------------------------------------------
1844         desc("Qt for Windows CE only:\n\n");
1845         desc("IWMMXT", "no",       "-no-iwmmxt",           "Do not compile with use of IWMMXT instructions");
1846         desc("IWMMXT", "yes",      "-iwmmxt",              "Do compile with use of IWMMXT instructions (Qt for Windows CE on Arm only)");
1847         desc("CE_CRT", "no",       "-no-crt" ,             "Do not add the C runtime to default deployment rules");
1848         desc("CE_CRT", "yes",      "-qt-crt",              "Qt identifies C runtime during project generation");
1849         desc(                      "-crt <path>",          "Specify path to C runtime used for project generation.");
1850         desc("CETEST", "no",       "-no-cetest",           "Do not compile Windows CE remote test application");
1851         desc("CETEST", "yes",      "-cetest",              "Compile Windows CE remote test application");
1852         desc(                      "-signature <file>",    "Use file for signing the target project");
1853
1854         desc("DIRECTSHOW", "no",   "-phonon-wince-ds9",    "Enable Phonon Direct Show 9 backend for Windows CE");
1855         return true;
1856     }
1857     return false;
1858 }
1859
1860 QString Configure::findFileInPaths(const QString &fileName, const QString &paths)
1861 {
1862 #if defined(Q_OS_WIN32)
1863     QRegExp splitReg("[;,]");
1864 #else
1865     QRegExp splitReg("[:]");
1866 #endif
1867     QStringList pathList = paths.split(splitReg, QString::SkipEmptyParts);
1868     QDir d;
1869     for (QStringList::ConstIterator it = pathList.begin(); it != pathList.end(); ++it) {
1870         // Remove any leading or trailing ", this is commonly used in the environment
1871         // variables
1872         QString path = (*it);
1873         if (path.startsWith('\"'))
1874             path = path.right(path.length() - 1);
1875         if (path.endsWith('\"'))
1876             path = path.left(path.length() - 1);
1877         if (d.exists(path + QDir::separator() + fileName))
1878             return path;
1879     }
1880     return QString();
1881 }
1882
1883 static QString mingwPaths(const QString &mingwPath, const QString &pathName)
1884 {
1885     QString ret;
1886     QDir mingwDir = QFileInfo(mingwPath).dir();
1887     const QFileInfoList subdirs = mingwDir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
1888     for (int i = 0 ;i < subdirs.length(); ++i) {
1889         const QFileInfo &fi = subdirs.at(i);
1890         const QString name = fi.fileName();
1891         if (name == pathName)
1892             ret += fi.absoluteFilePath() + ';';
1893         else if (name.contains("mingw"))
1894             ret += fi.absoluteFilePath() + QDir::separator() + pathName + ';';
1895     }
1896     return ret;
1897 }
1898
1899 bool Configure::findFile(const QString &fileName)
1900 {
1901     const QString file = fileName.toLower();
1902     const QString pathEnvVar = QString::fromLocal8Bit(getenv("PATH"));
1903     const QString mingwPath = dictionary["QMAKESPEC"].endsWith("-g++") ?
1904         findFileInPaths("g++.exe", pathEnvVar) : QString();
1905
1906     QString paths;
1907     if (file.endsWith(".h")) {
1908         if (!mingwPath.isNull()) {
1909             if (!findFileInPaths(file, mingwPaths(mingwPath, "include")).isNull())
1910                 return true;
1911             //now let's try the additional compiler path
1912
1913             const QFileInfoList mingwConfigs = QDir(mingwPath + QLatin1String("/../lib/gcc")).entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
1914             for (int i = 0; i < mingwConfigs.length(); ++i) {
1915                 const QDir mingwLibDir = mingwConfigs.at(i).absoluteFilePath();
1916                 foreach(const QFileInfo &version, mingwLibDir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot)) {
1917                     if (!findFileInPaths(file, version.absoluteFilePath() + QLatin1String("/include")).isNull())
1918                         return true;
1919                 }
1920             }
1921         }
1922         paths = QString::fromLocal8Bit(getenv("INCLUDE"));
1923     } else if (file.endsWith(".lib") ||  file.endsWith(".a")) {
1924         if (!mingwPath.isNull() && !findFileInPaths(file, mingwPaths(mingwPath, "lib")).isNull())
1925             return true;
1926         paths = QString::fromLocal8Bit(getenv("LIB"));
1927     } else {
1928         paths = pathEnvVar;
1929     }
1930     return !findFileInPaths(file, paths).isNull();
1931 }
1932
1933 /*!
1934     Default value for options marked as "auto" if the test passes.
1935     (Used both by the autoDetection() below, and the desc() function
1936     to mark (+) the default option of autodetecting options.
1937 */
1938 QString Configure::defaultTo(const QString &option)
1939 {
1940     // We prefer using the system version of the 3rd party libs
1941     if (option == "ZLIB"
1942         || option == "PCRE"
1943         || option == "LIBJPEG"
1944         || option == "LIBPNG")
1945         return "system";
1946
1947     // PNG is always built-in, never a plugin
1948     if (option == "PNG")
1949         return "yes";
1950
1951     // These database drivers and image formats can be built-in or plugins.
1952     // Prefer plugins when Qt is shared.
1953     if (dictionary[ "SHARED" ] == "yes") {
1954         if (option == "SQL_MYSQL"
1955             || option == "SQL_MYSQL"
1956             || option == "SQL_ODBC"
1957             || option == "SQL_OCI"
1958             || option == "SQL_PSQL"
1959             || option == "SQL_TDS"
1960             || option == "SQL_DB2"
1961             || option == "SQL_SQLITE"
1962             || option == "SQL_SQLITE2"
1963             || option == "SQL_IBASE"
1964             || option == "JPEG"
1965             || option == "GIF")
1966             return "plugin";
1967     }
1968
1969     // By default we do not want to compile OCI driver when compiling with
1970     // MinGW, due to lack of such support from Oracle. It prob. wont work.
1971     // (Customer may force the use though)
1972     if (dictionary["QMAKESPEC"].endsWith("-g++")
1973         && option == "SQL_OCI")
1974         return "no";
1975
1976     if (option == "SYNCQT"
1977         && (!QFile::exists(sourcePath + "/bin/syncqt") ||
1978             !QFile::exists(sourcePath + "/bin/syncqt.bat")))
1979         return "no";
1980
1981     return "yes";
1982 }
1983
1984 /*!
1985     Checks the system for the availability of a feature.
1986     Returns true if the feature is available, else false.
1987 */
1988 bool Configure::checkAvailability(const QString &part)
1989 {
1990     bool available = false;
1991     if (part == "STYLE_WINDOWSXP")
1992         available = (platform() == WINDOWS) && findFile("uxtheme.h");
1993
1994     else if (part == "ZLIB")
1995         available = findFile("zlib.h");
1996
1997     else if (part == "PCRE")
1998         available = findFile("pcre.h");
1999
2000     else if (part == "ICU")
2001         available = findFile("unicode/utypes.h") && findFile("unicode/ucol.h") && findFile("unicode/ustring.h") && findFile("icuin.lib");
2002
2003     else if (part == "LIBJPEG")
2004         available = findFile("jpeglib.h");
2005     else if (part == "LIBPNG")
2006         available = findFile("png.h");
2007     else if (part == "SQL_MYSQL")
2008         available = findFile("mysql.h") && findFile("libmySQL.lib");
2009     else if (part == "SQL_ODBC")
2010         available = findFile("sql.h") && findFile("sqlext.h") && findFile("odbc32.lib");
2011     else if (part == "SQL_OCI")
2012         available = findFile("oci.h") && findFile("oci.lib");
2013     else if (part == "SQL_PSQL")
2014         available = findFile("libpq-fe.h") && findFile("libpq.lib") && findFile("ws2_32.lib") && findFile("advapi32.lib");
2015     else if (part == "SQL_TDS")
2016         available = findFile("sybfront.h") && findFile("sybdb.h") && findFile("ntwdblib.lib");
2017     else if (part == "SQL_DB2")
2018         available = findFile("sqlcli.h") && findFile("sqlcli1.h") && findFile("db2cli.lib");
2019     else if (part == "SQL_SQLITE")
2020         available = true; // Built in, we have a fork
2021     else if (part == "SQL_SQLITE_LIB") {
2022         if (dictionary[ "SQL_SQLITE_LIB" ] == "system") {
2023             if ((platform() == QNX) || (platform() == BLACKBERRY)) {
2024                 available = true;
2025                 dictionary[ "QT_LFLAGS_SQLITE" ] += "-lsqlite3 -lz";
2026             } else {
2027                 available = findFile("sqlite3.h") && findFile("sqlite3.lib");
2028                 if (available)
2029                     dictionary[ "QT_LFLAGS_SQLITE" ] += "sqlite3.lib";
2030             }
2031         } else {
2032             available = true;
2033         }
2034     } else if (part == "SQL_SQLITE2")
2035         available = findFile("sqlite.h") && findFile("sqlite.lib");
2036     else if (part == "SQL_IBASE")
2037         available = findFile("ibase.h") && (findFile("gds32_ms.lib") || findFile("gds32.lib"));
2038     else if (part == "IWMMXT")
2039         available = (dictionary.value("XQMAKESPEC").startsWith("wince"));
2040     else if (part == "OPENGL_ES_CM")
2041         available = (dictionary.value("XQMAKESPEC").startsWith("wince"));
2042     else if (part == "OPENGL_ES_2")
2043         available = (dictionary.value("XQMAKESPEC").startsWith("wince"));
2044     else if (part == "DIRECTSHOW")
2045         available = (dictionary.value("XQMAKESPEC").startsWith("wince"));
2046     else if (part == "SSE2")
2047         available = tryCompileProject("common/sse2");
2048     else if (part == "SSE3")
2049         available = tryCompileProject("common/sse3");
2050     else if (part == "SSSE3")
2051         available = tryCompileProject("common/ssse3");
2052     else if (part == "SSE4_1")
2053         available = tryCompileProject("common/sse4_1");
2054     else if (part == "SSE4_2")
2055         available = tryCompileProject("common/sse4_2");
2056     else if (part == "AVX")
2057         available = tryCompileProject("common/avx");
2058     else if (part == "AVX2")
2059         available = tryCompileProject("common/avx2");
2060     else if (part == "OPENSSL")
2061         available = findFile("openssl\\ssl.h");
2062     else if (part == "DBUS")
2063         available = findFile("dbus\\dbus.h");
2064     else if (part == "CETEST") {
2065         QString rapiHeader = locateFile("rapi.h");
2066         QString rapiLib = locateFile("rapi.lib");
2067         available = (dictionary.value("XQMAKESPEC").startsWith("wince")) && !rapiHeader.isEmpty() && !rapiLib.isEmpty();
2068         if (available) {
2069             dictionary[ "QT_CE_RAPI_INC" ] += QLatin1String("\"") + rapiHeader + QLatin1String("\"");
2070             dictionary[ "QT_CE_RAPI_LIB" ] += QLatin1String("\"") + rapiLib + QLatin1String("\"");
2071         }
2072         else if (dictionary[ "CETEST_REQUESTED" ] == "yes") {
2073             cout << "cetest could not be enabled: rapi.h and rapi.lib could not be found." << endl;
2074             cout << "Make sure the environment is set up for compiling with ActiveSync." << endl;
2075             dictionary[ "DONE" ] = "error";
2076         }
2077     }
2078     else if (part == "INCREDIBUILD_XGE")
2079         available = findFile("BuildConsole.exe") && findFile("xgConsole.exe");
2080     else if (part == "PHONON") {
2081         available = findFile("vmr9.h") && findFile("dshow.h") && findFile("dmo.h") && findFile("dmodshow.h")
2082             && (findFile("strmiids.lib") || findFile("libstrmiids.a"))
2083             && (findFile("dmoguids.lib") || findFile("libdmoguids.a"))
2084             && (findFile("msdmo.lib") || findFile("libmsdmo.a"))
2085             && findFile("d3d9.h");
2086
2087         if (!available) {
2088             cout << "All the required DirectShow/Direct3D files couldn't be found." << endl
2089                  << "Make sure you have either the platform SDK AND the DirectShow SDK or the Windows SDK installed." << endl
2090                  << "If you have the DirectShow SDK installed, please make sure that you have run the <path to SDK>\\SetEnv.Cmd script." << endl;
2091             if (!findFile("vmr9.h"))  cout << "vmr9.h not found" << endl;
2092             if (!findFile("dshow.h")) cout << "dshow.h not found" << endl;
2093             if (!findFile("strmiids.lib")) cout << "strmiids.lib not found" << endl;
2094             if (!findFile("dmoguids.lib")) cout << "dmoguids.lib not found" << endl;
2095             if (!findFile("msdmo.lib")) cout << "msdmo.lib not found" << endl;
2096             if (!findFile("d3d9.h")) cout << "d3d9.h not found" << endl;
2097         }
2098     } else if (part == "WMSDK") {
2099         available = findFile("wmsdk.h");
2100     } else if (part == "V8SNAPSHOT") {
2101         available = true;
2102     } else if (part == "AUDIO_BACKEND") {
2103         available = true;
2104     } else if (part == "DIRECTWRITE") {
2105         available = findFile("dwrite.h") && findFile("d2d1.h") && findFile("dwrite.lib");
2106     } else if (part == "ICONV") {
2107         available = tryCompileProject("unix/iconv") || tryCompileProject("unix/gnu-libiconv");
2108     } else if (part == "CUPS") {
2109         available = (platform() != WINDOWS) && (platform() != WINDOWS_CE) && tryCompileProject("unix/cups");
2110     }
2111
2112     return available;
2113 }
2114
2115 /*
2116     Autodetect options marked as "auto".
2117 */
2118 void Configure::autoDetection()
2119 {
2120     // Style detection
2121     if (dictionary["STYLE_WINDOWSXP"] == "auto")
2122         dictionary["STYLE_WINDOWSXP"] = checkAvailability("STYLE_WINDOWSXP") ? defaultTo("STYLE_WINDOWSXP") : "no";
2123     if (dictionary["STYLE_WINDOWSVISTA"] == "auto") // Vista style has the same requirements as XP style
2124         dictionary["STYLE_WINDOWSVISTA"] = checkAvailability("STYLE_WINDOWSXP") ? defaultTo("STYLE_WINDOWSVISTA") : "no";
2125
2126     // Compression detection
2127     if (dictionary["ZLIB"] == "auto")
2128         dictionary["ZLIB"] =  checkAvailability("ZLIB") ? defaultTo("ZLIB") : "qt";
2129
2130     // PCRE detection
2131     if (dictionary["PCRE"] == "auto")
2132         dictionary["PCRE"] = checkAvailability("PCRE") ? defaultTo("PCRE") : "qt";
2133
2134     // ICU detection
2135     if (dictionary["ICU"] == "auto")
2136         dictionary["ICU"] = checkAvailability("ICU") ? "yes" : "no";
2137
2138     // Image format detection
2139     if (dictionary["GIF"] == "auto")
2140         dictionary["GIF"] = defaultTo("GIF");
2141     if (dictionary["JPEG"] == "auto")
2142         dictionary["JPEG"] = defaultTo("JPEG");
2143     if (dictionary["PNG"] == "auto")
2144         dictionary["PNG"] = defaultTo("PNG");
2145     if (dictionary["LIBJPEG"] == "auto")
2146         dictionary["LIBJPEG"] = checkAvailability("LIBJPEG") ? defaultTo("LIBJPEG") : "qt";
2147     if (dictionary["LIBPNG"] == "auto")
2148         dictionary["LIBPNG"] = checkAvailability("LIBPNG") ? defaultTo("LIBPNG") : "qt";
2149
2150     // SQL detection (not on by default)
2151     if (dictionary["SQL_MYSQL"] == "auto")
2152         dictionary["SQL_MYSQL"] = checkAvailability("SQL_MYSQL") ? defaultTo("SQL_MYSQL") : "no";
2153     if (dictionary["SQL_ODBC"] == "auto")
2154         dictionary["SQL_ODBC"] = checkAvailability("SQL_ODBC") ? defaultTo("SQL_ODBC") : "no";
2155     if (dictionary["SQL_OCI"] == "auto")
2156         dictionary["SQL_OCI"] = checkAvailability("SQL_OCI") ? defaultTo("SQL_OCI") : "no";
2157     if (dictionary["SQL_PSQL"] == "auto")
2158         dictionary["SQL_PSQL"] = checkAvailability("SQL_PSQL") ? defaultTo("SQL_PSQL") : "no";
2159     if (dictionary["SQL_TDS"] == "auto")
2160         dictionary["SQL_TDS"] = checkAvailability("SQL_TDS") ? defaultTo("SQL_TDS") : "no";
2161     if (dictionary["SQL_DB2"] == "auto")
2162         dictionary["SQL_DB2"] = checkAvailability("SQL_DB2") ? defaultTo("SQL_DB2") : "no";
2163     if (dictionary["SQL_SQLITE"] == "auto")
2164         dictionary["SQL_SQLITE"] = checkAvailability("SQL_SQLITE") ? defaultTo("SQL_SQLITE") : "no";
2165     if (dictionary["SQL_SQLITE_LIB"] == "system")
2166         if (!checkAvailability("SQL_SQLITE_LIB"))
2167             dictionary["SQL_SQLITE_LIB"] = "no";
2168     if (dictionary["SQL_SQLITE2"] == "auto")
2169         dictionary["SQL_SQLITE2"] = checkAvailability("SQL_SQLITE2") ? defaultTo("SQL_SQLITE2") : "no";
2170     if (dictionary["SQL_IBASE"] == "auto")
2171         dictionary["SQL_IBASE"] = checkAvailability("SQL_IBASE") ? defaultTo("SQL_IBASE") : "no";
2172     if (dictionary["SSE2"] == "auto")
2173         dictionary["SSE2"] = checkAvailability("SSE2") ? "yes" : "no";
2174     if (dictionary["SSE3"] == "auto")
2175         dictionary["SSE3"] = checkAvailability("SSE3") ? "yes" : "no";
2176     if (dictionary["SSSE3"] == "auto")
2177         dictionary["SSSE3"] = checkAvailability("SSSE3") ? "yes" : "no";
2178     if (dictionary["SSE4_1"] == "auto")
2179         dictionary["SSE4_1"] = checkAvailability("SSE4_1") ? "yes" : "no";
2180     if (dictionary["SSE4_2"] == "auto")
2181         dictionary["SSE4_2"] = checkAvailability("SSE4_2") ? "yes" : "no";
2182     if (dictionary["AVX"] == "auto")
2183         dictionary["AVX"] = checkAvailability("AVX") ? "yes" : "no";
2184     if (dictionary["AVX2"] == "auto")
2185         dictionary["AVX2"] = checkAvailability("AVX2") ? "yes" : "no";
2186     if (dictionary["IWMMXT"] == "auto")
2187         dictionary["IWMMXT"] = checkAvailability("IWMMXT") ? "yes" : "no";
2188     if (dictionary["OPENSSL"] == "auto")
2189         dictionary["OPENSSL"] = checkAvailability("OPENSSL") ? "yes" : "no";
2190     if (dictionary["DBUS"] == "auto")
2191         dictionary["DBUS"] = checkAvailability("DBUS") ? "yes" : "no";
2192     if (dictionary["V8SNAPSHOT"] == "auto")
2193         dictionary["V8SNAPSHOT"] = (dictionary["V8"] == "yes") && checkAvailability("V8SNAPSHOT") ? "yes" : "no";
2194     if (dictionary["QML_DEBUG"] == "auto")
2195         dictionary["QML_DEBUG"] = dictionary["QML"] == "yes" ? "yes" : "no";
2196     if (dictionary["AUDIO_BACKEND"] == "auto")
2197         dictionary["AUDIO_BACKEND"] = checkAvailability("AUDIO_BACKEND") ? "yes" : "no";
2198     if (dictionary["WMSDK"] == "auto")
2199         dictionary["WMSDK"] = checkAvailability("WMSDK") ? "yes" : "no";
2200
2201     // Qt/WinCE remote test application
2202     if (dictionary["CETEST"] == "auto")
2203         dictionary["CETEST"] = checkAvailability("CETEST") ? "yes" : "no";
2204
2205     // Detection of IncrediBuild buildconsole
2206     if (dictionary["INCREDIBUILD_XGE"] == "auto")
2207         dictionary["INCREDIBUILD_XGE"] = checkAvailability("INCREDIBUILD_XGE") ? "yes" : "no";
2208
2209     // Detection of iconv support
2210     if (dictionary["QT_ICONV"] == "auto")
2211         dictionary["QT_ICONV"] = checkAvailability("ICONV") ? "yes" : "no";
2212
2213     // Detection of cups support
2214     if (dictionary["QT_CUPS"] == "auto")
2215         dictionary["QT_CUPS"] = checkAvailability("CUPS") ? "yes" : "no";
2216
2217     // Mark all unknown "auto" to the default value..
2218     for (QMap<QString,QString>::iterator i = dictionary.begin(); i != dictionary.end(); ++i) {
2219         if (i.value() == "auto")
2220             i.value() = defaultTo(i.key());
2221     }
2222 }
2223
2224 bool Configure::verifyConfiguration()
2225 {
2226     if (dictionary["SQL_SQLITE_LIB"] == "no" && dictionary["SQL_SQLITE"] != "no") {
2227         cout << "WARNING: Configure could not detect the presence of a system SQLite3 lib." << endl
2228              << "Configure will therefore continue with the SQLite3 lib bundled with Qt." << endl
2229              << "(Press any key to continue..)";
2230         if (_getch() == 3) // _Any_ keypress w/no echo(eat <Enter> for stdout)
2231             exit(0);      // Exit cleanly for Ctrl+C
2232
2233         dictionary["SQL_SQLITE_LIB"] = "qt"; // Set to Qt's bundled lib an continue
2234     }
2235     if (dictionary["QMAKESPEC"].endsWith("-g++")
2236         && dictionary["SQL_OCI"] != "no") {
2237         cout << "WARNING: Qt does not support compiling the Oracle database driver with" << endl
2238              << "MinGW, due to lack of such support from Oracle. Consider disabling the" << endl
2239              << "Oracle driver, as the current build will most likely fail." << endl;
2240         cout << "(Press any key to continue..)";
2241         if (_getch() == 3) // _Any_ keypress w/no echo(eat <Enter> for stdout)
2242             exit(0);      // Exit cleanly for Ctrl+C
2243     }
2244     if (dictionary["QMAKESPEC"].endsWith("win32-msvc.net")) {
2245         cout << "WARNING: The makespec win32-msvc.net is deprecated. Consider using" << endl
2246              << "win32-msvc2002 or win32-msvc2003 instead." << endl;
2247         cout << "(Press any key to continue..)";
2248         if (_getch() == 3) // _Any_ keypress w/no echo(eat <Enter> for stdout)
2249             exit(0);      // Exit cleanly for Ctrl+C
2250     }
2251     if (0 != dictionary["ARM_FPU_TYPE"].size()) {
2252             QStringList l= QStringList()
2253                     << "softvfp"
2254                     << "softvfp+vfpv2"
2255                     << "vfpv2";
2256             if (!(l.contains(dictionary["ARM_FPU_TYPE"])))
2257                     cout << QString("WARNING: Using unsupported fpu flag: %1").arg(dictionary["ARM_FPU_TYPE"]) << endl;
2258     }
2259     if (dictionary["DIRECTWRITE"] == "yes" && !checkAvailability("DIRECTWRITE")) {
2260         cout << "WARNING: To be able to compile the DirectWrite font engine you will" << endl
2261              << "need the Microsoft DirectWrite and Microsoft Direct2D development" << endl
2262              << "files such as headers and libraries." << endl
2263              << "(Press any key to continue..)";
2264         if (_getch() == 3) // _Any_ keypress w/no echo(eat <Enter> for stdout)
2265             exit(0);      // Exit cleanly for Ctrl+C
2266     }
2267
2268     return true;
2269 }
2270
2271 /*
2272  Things that affect the Qt API/ABI:
2273    Options:
2274      minimal-config small-config medium-config large-config full-config
2275
2276    Options:
2277      debug release
2278
2279  Things that do not affect the Qt API/ABI:
2280      system-jpeg no-jpeg jpeg
2281      system-png no-png png
2282      system-zlib no-zlib zlib
2283      no-gif gif
2284      dll staticlib
2285
2286      nocrosscompiler
2287      GNUmake
2288      largefile
2289      nis
2290      nas
2291      tablet
2292
2293      X11     : x11sm xinerama xcursor xfixes xrandr xrender fontconfig xkb
2294      Embedded: embedded freetype
2295 */
2296 void Configure::generateBuildKey()
2297 {
2298     QString spec = dictionary["QMAKESPEC"];
2299
2300     QString compiler = "msvc"; // ICC is compatible
2301     if (spec.endsWith("-g++"))
2302         compiler = "mingw";
2303     else if (spec.endsWith("-borland"))
2304         compiler = "borland";
2305
2306     // Build options which changes the Qt API/ABI
2307     QStringList build_options;
2308     if (!dictionary["QCONFIG"].isEmpty())
2309         build_options += dictionary["QCONFIG"] + "-config ";
2310     build_options.sort();
2311
2312     // Sorted defines that start with QT_NO_
2313     QStringList build_defines = qmakeDefines.filter(QRegExp("^QT_NO_"));
2314     build_defines.sort();
2315 }
2316
2317 void Configure::generateOutputVars()
2318 {
2319     // Generate variables for output
2320     QString build = dictionary[ "BUILD" ];
2321     bool buildAll = (dictionary[ "BUILDALL" ] == "yes");
2322     if (build == "debug") {
2323         if (buildAll)
2324             qtConfig += "debug_and_release build_all release";
2325         qtConfig += "debug";
2326     } else if (build == "release") {
2327         if (buildAll)
2328             qtConfig += "debug_and_release build_all debug";
2329         qtConfig += "release";
2330     }
2331
2332     if (dictionary[ "SHARED" ] == "no")
2333         qtConfig += "static";
2334     else
2335         qtConfig += "shared";
2336
2337     if (dictionary[ "WIDGETS" ] == "no")
2338         qtConfig += "no-widgets";
2339
2340     // Compression --------------------------------------------------
2341     if (dictionary[ "ZLIB" ] == "qt")
2342         qtConfig += "zlib";
2343     else if (dictionary[ "ZLIB" ] == "system")
2344         qtConfig += "system-zlib";
2345
2346     // PCRE ---------------------------------------------------------
2347     if (dictionary[ "PCRE" ] == "qt")
2348         qmakeConfig += "pcre";
2349
2350     // ICU ---------------------------------------------------------
2351     if (dictionary[ "ICU" ] == "yes")
2352         qtConfig  += "icu";
2353
2354     // Image formates -----------------------------------------------
2355     if (dictionary[ "GIF" ] == "no")
2356         qtConfig += "no-gif";
2357     else if (dictionary[ "GIF" ] == "yes")
2358         qtConfig += "gif";
2359
2360     if (dictionary[ "JPEG" ] == "no")
2361         qtConfig += "no-jpeg";
2362     else if (dictionary[ "JPEG" ] == "yes")
2363         qtConfig += "jpeg";
2364     if (dictionary[ "LIBJPEG" ] == "system")
2365         qtConfig += "system-jpeg";
2366
2367     if (dictionary[ "PNG" ] == "no")
2368         qtConfig += "no-png";
2369     else if (dictionary[ "PNG" ] == "yes")
2370         qtConfig += "png";
2371     if (dictionary[ "LIBPNG" ] == "system")
2372         qtConfig += "system-png";
2373
2374     // Text rendering --------------------------------------------------
2375     if (dictionary[ "FREETYPE" ] == "yes")
2376         qtConfig += "freetype";
2377     else if (dictionary[ "FREETYPE" ] == "system")
2378         qtConfig += "system-freetype";
2379
2380     // Styles -------------------------------------------------------
2381     if (dictionary[ "STYLE_WINDOWS" ] == "yes")
2382         qmakeStyles += "windows";
2383
2384     if (dictionary[ "STYLE_PLASTIQUE" ] == "yes")
2385         qmakeStyles += "plastique";
2386
2387     if (dictionary[ "STYLE_CLEANLOOKS" ] == "yes")
2388         qmakeStyles += "cleanlooks";
2389
2390     if (dictionary[ "STYLE_WINDOWSXP" ] == "yes")
2391         qmakeStyles += "windowsxp";
2392
2393     if (dictionary[ "STYLE_WINDOWSVISTA" ] == "yes")
2394         qmakeStyles += "windowsvista";
2395
2396     if (dictionary[ "STYLE_MOTIF" ] == "yes")
2397         qmakeStyles += "motif";
2398
2399     if (dictionary[ "STYLE_SGI" ] == "yes")
2400         qmakeStyles += "sgi";
2401
2402     if (dictionary[ "STYLE_WINDOWSCE" ] == "yes")
2403     qmakeStyles += "windowsce";
2404
2405     if (dictionary[ "STYLE_WINDOWSMOBILE" ] == "yes")
2406     qmakeStyles += "windowsmobile";
2407
2408     if (dictionary[ "STYLE_CDE" ] == "yes")
2409         qmakeStyles += "cde";
2410
2411     // Databases ----------------------------------------------------
2412     if (dictionary[ "SQL_MYSQL" ] == "yes")
2413         qmakeSql += "mysql";
2414     else if (dictionary[ "SQL_MYSQL" ] == "plugin")
2415         qmakeSqlPlugins += "mysql";
2416
2417     if (dictionary[ "SQL_ODBC" ] == "yes")
2418         qmakeSql += "odbc";
2419     else if (dictionary[ "SQL_ODBC" ] == "plugin")
2420         qmakeSqlPlugins += "odbc";
2421
2422     if (dictionary[ "SQL_OCI" ] == "yes")
2423         qmakeSql += "oci";
2424     else if (dictionary[ "SQL_OCI" ] == "plugin")
2425         qmakeSqlPlugins += "oci";
2426
2427     if (dictionary[ "SQL_PSQL" ] == "yes")
2428         qmakeSql += "psql";
2429     else if (dictionary[ "SQL_PSQL" ] == "plugin")
2430         qmakeSqlPlugins += "psql";
2431
2432     if (dictionary[ "SQL_TDS" ] == "yes")
2433         qmakeSql += "tds";
2434     else if (dictionary[ "SQL_TDS" ] == "plugin")
2435         qmakeSqlPlugins += "tds";
2436
2437     if (dictionary[ "SQL_DB2" ] == "yes")
2438         qmakeSql += "db2";
2439     else if (dictionary[ "SQL_DB2" ] == "plugin")
2440         qmakeSqlPlugins += "db2";
2441
2442     if (dictionary[ "SQL_SQLITE" ] == "yes")
2443         qmakeSql += "sqlite";
2444     else if (dictionary[ "SQL_SQLITE" ] == "plugin")
2445         qmakeSqlPlugins += "sqlite";
2446
2447     if (dictionary[ "SQL_SQLITE_LIB" ] == "system")
2448         qmakeConfig += "system-sqlite";
2449
2450     if (dictionary[ "SQL_SQLITE2" ] == "yes")
2451         qmakeSql += "sqlite2";
2452     else if (dictionary[ "SQL_SQLITE2" ] == "plugin")
2453         qmakeSqlPlugins += "sqlite2";
2454
2455     if (dictionary[ "SQL_IBASE" ] == "yes")
2456         qmakeSql += "ibase";
2457     else if (dictionary[ "SQL_IBASE" ] == "plugin")
2458         qmakeSqlPlugins += "ibase";
2459
2460     // Other options ------------------------------------------------
2461     if (dictionary[ "BUILDALL" ] == "yes") {
2462         qtConfig += "build_all";
2463     }
2464     qmakeConfig += dictionary[ "BUILD" ];
2465     dictionary[ "QMAKE_OUTDIR" ] = dictionary[ "BUILD" ];
2466
2467     if (buildParts.isEmpty()) {
2468         buildParts = defaultBuildParts;
2469
2470         if (dictionary["BUILDDEV"] == "yes")
2471             buildParts += "tests";
2472     }
2473     while (!nobuildParts.isEmpty())
2474         buildParts.removeAll(nobuildParts.takeFirst());
2475     if (!buildParts.contains("libs"))
2476         buildParts += "libs";
2477     buildParts.removeDuplicates();
2478
2479     if (dictionary["MSVC_MP"] == "yes")
2480         qmakeConfig += "msvc_mp";
2481
2482     if (dictionary[ "SHARED" ] == "yes") {
2483         QString version = dictionary[ "VERSION" ];
2484         if (!version.isEmpty()) {
2485             qmakeVars += "QMAKE_QT_VERSION_OVERRIDE = " + version.left(version.indexOf("."));
2486             version.remove(QLatin1Char('.'));
2487         }
2488         dictionary[ "QMAKE_OUTDIR" ] += "_shared";
2489     } else {
2490         dictionary[ "QMAKE_OUTDIR" ] += "_static";
2491     }
2492
2493     if (dictionary[ "ACCESSIBILITY" ] == "yes")
2494         qtConfig += "accessibility";
2495
2496     if (!qmakeLibs.isEmpty())
2497         qmakeVars += "LIBS           += " + formatPaths(qmakeLibs);
2498
2499     if (!dictionary["QT_LFLAGS_SQLITE"].isEmpty())
2500         qmakeVars += "QT_LFLAGS_SQLITE += " + formatPath(dictionary["QT_LFLAGS_SQLITE"]);
2501
2502     if (dictionary[ "OPENGL" ] == "yes")
2503         qtConfig += "opengl";
2504
2505     if (dictionary["OPENGL_ES_CM"] == "yes") {
2506         qtConfig += "opengles1";
2507         qtConfig += "egl";
2508     }
2509
2510     if (dictionary["OPENGL_ES_2"] == "yes") {
2511         qtConfig += "opengles2";
2512         qtConfig += "egl";
2513     }
2514
2515     if (dictionary["OPENVG"] == "yes") {
2516         qtConfig += "openvg";
2517         qtConfig += "egl";
2518     }
2519
2520     // ### Vestige
2521      if (dictionary["DIRECTSHOW"] == "yes")
2522         qtConfig += "directshow";
2523
2524     if (dictionary[ "OPENSSL" ] == "yes")
2525         qtConfig += "openssl";
2526     else if (dictionary[ "OPENSSL" ] == "linked")
2527         qtConfig += "openssl-linked";
2528
2529     if (dictionary[ "DBUS" ] == "yes")
2530         qtConfig += "dbus";
2531     else if (dictionary[ "DBUS" ] == "linked")
2532         qtConfig += "dbus dbus-linked";
2533
2534     if (dictionary[ "CETEST" ] == "yes")
2535         qtConfig += "cetest";
2536
2537     // ### Vestige
2538     if (dictionary["PHONON_BACKEND"] == "yes")
2539         qtConfig += "phonon-backend";
2540
2541     // ### Vestige
2542     if (dictionary["AUDIO_BACKEND"] == "yes")
2543         qtConfig += "audio-backend";
2544
2545     if (dictionary["DIRECTWRITE"] == "yes")
2546         qtConfig += "directwrite";
2547
2548     if (dictionary[ "NATIVE_GESTURES" ] == "yes")
2549         qtConfig += "native-gestures";
2550
2551     qtConfig += "qpa";
2552
2553     if (dictionary["NIS"] == "yes")
2554         qtConfig += "nis";
2555
2556     if (dictionary["QT_CUPS"] == "yes")
2557         qtConfig += "cups";
2558
2559     if (dictionary["QT_ICONV"] == "yes")
2560         qtConfig += "iconv";
2561     else if (dictionary["QT_ICONV"] == "sun")
2562         qtConfig += "sun-libiconv";
2563     else if (dictionary["QT_ICONV"] == "gnu")
2564         qtConfig += "gnu-libiconv";
2565
2566     if (dictionary["FONT_CONFIG"] == "yes") {
2567         qtConfig += "fontconfig";
2568         qmakeVars += "QMAKE_CFLAGS_FONTCONFIG =";
2569         qmakeVars += "QMAKE_LIBS_FONTCONFIG   = -lfreetype -lfontconfig";
2570     }
2571
2572     if (dictionary["QT_GLIB"] == "yes")
2573         qtConfig += "glib";
2574
2575     // We currently have no switch for QtConcurrent, so add it unconditionally.
2576     qtConfig += "concurrent";
2577
2578     // ### Vestige
2579     if (dictionary[ "V8SNAPSHOT" ] == "yes")
2580         qtConfig += "v8snapshot";
2581
2582     // Add config levels --------------------------------------------
2583     QStringList possible_configs = QStringList()
2584         << "minimal"
2585         << "small"
2586         << "medium"
2587         << "large"
2588         << "full";
2589
2590     QString set_config = dictionary["QCONFIG"];
2591     if (possible_configs.contains(set_config)) {
2592         foreach (const QString &cfg, possible_configs) {
2593             qtConfig += (cfg + "-config");
2594             if (cfg == set_config)
2595                 break;
2596         }
2597     }
2598
2599     if (dictionary.contains("XQMAKESPEC") && (dictionary["QMAKESPEC"] != dictionary["XQMAKESPEC"])) {
2600             qmakeConfig += "cross_compile";
2601             dictionary["CROSS_COMPILE"] = "yes";
2602     }
2603
2604     // Directories and settings for .qmake.cache --------------------
2605
2606     if (dictionary.contains("XQMAKESPEC") && dictionary[ "XQMAKESPEC" ].startsWith("linux"))
2607         dictionary[ "QMAKE_RPATHDIR" ] = dictionary[ "QT_INSTALL_LIBS" ];
2608
2609     qmakeVars += QString("OBJECTS_DIR     = ") + formatPath("tmp/obj/" + dictionary["QMAKE_OUTDIR"]);
2610     qmakeVars += QString("MOC_DIR         = ") + formatPath("tmp/moc/" + dictionary["QMAKE_OUTDIR"]);
2611     qmakeVars += QString("RCC_DIR         = ") + formatPath("tmp/rcc/" + dictionary["QMAKE_OUTDIR"]);
2612
2613     if (!qmakeDefines.isEmpty())
2614         qmakeVars += QString("DEFINES        += ") + qmakeDefines.join(" ");
2615     if (!qmakeIncludes.isEmpty())
2616         qmakeVars += QString("INCLUDEPATH    += ") + formatPaths(qmakeIncludes);
2617     if (!opensslLibs.isEmpty())
2618         qmakeVars += opensslLibs;
2619     if (dictionary[ "OPENSSL" ] == "linked") {
2620         if (!opensslLibsDebug.isEmpty() || !opensslLibsRelease.isEmpty()) {
2621             if (opensslLibsDebug.isEmpty() || opensslLibsRelease.isEmpty()) {
2622                 cout << "Error: either both or none of OPENSSL_LIBS_DEBUG/_RELEASE must be defined." << endl;
2623                 exit(1);
2624             }
2625             qmakeVars += opensslLibsDebug;
2626             qmakeVars += opensslLibsRelease;
2627         } else if (opensslLibs.isEmpty()) {
2628             qmakeVars += QString("OPENSSL_LIBS    = -lssleay32 -llibeay32");
2629         }
2630     }
2631     if (!psqlLibs.isEmpty())
2632         qmakeVars += QString("QT_LFLAGS_PSQL=") + psqlLibs.section("=", 1);
2633
2634     {
2635         QStringList lflagsTDS;
2636         if (!sybase.isEmpty())
2637             lflagsTDS += QString("-L") + formatPath(sybase.section("=", 1) + "/lib");
2638         if (!sybaseLibs.isEmpty())
2639             lflagsTDS += sybaseLibs.section("=", 1);
2640         if (!lflagsTDS.isEmpty())
2641             qmakeVars += QString("QT_LFLAGS_TDS=") + lflagsTDS.join(" ");
2642     }
2643
2644     if (!qmakeSql.isEmpty())
2645         qmakeVars += QString("sql-drivers    += ") + qmakeSql.join(" ");
2646     if (!qmakeSqlPlugins.isEmpty())
2647         qmakeVars += QString("sql-plugins    += ") + qmakeSqlPlugins.join(" ");
2648     if (!qmakeStyles.isEmpty())
2649         qmakeVars += QString("styles         += ") + qmakeStyles.join(" ");
2650     if (!qmakeStylePlugins.isEmpty())
2651         qmakeVars += QString("style-plugins  += ") + qmakeStylePlugins.join(" ");
2652
2653     if (dictionary["QMAKESPEC"].endsWith("-g++")) {
2654         QString includepath = qgetenv("INCLUDE");
2655         bool hasSh = Environment::detectExecutable("sh.exe");
2656         QChar separator = (!includepath.contains(":\\") && hasSh ? QChar(':') : QChar(';'));
2657         qmakeVars += QString("TMPPATH            = $$quote($$(INCLUDE))");
2658         qmakeVars += QString("QMAKE_INCDIR_POST += $$split(TMPPATH,\"%1\")").arg(separator);
2659         qmakeVars += QString("TMPPATH            = $$quote($$(LIB))");
2660         qmakeVars += QString("QMAKE_LIBDIR_POST += $$split(TMPPATH,\"%1\")").arg(separator);
2661     }
2662
2663     if (!dictionary[ "QMAKESPEC" ].length()) {
2664         cout << "Configure could not detect your compiler. QMAKESPEC must either" << endl
2665              << "be defined as an environment variable, or specified as an" << endl
2666              << "argument with -platform" << endl;
2667         dictionary[ "HELP" ] = "yes";
2668
2669         QStringList winPlatforms;
2670         QDir mkspecsDir(sourcePath + "/mkspecs");
2671         const QFileInfoList &specsList = mkspecsDir.entryInfoList();
2672         for (int i = 0; i < specsList.size(); ++i) {
2673             const QFileInfo &fi = specsList.at(i);
2674             if (fi.fileName().left(5) == "win32") {
2675                 winPlatforms += fi.fileName();
2676             }
2677         }
2678         cout << "Available platforms are: " << qPrintable(winPlatforms.join(", ")) << endl;
2679         dictionary[ "DONE" ] = "error";
2680     }
2681 }
2682
2683 #if !defined(EVAL)
2684 void Configure::generateCachefile()
2685 {
2686     // Generate .qmake.cache
2687     QFile cacheFile(buildPath + "/.qmake.cache");
2688     if (cacheFile.open(QFile::WriteOnly | QFile::Text)) { // Truncates any existing file.
2689         QTextStream cacheStream(&cacheFile);
2690
2691         cacheStream << "include($$PWD/mkspecs/qmodule.pri)" << endl;
2692
2693         for (QStringList::Iterator var = qmakeVars.begin(); var != qmakeVars.end(); ++var) {
2694             cacheStream << (*var) << endl;
2695         }
2696         cacheStream << "CONFIG         += " << qmakeConfig.join(" ") << "depend_includepath no_private_qt_headers_warning QTDIR_build" << endl;
2697
2698         cacheStream.flush();
2699         cacheFile.close();
2700     }
2701
2702     // Generate qmodule.pri
2703     QFile moduleFile(dictionary[ "QT_BUILD_TREE" ] + "/mkspecs/qmodule.pri");
2704     if (moduleFile.open(QFile::WriteOnly | QFile::Text)) { // Truncates any existing file.
2705         QTextStream moduleStream(&moduleFile);
2706
2707         moduleStream << "#paths" << endl;
2708         moduleStream << "QT_BUILD_TREE   = " << formatPath(dictionary["QT_BUILD_TREE"]) << endl;
2709         moduleStream << "QT_SOURCE_TREE  = " << formatPath(dictionary["QT_SOURCE_TREE"]) << endl;
2710         moduleStream << "QT_BUILD_PARTS += " << buildParts.join(" ") << endl << endl;
2711
2712         if (dictionary["QT_EDITION"] != "QT_EDITION_OPENSOURCE")
2713             moduleStream << "DEFINES        *= QT_EDITION=QT_EDITION_DESKTOP" << endl;
2714
2715         if (dictionary["CETEST"] == "yes") {
2716             moduleStream << "QT_CE_RAPI_INC  = " << formatPath(dictionary["QT_CE_RAPI_INC"]) << endl;
2717             moduleStream << "QT_CE_RAPI_LIB  = " << formatPath(dictionary["QT_CE_RAPI_LIB"]) << endl;
2718         }
2719
2720         moduleStream << "#Qt for Windows CE c-runtime deployment" << endl
2721                      << "QT_CE_C_RUNTIME = " << formatPath(dictionary["CE_CRT"]) << endl;
2722
2723         if (dictionary["CE_SIGNATURE"] != QLatin1String("no"))
2724             moduleStream << "DEFAULT_SIGNATURE=" << dictionary["CE_SIGNATURE"] << endl;
2725
2726         // embedded
2727         if (!dictionary["KBD_DRIVERS"].isEmpty())
2728             moduleStream << "kbd-drivers += "<< dictionary["KBD_DRIVERS"]<<endl;
2729         if (!dictionary["GFX_DRIVERS"].isEmpty())
2730             moduleStream << "gfx-drivers += "<< dictionary["GFX_DRIVERS"]<<endl;
2731         if (!dictionary["MOUSE_DRIVERS"].isEmpty())
2732             moduleStream << "mouse-drivers += "<< dictionary["MOUSE_DRIVERS"]<<endl;
2733         if (!dictionary["DECORATIONS"].isEmpty())
2734             moduleStream << "decorations += "<<dictionary["DECORATIONS"]<<endl;
2735
2736         moduleStream << "CONFIG += create_prl link_prl";
2737         if (dictionary[ "SSE2" ] == "yes")
2738             moduleStream << " sse2";
2739         if (dictionary[ "SSE3" ] == "yes")
2740             moduleStream << " sse3";
2741         if (dictionary[ "SSSE3" ] == "yes")
2742             moduleStream << " ssse3";
2743         if (dictionary[ "SSE4_1" ] == "yes")
2744             moduleStream << " sse4_1";
2745         if (dictionary[ "SSE4_2" ] == "yes")
2746             moduleStream << " sse4_2";
2747         if (dictionary[ "AVX" ] == "yes")
2748             moduleStream << " avx";
2749         if (dictionary[ "AVX2" ] == "yes")
2750             moduleStream << " avx2";
2751         if (dictionary[ "IWMMXT" ] == "yes")
2752             moduleStream << " iwmmxt";
2753         if (dictionary[ "NEON" ] == "yes")
2754             moduleStream << " neon";
2755         if (dictionary[ "LARGE_FILE" ] == "yes")
2756             moduleStream << " largefile";
2757         moduleStream << endl;
2758
2759         moduleStream.flush();
2760         moduleFile.close();
2761     }
2762 }
2763
2764 struct ArchData {
2765     const char *qmakespec;
2766     const char *key;
2767     const char *subarchKey;
2768     const char *type;
2769     ArchData() {}
2770     ArchData(const char *t, const char *qm, const char *k, const char *sak)
2771         : qmakespec(qm), key(k), subarchKey(sak), type(t)
2772     {}
2773 };
2774
2775 /*
2776     Runs qmake on config.tests/arch/arch.pro, which will detect the target arch
2777     for the compiler we are using
2778 */
2779 void Configure::detectArch()
2780 {
2781     QString oldpwd = QDir::currentPath();
2782
2783     QString newpwd = QString("%1/config.tests/arch").arg(buildPath);
2784     if (!QDir().exists(newpwd) && !QDir().mkpath(newpwd)) {
2785         cout << "Failed to create directory " << qPrintable(QDir::toNativeSeparators(newpwd)) << endl;
2786         dictionary["DONE"] = "error";
2787         return;
2788     }
2789     if (!QDir::setCurrent(newpwd)) {
2790         cout << "Failed to change working directory to " << qPrintable(QDir::toNativeSeparators(newpwd)) << endl;
2791         dictionary["DONE"] = "error";
2792         return;
2793     }
2794
2795     QVector<ArchData> qmakespecs;
2796     if (dictionary.contains("XQMAKESPEC"))
2797         qmakespecs << ArchData("target", "XQMAKESPEC", "QT_ARCH", "QT_CPU_FEATURES");
2798     qmakespecs << ArchData("host", "QMAKESPEC", "QT_HOST_ARCH", "QT_HOST_CPU_FEATURES");
2799
2800     for (int i = 0; i < qmakespecs.count(); ++i) {
2801         const ArchData &data = qmakespecs.at(i);
2802         QString qmakespec = dictionary.value(data.qmakespec);
2803         QString key = data.key;
2804         QString subarchKey = data.subarchKey;
2805
2806         // run qmake
2807         QString command = QString("%1 -spec %2 %3 2>&1")
2808             .arg(QDir::toNativeSeparators(buildPath + "/bin/qmake.exe"),
2809                  QDir::toNativeSeparators(qmakespec),
2810                  QDir::toNativeSeparators(sourcePath + "/config.tests/arch/arch.pro"));
2811         Environment::execute(command);
2812
2813         // compile
2814         command = dictionary[ "MAKE" ];
2815         if (command.contains("nmake"))
2816             command += " /NOLOGO";
2817         command += " -s";
2818         Environment::execute(command);
2819
2820         // find the executable that was generated
2821         QFile exe("arch.exe");
2822         if (!exe.open(QFile::ReadOnly)) { // no Text, this is binary
2823             exe.setFileName("arch");
2824             if (!exe.open(QFile::ReadOnly)) {
2825                 cout << "Could not find output file: " << qPrintable(exe.errorString()) << endl;
2826                 dictionary["DONE"] = "error";
2827                 return;
2828             }
2829         }
2830         QByteArray exeContents = exe.readAll();
2831         exe.close();
2832
2833         static const char archMagic[] = "==Qt=magic=Qt== Architecture:";
2834         int magicPos = exeContents.indexOf(archMagic);
2835         if (magicPos == -1) {
2836             cout << "Internal error, could not find the architecture of the "
2837                  << data.type << " executable" << endl;
2838             dictionary["DONE"] = "error";
2839             return;
2840         }
2841         //cout << "Found magic at offset 0x" << hex << magicPos << endl;
2842
2843         // the conversion from QByteArray will stop at the ending NUL anyway
2844         QString arch = QString::fromLatin1(exeContents.constData() + magicPos
2845                                            + sizeof(archMagic) - 1);
2846         dictionary[key] = arch;
2847
2848         static const char subarchMagic[] = "==Qt=magic=Qt== Sub-architecture:";
2849         magicPos = exeContents.indexOf(subarchMagic);
2850         if (magicPos == -1) {
2851             cout << "Internal error, could not find the sub-architecture of the "
2852                  << data.type << " executable" << endl;
2853             dictionary["DONE"] = "error";
2854             return;
2855         }
2856
2857         QString subarch = QString::fromLatin1(exeContents.constData() + magicPos
2858                                               + sizeof(subarchMagic) - 1);
2859         dictionary[subarchKey] = subarch;
2860
2861         //cout << "Detected arch '" << qPrintable(arch) << "'\n";
2862         //cout << "Detected sub-arch '" << qPrintable(subarch) << "'\n";
2863
2864         // clean up
2865         Environment::execute(command + " distclean");
2866     }
2867
2868     if (!dictionary.contains("QT_HOST_ARCH"))
2869         dictionary["QT_HOST_ARCH"] = "unknown";
2870     if (!dictionary.contains("QT_ARCH")) {
2871         dictionary["QT_ARCH"] = dictionary["QT_HOST_ARCH"];
2872         dictionary["QT_CPU_FEATURES"] = dictionary["QT_HOST_CPU_FEATURES"];
2873     }
2874
2875     QDir::setCurrent(oldpwd);
2876 }
2877
2878 bool Configure::tryCompileProject(const QString &projectPath, const QString &extraOptions)
2879 {
2880     QString oldpwd = QDir::currentPath();
2881
2882     QString newpwd = QString("%1/config.tests/%2").arg(buildPath, projectPath);
2883     if (!QDir().exists(newpwd) && !QDir().mkpath(newpwd)) {
2884         cout << "Failed to create directory " << qPrintable(QDir::toNativeSeparators(newpwd)) << endl;
2885         dictionary["DONE"] = "error";
2886         return false;
2887     }
2888     if (!QDir::setCurrent(newpwd)) {
2889         cout << "Failed to change working directory to " << qPrintable(QDir::toNativeSeparators(newpwd)) << endl;
2890         dictionary["DONE"] = "error";
2891         return false;
2892     }
2893
2894     // run qmake
2895     QString command = QString("%1 %2 %3 2>&1")
2896         .arg(QDir::toNativeSeparators(buildPath + "/bin/qmake.exe"),
2897              QDir::toNativeSeparators(sourcePath + "/config.tests/" + projectPath),
2898              extraOptions);
2899     int code = 0;
2900     QString output = Environment::execute(command, &code);
2901     //cout << output << endl;
2902
2903     if (code == 0) {
2904         // compile
2905         command = dictionary[ "MAKE" ];
2906         if (command.contains("nmake"))
2907             command += " /NOLOGO";
2908         command += " -s 2>&1";
2909         output = Environment::execute(command, &code);
2910         //cout << output << endl;
2911
2912         // clean up
2913         Environment::execute(command + " distclean 2>&1");
2914     }
2915
2916     QDir::setCurrent(oldpwd);
2917     return code == 0;
2918 }
2919
2920 void Configure::generateQConfigPri()
2921 {
2922     // Generate qconfig.pri
2923     QFile configFile(dictionary[ "QT_BUILD_TREE" ] + "/mkspecs/qconfig.pri");
2924     if (configFile.open(QFile::WriteOnly | QFile::Text)) { // Truncates any existing file.
2925         QTextStream configStream(&configFile);
2926
2927         configStream << "CONFIG+= ";
2928         configStream << dictionary[ "BUILD" ];
2929
2930         if (dictionary[ "LTCG" ] == "yes")
2931             configStream << " ltcg";
2932         if (dictionary[ "RTTI" ] == "yes")
2933             configStream << " rtti";
2934         if (dictionary["INCREDIBUILD_XGE"] == "yes")
2935             configStream << " incredibuild_xge";
2936         if (dictionary["PLUGIN_MANIFESTS"] == "no")
2937             configStream << " no_plugin_manifest";
2938         if (dictionary["CROSS_COMPILE"] == "yes")
2939             configStream << " cross_compile";
2940
2941         if (dictionary["DIRECTWRITE"] == "yes")
2942             configStream << "directwrite";
2943
2944         // ### For compatibility only, should be removed later.
2945         configStream << " qpa";
2946
2947         configStream << endl;
2948         configStream << "QT_ARCH = " << dictionary["QT_ARCH"] << endl;
2949         configStream << "QT_HOST_ARCH = " << dictionary["QT_HOST_ARCH"] << endl;
2950         configStream << "QT_CPU_FEATURES = " << dictionary["QT_CPU_FEATURES"] << endl;
2951         configStream << "QT_HOST_CPU_FEATURES = " << dictionary["QT_HOST_CPU_FEATURES"] << endl;
2952         if (dictionary["QT_EDITION"].contains("OPENSOURCE"))
2953             configStream << "QT_EDITION = " << QLatin1String("OpenSource") << endl;
2954         else
2955             configStream << "QT_EDITION = " << dictionary["EDITION"] << endl;
2956         configStream << "QT_CONFIG += " << qtConfig.join(" ") << endl;
2957
2958         configStream << "#versioning " << endl
2959                      << "QT_VERSION = " << dictionary["VERSION"] << endl
2960                      << "QT_MAJOR_VERSION = " << dictionary["VERSION_MAJOR"] << endl
2961                      << "QT_MINOR_VERSION = " << dictionary["VERSION_MINOR"] << endl
2962                      << "QT_PATCH_VERSION = " << dictionary["VERSION_PATCH"] << endl;
2963
2964         if (!dictionary["CFG_SYSROOT"].isEmpty() && dictionary["CFG_GCC_SYSROOT"] == "yes") {
2965             configStream << endl
2966                          << "# sysroot" << endl
2967                          << "!host_build {" << endl
2968                          << "    QMAKE_CFLAGS    += --sysroot=$$[QT_SYSROOT]" << endl
2969                          << "    QMAKE_CXXFLAGS  += --sysroot=$$[QT_SYSROOT]" << endl
2970                          << "    QMAKE_LFLAGS    += --sysroot=$$[QT_SYSROOT]" << endl
2971                          << "}" << endl;
2972         }
2973
2974         if (!dictionary["QMAKE_RPATHDIR"].isEmpty())
2975             configStream << "QMAKE_RPATHDIR += " << formatPath(dictionary["QMAKE_RPATHDIR"]) << endl;
2976
2977         if (!dictionary["QT_LIBINFIX"].isEmpty())
2978             configStream << "QT_LIBINFIX = " << dictionary["QT_LIBINFIX"] << endl;
2979
2980         if (!dictionary["QT_NAMESPACE"].isEmpty())
2981             configStream << "#namespaces" << endl << "QT_NAMESPACE = " << dictionary["QT_NAMESPACE"] << endl;
2982
2983         if (dictionary.value(QStringLiteral("OPENGL_ES_2")) == QStringLiteral("yes")) {
2984             const QString angleDir = dictionary.value(QStringLiteral("ANGLE_DIR"));
2985             if (!angleDir.isEmpty()) {
2986                 configStream
2987                     << "QMAKE_INCDIR_OPENGL_ES2 = " << angleDir << "/include\n"
2988                     << "QMAKE_LIBDIR_OPENGL_ES2_DEBUG = " << angleDir << "/lib/Debug\n"
2989                     << "QMAKE_LIBDIR_OPENGL_ES2_RELEASE = " << angleDir << "/lib/Release\n";
2990             }
2991         }
2992
2993         configStream.flush();
2994         configFile.close();
2995     }
2996 }
2997 #endif
2998
2999 QString Configure::addDefine(QString def)
3000 {
3001     QString result, defNeg, defD = def;
3002
3003     defD.replace(QRegExp("=.*"), "");
3004     def.replace(QRegExp("="), " ");
3005
3006     if (def.startsWith("QT_NO_")) {
3007         defNeg = defD;
3008         defNeg.replace("QT_NO_", "QT_");
3009     } else if (def.startsWith("QT_")) {
3010         defNeg = defD;
3011         defNeg.replace("QT_", "QT_NO_");
3012     }
3013
3014     if (defNeg.isEmpty()) {
3015         result = "#ifndef $DEFD\n"
3016                  "# define $DEF\n"
3017                  "#endif\n\n";
3018     } else {
3019         result = "#if defined($DEFD) && defined($DEFNEG)\n"
3020                  "# undef $DEFD\n"
3021                  "#elif !defined($DEFD)\n"
3022                  "# define $DEF\n"
3023                  "#endif\n\n";
3024     }
3025     result.replace("$DEFNEG", defNeg);
3026     result.replace("$DEFD", defD);
3027     result.replace("$DEF", def);
3028     return result;
3029 }
3030
3031 #if !defined(EVAL)
3032 bool Configure::copySpec(const char *name, const char *pfx, const QString &spec)
3033 {
3034     // "Link" configured mkspec to default directory, but remove the old one first, if there is any
3035     QString defSpec = buildPath + "/mkspecs/" + name;
3036     QFileInfo defSpecInfo(defSpec);
3037     if (defSpecInfo.exists()) {
3038         if (!Environment::rmdir(defSpec)) {
3039             cout << "Couldn't update default " << pfx << "mkspec! Are files in " << qPrintable(defSpec) << " read-only?" << endl;
3040             dictionary["DONE"] = "error";
3041             return false;
3042         }
3043     }
3044
3045     QDir::current().mkpath(defSpec);
3046     QFile qfile(defSpec + "/qmake.conf");
3047     if (qfile.open(QFile::WriteOnly | QFile::Text)) {
3048         QTextStream fileStream;
3049         fileStream.setDevice(&qfile);
3050         QString srcSpec = buildPath + "/mkspecs/" + spec; // We copied it to the build dir
3051         fileStream << "QMAKESPEC_ORIGINAL = " << formatPath(srcSpec) << endl;
3052         fileStream << "include(" << formatPath(QDir(defSpec).relativeFilePath(srcSpec + "/qmake.conf")) << ")" << endl;
3053         qfile.close();
3054     }
3055     if (qfile.error() != QFile::NoError) {
3056         cout << "Couldn't update default " << pfx << "mkspec: " << qPrintable(qfile.errorString()) << endl;
3057         dictionary["DONE"] = "error";
3058         return false;
3059     }
3060     return true;
3061 }
3062
3063 void Configure::generateConfigfiles()
3064 {
3065     QDir(buildPath).mkpath("src/corelib/global");
3066     QString outName(buildPath + "/src/corelib/global/qconfig.h");
3067     QTemporaryFile tmpFile;
3068     QTextStream tmpStream;
3069
3070     if (tmpFile.open()) {
3071         tmpStream.setDevice(&tmpFile);
3072
3073         if (dictionary[ "QCONFIG" ] == "full") {
3074             tmpStream << "/* Everything */" << endl;
3075         } else {
3076             QString configName("qconfig-" + dictionary[ "QCONFIG" ] + ".h");
3077             tmpStream << "/* Copied from " << configName << "*/" << endl;
3078             tmpStream << "#ifndef QT_BOOTSTRAPPED" << endl;
3079             QFile inFile(sourcePath + "/src/corelib/global/" + configName);
3080             if (inFile.open(QFile::ReadOnly)) {
3081                 QByteArray buffer = inFile.readAll();
3082                 tmpFile.write(buffer.constData(), buffer.size());
3083                 inFile.close();
3084             }
3085             tmpStream << "#endif // QT_BOOTSTRAPPED" << endl;
3086         }
3087         tmpStream << endl;
3088
3089         if (dictionary[ "SHARED" ] == "no") {
3090             tmpStream << "/* Qt was configured for a static build */" << endl
3091                       << "#if !defined(QT_SHARED) && !defined(QT_STATIC)" << endl
3092                       << "# define QT_STATIC" << endl
3093                       << "#endif" << endl
3094                       << endl;
3095         }
3096         tmpStream << "/* License information */" << endl;
3097         tmpStream << "#define QT_PRODUCT_LICENSEE \"" << licenseInfo[ "LICENSEE" ] << "\"" << endl;
3098         tmpStream << "#define QT_PRODUCT_LICENSE \"" << dictionary[ "EDITION" ] << "\"" << endl;
3099         tmpStream << endl;
3100         tmpStream << "// Qt Edition" << endl;
3101         tmpStream << "#ifndef QT_EDITION" << endl;
3102         tmpStream << "#  define QT_EDITION " << dictionary["QT_EDITION"] << endl;
3103         tmpStream << "#endif" << endl;
3104         tmpStream << endl;
3105         if (dictionary["BUILDDEV"] == "yes") {
3106             dictionary["QMAKE_INTERNAL"] = "yes";
3107             tmpStream << "/* Used for example to export symbols for the certain autotests*/" << endl;
3108             tmpStream << "#define QT_BUILD_INTERNAL" << endl;
3109             tmpStream << endl;
3110         }
3111
3112         tmpStream << endl << "// Compile time features" << endl;
3113
3114         QStringList qconfigList;
3115         if (dictionary["STYLE_WINDOWS"] != "yes")     qconfigList += "QT_NO_STYLE_WINDOWS";
3116         if (dictionary["STYLE_PLASTIQUE"] != "yes")   qconfigList += "QT_NO_STYLE_PLASTIQUE";
3117         if (dictionary["STYLE_CLEANLOOKS"] != "yes")   qconfigList += "QT_NO_STYLE_CLEANLOOKS";
3118         if (dictionary["STYLE_WINDOWSXP"] != "yes" && dictionary["STYLE_WINDOWSVISTA"] != "yes")
3119             qconfigList += "QT_NO_STYLE_WINDOWSXP";
3120         if (dictionary["STYLE_WINDOWSVISTA"] != "yes")   qconfigList += "QT_NO_STYLE_WINDOWSVISTA";
3121         if (dictionary["STYLE_MOTIF"] != "yes")       qconfigList += "QT_NO_STYLE_MOTIF";
3122         if (dictionary["STYLE_CDE"] != "yes")         qconfigList += "QT_NO_STYLE_CDE";
3123
3124         // ### We still need the QT_NO_STYLE_S60 define for compiling Qt. Remove later!
3125         qconfigList += "QT_NO_STYLE_S60";
3126
3127         if (dictionary["STYLE_WINDOWSCE"] != "yes")   qconfigList += "QT_NO_STYLE_WINDOWSCE";
3128         if (dictionary["STYLE_WINDOWSMOBILE"] != "yes")   qconfigList += "QT_NO_STYLE_WINDOWSMOBILE";
3129         if (dictionary["STYLE_GTK"] != "yes")         qconfigList += "QT_NO_STYLE_GTK";
3130
3131         if (dictionary["GIF"] == "yes")              qconfigList += "QT_BUILTIN_GIF_READER=1";
3132         if (dictionary["PNG"] != "yes")              qconfigList += "QT_NO_IMAGEFORMAT_PNG";
3133         if (dictionary["JPEG"] != "yes")             qconfigList += "QT_NO_IMAGEFORMAT_JPEG";
3134         if (dictionary["ZLIB"] == "no") {
3135             qconfigList += "QT_NO_ZLIB";
3136             qconfigList += "QT_NO_COMPRESS";
3137         }
3138
3139         if (dictionary["ACCESSIBILITY"] == "no")     qconfigList += "QT_NO_ACCESSIBILITY";
3140         if (dictionary["WIDGETS"] == "no")           qconfigList += "QT_NO_WIDGETS";
3141         if (dictionary["OPENGL"] == "no")            qconfigList += "QT_NO_OPENGL";
3142         if (dictionary["OPENVG"] == "no")            qconfigList += "QT_NO_OPENVG";
3143         if (dictionary["OPENSSL"] == "no") {
3144             qconfigList += "QT_NO_OPENSSL";
3145             qconfigList += "QT_NO_SSL";
3146         }
3147         if (dictionary["OPENSSL"] == "linked")       qconfigList += "QT_LINKED_OPENSSL";
3148         if (dictionary["DBUS"] == "no")              qconfigList += "QT_NO_DBUS";
3149         if (dictionary["QML_DEBUG"] == "no")         qconfigList += "QT_QML_NO_DEBUGGER";
3150         if (dictionary["FREETYPE"] == "no")          qconfigList += "QT_NO_FREETYPE";
3151         if (dictionary["NATIVE_GESTURES"] == "no")   qconfigList += "QT_NO_NATIVE_GESTURES";
3152
3153         if (dictionary["OPENGL_ES_CM"] == "yes" ||
3154            dictionary["OPENGL_ES_2"]  == "yes")     qconfigList += "QT_OPENGL_ES";
3155
3156         if (dictionary["OPENGL_ES_CM"] == "yes")     qconfigList += "QT_OPENGL_ES_1";
3157         if (dictionary["OPENGL_ES_2"]  == "yes")     qconfigList += "QT_OPENGL_ES_2";
3158         if (dictionary["SQL_MYSQL"] == "yes")        qconfigList += "QT_SQL_MYSQL";
3159         if (dictionary["SQL_ODBC"] == "yes")         qconfigList += "QT_SQL_ODBC";
3160         if (dictionary["SQL_OCI"] == "yes")          qconfigList += "QT_SQL_OCI";
3161         if (dictionary["SQL_PSQL"] == "yes")         qconfigList += "QT_SQL_PSQL";
3162         if (dictionary["SQL_TDS"] == "yes")          qconfigList += "QT_SQL_TDS";
3163         if (dictionary["SQL_DB2"] == "yes")          qconfigList += "QT_SQL_DB2";
3164         if (dictionary["SQL_SQLITE"] == "yes")       qconfigList += "QT_SQL_SQLITE";
3165         if (dictionary["SQL_SQLITE2"] == "yes")      qconfigList += "QT_SQL_SQLITE2";
3166         if (dictionary["SQL_IBASE"] == "yes")        qconfigList += "QT_SQL_IBASE";
3167
3168         if (dictionary["POSIX_IPC"] == "yes")        qconfigList += "QT_POSIX_IPC";
3169
3170         if (dictionary["FONT_CONFIG"] == "no")       qconfigList += "QT_NO_FONTCONFIG";
3171
3172         if (dictionary["NIS"] == "yes")
3173             qconfigList += "QT_NIS";
3174         else
3175             qconfigList += "QT_NO_NIS";
3176
3177         if (dictionary["LARGE_FILE"] == "yes")
3178             tmpStream << "#define QT_LARGEFILE_SUPPORT 64" << endl;
3179
3180
3181         qconfigList.sort();
3182         for (int i = 0; i < qconfigList.count(); ++i)
3183             tmpStream << addDefine(qconfigList.at(i));
3184
3185         if (dictionary[ "QT_CUPS" ] == "no")
3186           tmpStream<<"#define QT_NO_CUPS"<<endl;
3187
3188         if (dictionary[ "QT_ICONV" ]  == "no")
3189           tmpStream<<"#define QT_NO_ICONV"<<endl;
3190
3191         if (dictionary[ "QT_GLIB" ] == "no")
3192           tmpStream<<"#define QT_NO_GLIB"<<endl;
3193
3194         if (dictionary[ "QT_INOTIFY" ] == "no")
3195           tmpStream<<"#define QT_NO_INOTIFY"<<endl;
3196
3197         tmpStream<<"#define QT_QPA_DEFAULT_PLATFORM_NAME \"" << qpaPlatformName() << "\""<<endl;
3198
3199         tmpStream.flush();
3200         tmpFile.flush();
3201
3202         // Replace old qconfig.h with new one
3203         ::SetFileAttributes((wchar_t*)outName.utf16(), FILE_ATTRIBUTE_NORMAL);
3204         QFile::remove(outName);
3205         tmpFile.copy(outName);
3206         tmpFile.close();
3207     }
3208
3209     QTemporaryFile tmpFile3;
3210     if (tmpFile3.open()) {
3211         tmpStream.setDevice(&tmpFile3);
3212         tmpStream << "/* Evaluation license key */" << endl
3213                   << "static const volatile char qt_eval_key_data              [512 + 12] = \"qt_qevalkey=" << licenseInfo["LICENSEKEYEXT"] << "\";" << endl;
3214
3215         tmpStream.flush();
3216         tmpFile3.flush();
3217
3218         outName = buildPath + "/src/corelib/global/qconfig_eval.cpp";
3219         ::SetFileAttributes((wchar_t*)outName.utf16(), FILE_ATTRIBUTE_NORMAL);
3220         QFile::remove(outName);
3221
3222         if (dictionary["EDITION"] == "Evaluation" || qmakeDefines.contains("QT_EVAL"))
3223             tmpFile3.copy(outName);
3224         tmpFile3.close();
3225     }
3226 }
3227 #endif
3228
3229 #if !defined(EVAL)
3230 void Configure::displayConfig()
3231 {
3232     fstream sout;
3233     sout.open(QString(buildPath + "/config.summary").toLocal8Bit().constData(),
3234               ios::in | ios::out | ios::trunc);
3235
3236     // Give some feedback
3237     sout << "Environment:" << endl;
3238     QString env = QString::fromLocal8Bit(getenv("INCLUDE")).replace(QRegExp("[;,]"), "\r\n      ");
3239     if (env.isEmpty())
3240         env = "Unset";
3241     sout << "    INCLUDE=\r\n      " << env << endl;
3242     env = QString::fromLocal8Bit(getenv("LIB")).replace(QRegExp("[;,]"), "\r\n      ");
3243     if (env.isEmpty())
3244         env = "Unset";
3245     sout << "    LIB=\r\n      " << env << endl;
3246     env = QString::fromLocal8Bit(getenv("PATH")).replace(QRegExp("[;,]"), "\r\n      ");
3247     if (env.isEmpty())
3248         env = "Unset";
3249     sout << "    PATH=\r\n      " << env << endl;
3250
3251     if (dictionary[QStringLiteral("EDITION")] != QStringLiteral("OpenSource")) {
3252         QString l1 = licenseInfo[ "LICENSEE" ];
3253         QString l2 = licenseInfo[ "LICENSEID" ];
3254         QString l3 = dictionary["EDITION"] + ' ' + "Edition";
3255         QString l4 = licenseInfo[ "EXPIRYDATE" ];
3256         sout << "Licensee...................." << (l1.isNull() ? "" : l1) << endl;
3257         sout << "License ID.................." << (l2.isNull() ? "" : l2) << endl;
3258         sout << "Product license............." << (l3.isNull() ? "" : l3) << endl;
3259         sout << "Expiry Date................." << (l4.isNull() ? "" : l4) << endl << endl;
3260     }
3261
3262     sout << "Configuration:" << endl;
3263     sout << "    " << qmakeConfig.join("\r\n    ") << endl;
3264     sout << "Qt Configuration:" << endl;
3265     sout << "    " << qtConfig.join("\r\n    ") << endl;
3266     sout << endl;
3267
3268     if (dictionary.contains("XQMAKESPEC"))
3269         sout << "QMAKESPEC..................." << dictionary[ "XQMAKESPEC" ] << " (" << dictionary["QMAKESPEC_FROM"] << ")" << endl;
3270     else
3271         sout << "QMAKESPEC..................." << dictionary[ "QMAKESPEC" ] << " (" << dictionary["QMAKESPEC_FROM"] << ")" << endl;
3272     sout << "Architecture................" << dictionary["QT_ARCH"]
3273          << ", features:" << dictionary["QT_CPU_FEATURES"] << endl;
3274     sout << "Host Architecture..........." << dictionary["QT_HOST_ARCH"]
3275          << ", features:" << dictionary["QT_HOST_CPU_FEATURES"]  << endl;
3276     sout << "Maketool...................." << dictionary[ "MAKE" ] << endl;
3277     sout << "Debug symbols..............." << (dictionary[ "BUILD" ] == "debug" ? "yes" : "no") << endl;
3278     sout << "Link Time Code Generation..." << dictionary[ "LTCG" ] << endl;
3279     sout << "Accessibility support......." << dictionary[ "ACCESSIBILITY" ] << endl;
3280     sout << "RTTI support................" << dictionary[ "RTTI" ] << endl;
3281     sout << "SSE2 support................" << dictionary[ "SSE2" ] << endl;
3282     sout << "SSE3 support................" << dictionary[ "SSE3" ] << endl;
3283     sout << "SSSE3 support..............." << dictionary[ "SSSE3" ] << endl;
3284     sout << "SSE4.1 support.............." << dictionary[ "SSE4_1" ] << endl;
3285     sout << "SSE4.2 support.............." << dictionary[ "SSE4_2" ] << endl;
3286     sout << "AVX support................." << dictionary[ "AVX" ] << endl;
3287     sout << "AVX2 support................" << dictionary[ "AVX2" ] << endl;
3288     sout << "NEON support................" << dictionary[ "NEON" ] << endl;
3289     sout << "IWMMXT support.............." << dictionary[ "IWMMXT" ] << endl;
3290     sout << "OpenGL support.............." << dictionary[ "OPENGL" ] << endl;
3291     sout << "Large File support.........." << dictionary[ "LARGE_FILE" ] << endl;
3292     sout << "NIS support................." << dictionary[ "NIS" ] << endl;
3293     sout << "Iconv support..............." << dictionary[ "QT_ICONV" ] << endl;
3294     sout << "Glib support................" << dictionary[ "QT_GLIB" ] << endl;
3295     sout << "CUPS support................" << dictionary[ "QT_CUPS" ] << endl;
3296     if (dictionary.value(QStringLiteral("OPENGL_ES_2")) == QStringLiteral("yes")) {
3297         const QString angleDir = dictionary.value(QStringLiteral("ANGLE_DIR"));
3298         if (!angleDir.isEmpty())
3299             sout << "ANGLE......................." << QDir::toNativeSeparators(angleDir) << endl;
3300     }
3301     sout << "OpenVG support.............." << dictionary[ "OPENVG" ] << endl;
3302     sout << "OpenSSL support............." << dictionary[ "OPENSSL" ] << endl;
3303     sout << "QtDBus support.............." << dictionary[ "DBUS" ] << endl;
3304     sout << "QtWidgets module support...." << dictionary[ "WIDGETS" ] << endl;
3305     sout << "QML debugging..............." << dictionary[ "QML_DEBUG" ] << endl;
3306     sout << "DirectWrite support........." << dictionary[ "DIRECTWRITE" ] << endl << endl;
3307
3308     sout << "Third Party Libraries:" << endl;
3309     sout << "    ZLIB support............" << dictionary[ "ZLIB" ] << endl;
3310     sout << "    GIF support............." << dictionary[ "GIF" ] << endl;
3311     sout << "    JPEG support............" << dictionary[ "JPEG" ] << endl;
3312     sout << "    PNG support............." << dictionary[ "PNG" ] << endl;
3313     sout << "    FreeType support........" << dictionary[ "FREETYPE" ] << endl << endl;
3314     sout << "    PCRE support............" << dictionary[ "PCRE" ] << endl;
3315     sout << "    ICU support............." << dictionary[ "ICU" ] << endl;
3316
3317     sout << "Styles:" << endl;
3318     sout << "    Windows................." << dictionary[ "STYLE_WINDOWS" ] << endl;
3319     sout << "    Windows XP.............." << dictionary[ "STYLE_WINDOWSXP" ] << endl;
3320     sout << "    Windows Vista..........." << dictionary[ "STYLE_WINDOWSVISTA" ] << endl;
3321     sout << "    Plastique..............." << dictionary[ "STYLE_PLASTIQUE" ] << endl;
3322     sout << "    Cleanlooks.............." << dictionary[ "STYLE_CLEANLOOKS" ] << endl;
3323     sout << "    Motif..................." << dictionary[ "STYLE_MOTIF" ] << endl;
3324     sout << "    CDE....................." << dictionary[ "STYLE_CDE" ] << endl;
3325     sout << "    Windows CE.............." << dictionary[ "STYLE_WINDOWSCE" ] << endl;
3326     sout << "    Windows Mobile.........." << dictionary[ "STYLE_WINDOWSMOBILE" ] << endl << endl;
3327
3328     sout << "Sql Drivers:" << endl;
3329     sout << "    ODBC...................." << dictionary[ "SQL_ODBC" ] << endl;
3330     sout << "    MySQL..................." << dictionary[ "SQL_MYSQL" ] << endl;
3331     sout << "    OCI....................." << dictionary[ "SQL_OCI" ] << endl;
3332     sout << "    PostgreSQL.............." << dictionary[ "SQL_PSQL" ] << endl;
3333     sout << "    TDS....................." << dictionary[ "SQL_TDS" ] << endl;
3334     sout << "    DB2....................." << dictionary[ "SQL_DB2" ] << endl;
3335     sout << "    SQLite.................." << dictionary[ "SQL_SQLITE" ] << " (" << dictionary[ "SQL_SQLITE_LIB" ] << ")" << endl;
3336     sout << "    SQLite2................." << dictionary[ "SQL_SQLITE2" ] << endl;
3337     sout << "    InterBase..............." << dictionary[ "SQL_IBASE" ] << endl << endl;
3338
3339     sout << "Sources are in.............." << QDir::toNativeSeparators(dictionary["QT_SOURCE_TREE"]) << endl;
3340     sout << "Build is done in............" << QDir::toNativeSeparators(dictionary["QT_BUILD_TREE"]) << endl;
3341     sout << "Install prefix.............." << QDir::toNativeSeparators(dictionary["QT_INSTALL_PREFIX"]) << endl;
3342     sout << "Headers installed to........" << QDir::toNativeSeparators(dictionary["QT_INSTALL_HEADERS"]) << endl;
3343     sout << "Libraries installed to......" << QDir::toNativeSeparators(dictionary["QT_INSTALL_LIBS"]) << endl;
3344     sout << "Plugins installed to........" << QDir::toNativeSeparators(dictionary["QT_INSTALL_PLUGINS"]) << endl;
3345     sout << "Imports installed to........" << QDir::toNativeSeparators(dictionary["QT_INSTALL_IMPORTS"]) << endl;
3346     sout << "Binaries installed to......." << QDir::toNativeSeparators(dictionary["QT_INSTALL_BINS"]) << endl;
3347     sout << "Docs installed to..........." << QDir::toNativeSeparators(dictionary["QT_INSTALL_DOCS"]) << endl;
3348     sout << "Data installed to..........." << QDir::toNativeSeparators(dictionary["QT_INSTALL_DATA"]) << endl;
3349     sout << "Translations installed to..." << QDir::toNativeSeparators(dictionary["QT_INSTALL_TRANSLATIONS"]) << endl;
3350     sout << "Examples installed to......." << QDir::toNativeSeparators(dictionary["QT_INSTALL_EXAMPLES"]) << endl;
3351     sout << "Tests installed to.........." << QDir::toNativeSeparators(dictionary["QT_INSTALL_TESTS"]) << endl;
3352
3353     if (dictionary.contains("XQMAKESPEC") && dictionary["XQMAKESPEC"].startsWith(QLatin1String("wince"))) {
3354         sout << "Using c runtime detection..." << dictionary[ "CE_CRT" ] << endl;
3355         sout << "Cetest support.............." << dictionary[ "CETEST" ] << endl;
3356         sout << "Signature..................." << dictionary[ "CE_SIGNATURE"] << endl << endl;
3357     }
3358
3359     if (checkAvailability("INCREDIBUILD_XGE"))
3360         sout << "Using IncrediBuild XGE......" << dictionary["INCREDIBUILD_XGE"] << endl;
3361     if (!qmakeDefines.isEmpty()) {
3362         sout << "Defines.....................";
3363         for (QStringList::Iterator defs = qmakeDefines.begin(); defs != qmakeDefines.end(); ++defs)
3364             sout << (*defs) << " ";
3365         sout << endl;
3366     }
3367     if (!qmakeIncludes.isEmpty()) {
3368         sout << "Include paths...............";
3369         for (QStringList::Iterator incs = qmakeIncludes.begin(); incs != qmakeIncludes.end(); ++incs)
3370             sout << (*incs) << " ";
3371         sout << endl;
3372     }
3373     if (!qmakeLibs.isEmpty()) {
3374         sout << "Additional libraries........";
3375         for (QStringList::Iterator libs = qmakeLibs.begin(); libs != qmakeLibs.end(); ++libs)
3376             sout << (*libs) << " ";
3377         sout << endl;
3378     }
3379     if (dictionary[ "QMAKE_INTERNAL" ] == "yes") {
3380         sout << "Using internal configuration." << endl;
3381     }
3382     if (dictionary[ "SHARED" ] == "no") {
3383         sout << "WARNING: Using static linking will disable the use of plugins." << endl;
3384         sout << "         Make sure you compile ALL needed modules into the library." << endl;
3385     }
3386     if (dictionary[ "OPENSSL" ] == "linked") {
3387         if (!opensslLibsDebug.isEmpty() || !opensslLibsRelease.isEmpty()) {
3388             sout << "Using OpenSSL libraries:" << endl;
3389             sout << "   debug  : " << opensslLibsDebug << endl;
3390             sout << "   release: " << opensslLibsRelease << endl;
3391             sout << "   both   : " << opensslLibs << endl;
3392         } else if (opensslLibs.isEmpty()) {
3393             sout << "NOTE: When linking against OpenSSL, you can override the default" << endl;
3394             sout << "library names through OPENSSL_LIBS and optionally OPENSSL_LIBS_DEBUG/OPENSSL_LIBS_RELEASE" << endl;
3395             sout << "For example:" << endl;
3396             sout << "    configure -openssl-linked OPENSSL_LIBS=\"-lssleay32 -llibeay32\"" << endl;
3397         }
3398     }
3399     if (dictionary[ "ZLIB_FORCED" ] == "yes") {
3400         QString which_zlib = "supplied";
3401         if (dictionary[ "ZLIB" ] == "system")
3402             which_zlib = "system";
3403
3404         sout << "NOTE: The -no-zlib option was supplied but is no longer supported." << endl
3405              << endl
3406              << "Qt now requires zlib support in all builds, so the -no-zlib" << endl
3407              << "option was ignored. Qt will be built using the " << which_zlib
3408              << "zlib" << endl;
3409     }
3410     if (dictionary["OBSOLETE_ARCH_ARG"] == "yes") {
3411         sout << endl
3412              << "NOTE: The -arch option is obsolete." << endl
3413              << endl
3414              << "Qt now detects the target and host architectures based on compiler" << endl
3415              << "output. Qt will be built using " << dictionary["QT_ARCH"] << " for the target architecture" << endl
3416              << "and " << dictionary["QT_HOST_ARCH"] << " for the host architecture (note that these two" << endl
3417              << "will be the same unless you are cross-compiling)." << endl
3418              << endl;
3419     }
3420
3421     // display config.summary
3422     sout.seekg(0, ios::beg);
3423     while (sout) {
3424         string str;
3425         getline(sout, str);
3426         cout << str << endl;
3427     }
3428 }
3429 #endif
3430
3431 #if !defined(EVAL)
3432 void Configure::generateHeaders()
3433 {
3434     if (dictionary["SYNCQT"] == "yes") {
3435         if (findFile("perl.exe")) {
3436             cout << "Running syncqt..." << endl;
3437             QStringList args;
3438             args += buildPath + "/bin/syncqt.bat";
3439             args += sourcePath;
3440             QStringList env;
3441             env += QString("QTDIR=" + sourcePath);
3442             env += QString("PATH=" + buildPath + "/bin/;" + qgetenv("PATH"));
3443             int retc = Environment::execute(args, env, QStringList());
3444             if (retc) {
3445                 cout << "syncqt failed, return code " << retc << endl << endl;
3446                 dictionary["DONE"] = "error";
3447             }
3448         } else {
3449             cout << "Perl not found in environment - cannot run syncqt." << endl;
3450             dictionary["DONE"] = "error";
3451         }
3452     }
3453 }
3454
3455 void Configure::generateQConfigCpp()
3456 {
3457     // if QT_INSTALL_* have not been specified on commandline, define them now from QT_INSTALL_PREFIX
3458     // if prefix is empty (WINCE), make all of them empty, if they aren't set
3459     bool qipempty = false;
3460     if (dictionary["QT_INSTALL_PREFIX"].isEmpty())
3461         qipempty = true;
3462
3463     if (!dictionary["QT_INSTALL_DOCS"].size())
3464         dictionary["QT_INSTALL_DOCS"] = qipempty ? "" : dictionary["QT_INSTALL_PREFIX"] + "/doc";
3465     if (!dictionary["QT_INSTALL_HEADERS"].size())
3466         dictionary["QT_INSTALL_HEADERS"] = qipempty ? "" : dictionary["QT_INSTALL_PREFIX"] + "/include";
3467     if (!dictionary["QT_INSTALL_LIBS"].size())
3468         dictionary["QT_INSTALL_LIBS"] = qipempty ? "" : dictionary["QT_INSTALL_PREFIX"] + "/lib";
3469     if (!dictionary["QT_INSTALL_BINS"].size())
3470         dictionary["QT_INSTALL_BINS"] = qipempty ? "" : dictionary["QT_INSTALL_PREFIX"] + "/bin";
3471     if (!dictionary["QT_INSTALL_PLUGINS"].size())
3472         dictionary["QT_INSTALL_PLUGINS"] = qipempty ? "" : dictionary["QT_INSTALL_PREFIX"] + "/plugins";
3473     if (!dictionary["QT_INSTALL_IMPORTS"].size())
3474         dictionary["QT_INSTALL_IMPORTS"] = qipempty ? "" : dictionary["QT_INSTALL_PREFIX"] + "/imports";
3475     if (!dictionary["QT_INSTALL_DATA"].size())
3476         dictionary["QT_INSTALL_DATA"] = qipempty ? "" : dictionary["QT_INSTALL_PREFIX"];
3477     if (!dictionary["QT_INSTALL_TRANSLATIONS"].size())
3478         dictionary["QT_INSTALL_TRANSLATIONS"] = qipempty ? "" : dictionary["QT_INSTALL_PREFIX"] + "/translations";
3479     if (!dictionary["QT_INSTALL_EXAMPLES"].size())
3480         dictionary["QT_INSTALL_EXAMPLES"] = qipempty ? "" : dictionary["QT_INSTALL_PREFIX"] + "/examples";
3481     if (!dictionary["QT_INSTALL_TESTS"].size())
3482         dictionary["QT_INSTALL_TESTS"] = qipempty ? "" : dictionary["QT_INSTALL_PREFIX"] + "/tests";
3483
3484     bool haveHpx = false;
3485     if (dictionary["QT_HOST_PREFIX"].isEmpty())
3486         dictionary["QT_HOST_PREFIX"] = dictionary["QT_INSTALL_PREFIX"];
3487     else
3488         haveHpx = true;
3489     if (dictionary["QT_HOST_BINS"].isEmpty())
3490         dictionary["QT_HOST_BINS"] = haveHpx ? dictionary["QT_HOST_PREFIX"] + "/bin" : dictionary["QT_INSTALL_BINS"];
3491     if (dictionary["QT_HOST_DATA"].isEmpty())
3492         dictionary["QT_HOST_DATA"] = haveHpx ? dictionary["QT_HOST_PREFIX"] : dictionary["QT_INSTALL_DATA"];
3493
3494     // Generate the new qconfig.cpp file
3495     QDir(buildPath).mkpath("src/corelib/global");
3496     const QString outName(buildPath + "/src/corelib/global/qconfig.cpp");
3497
3498     QTemporaryFile tmpFile;
3499     if (tmpFile.open()) {
3500         QTextStream tmpStream(&tmpFile);
3501         tmpStream << "/* Licensed */" << endl
3502                   << "static const char qt_configure_licensee_str          [512 + 12] = \"qt_lcnsuser=" << licenseInfo["LICENSEE"] << "\";" << endl
3503                   << "static const char qt_configure_licensed_products_str [512 + 12] = \"qt_lcnsprod=" << dictionary["EDITION"] << "\";" << endl
3504                   << endl
3505                   << "/* Build date */" << endl
3506                   << "static const char qt_configure_installation          [11  + 12] = \"qt_instdate=" << QDate::currentDate().toString(Qt::ISODate) << "\";" << endl
3507                   << endl
3508                   << "static const char qt_configure_prefix_path_strs[][12 + 512] = {" << endl
3509                   << "    \"qt_prfxpath=" << formatPath(dictionary["QT_INSTALL_PREFIX"]) << "\"," << endl
3510                   << "    \"qt_docspath=" << formatPath(dictionary["QT_INSTALL_DOCS"]) << "\","  << endl
3511                   << "    \"qt_hdrspath=" << formatPath(dictionary["QT_INSTALL_HEADERS"]) << "\","  << endl
3512                   << "    \"qt_libspath=" << formatPath(dictionary["QT_INSTALL_LIBS"]) << "\","  << endl
3513                   << "    \"qt_binspath=" << formatPath(dictionary["QT_INSTALL_BINS"]) << "\","  << endl
3514                   << "    \"qt_plugpath=" << formatPath(dictionary["QT_INSTALL_PLUGINS"]) << "\","  << endl
3515                   << "    \"qt_impspath=" << formatPath(dictionary["QT_INSTALL_IMPORTS"]) << "\","  << endl
3516                   << "    \"qt_datapath=" << formatPath(dictionary["QT_INSTALL_DATA"]) << "\","  << endl
3517                   << "    \"qt_trnspath=" << formatPath(dictionary["QT_INSTALL_TRANSLATIONS"]) << "\"," << endl
3518                   << "    \"qt_xmplpath=" << formatPath(dictionary["QT_INSTALL_EXAMPLES"]) << "\","  << endl
3519                   << "    \"qt_tstspath=" << formatPath(dictionary["QT_INSTALL_TESTS"]) << "\","  << endl
3520                   << "#ifdef QT_BUILD_QMAKE" << endl
3521                   << "    \"qt_ssrtpath=" << formatPath(dictionary["CFG_SYSROOT"]) << "\"," << endl
3522                   << "    \"qt_hpfxpath=" << formatPath(dictionary["QT_HOST_PREFIX"]) << "\"," << endl
3523                   << "    \"qt_hbinpath=" << formatPath(dictionary["QT_HOST_BINS"]) << "\"," << endl
3524                   << "    \"qt_hdatpath=" << formatPath(dictionary["QT_HOST_DATA"]) << "\"," << endl
3525                   << "#endif" << endl
3526                   << "};" << endl;
3527
3528         if ((platform() != WINDOWS) && (platform() != WINDOWS_CE))
3529             tmpStream << "static const char qt_configure_settings_path_str [256 + 12] = \"qt_stngpath=" << formatPath(dictionary["QT_INSTALL_SETTINGS"]) << "\";" << endl;
3530
3531         tmpStream << endl
3532                   << "/* strlen( \"qt_lcnsxxxx\") == 12 */" << endl
3533                   << "#define QT_CONFIGURE_LICENSEE qt_configure_licensee_str + 12;" << endl
3534                   << "#define QT_CONFIGURE_LICENSED_PRODUCTS qt_configure_licensed_products_str + 12;" << endl;
3535
3536         if ((platform() != WINDOWS) && (platform() != WINDOWS_CE))
3537             tmpStream << "#define QT_CONFIGURE_SETTINGS_PATH qt_configure_settings_path_str + 12;" << endl;
3538
3539         tmpStream.flush();
3540         tmpFile.flush();
3541
3542         // Replace old qconfig.cpp with new one
3543         ::SetFileAttributes((wchar_t*)outName.utf16(), FILE_ATTRIBUTE_NORMAL);
3544         QFile::remove(outName);
3545         tmpFile.copy(outName);
3546         tmpFile.close();
3547     }
3548 }
3549
3550 void Configure::buildQmake()
3551 {
3552     if (dictionary[ "BUILD_QMAKE" ] == "yes") {
3553         QStringList args;
3554
3555         // Build qmake
3556         QString pwd = QDir::currentPath();
3557         if (!QDir(buildPath).mkpath("qmake")) {
3558             cout << "Cannot create qmake build dir." << endl;
3559             dictionary[ "DONE" ] = "error";
3560             return;
3561         }
3562         if (!QDir::setCurrent(buildPath + "/qmake")) {
3563             cout << "Cannot enter qmake build dir." << endl;
3564             dictionary[ "DONE" ] = "error";
3565             return;
3566         }
3567
3568         QString makefile = "Makefile";
3569         {
3570             QFile out(makefile);
3571             if (out.open(QFile::WriteOnly | QFile::Text)) {
3572                 QTextStream stream(&out);
3573                 stream << "#AutoGenerated by configure.exe" << endl
3574                     << "BUILD_PATH = " << QDir::toNativeSeparators(buildPath) << endl
3575                     << "SOURCE_PATH = " << QDir::toNativeSeparators(sourcePath) << endl;
3576                 stream << "QMAKESPEC = " << dictionary["QMAKESPEC"] << endl
3577                        << "QT_VERSION = " << dictionary["VERSION"] << endl;
3578
3579                 if (dictionary["EDITION"] == "OpenSource" ||
3580                     dictionary["QT_EDITION"].contains("OPENSOURCE"))
3581                     stream << "QMAKE_OPENSOURCE_EDITION = yes" << endl;
3582                 stream << "\n\n";
3583
3584                 QFile in(sourcePath + "/qmake/" + dictionary["QMAKEMAKEFILE"]);
3585                 if (in.open(QFile::ReadOnly | QFile::Text)) {
3586                     QString d = in.readAll();
3587                     //### need replaces (like configure.sh)? --Sam
3588                     stream << d << endl;
3589                 }
3590                 stream.flush();
3591                 out.close();
3592             }
3593         }
3594
3595         args += dictionary[ "MAKE" ];
3596         args += "-f";
3597         args += makefile;
3598
3599         cout << "Creating qmake..." << endl;
3600         int exitCode = Environment::execute(args, QStringList(), QStringList());
3601         if (exitCode) {
3602             args.clear();
3603             args += dictionary[ "MAKE" ];
3604             args += "-f";
3605             args += makefile;
3606             args += "clean";
3607             exitCode = Environment::execute(args, QStringList(), QStringList());
3608             if (exitCode) {
3609                 cout << "Cleaning qmake failed, return code " << exitCode << endl << endl;
3610                 dictionary[ "DONE" ] = "error";
3611             } else {
3612                 args.clear();
3613                 args += dictionary[ "MAKE" ];
3614                 args += "-f";
3615                 args += makefile;
3616                 exitCode = Environment::execute(args, QStringList(), QStringList());
3617                 if (exitCode) {
3618                     cout << "Building qmake failed, return code " << exitCode << endl << endl;
3619                     dictionary[ "DONE" ] = "error";
3620                 }
3621             }
3622         }
3623         QDir::setCurrent(pwd);
3624     }
3625
3626     // Generate qt.conf
3627     QFile confFile(buildPath + "/bin/qt.conf");
3628     if (confFile.open(QFile::WriteOnly | QFile::Text)) { // Truncates any existing file.
3629         QTextStream confStream(&confFile);
3630         confStream << "[EffectivePaths]" << endl
3631                    << "Prefix=.." << endl;
3632
3633         confStream.flush();
3634         confFile.close();
3635     }
3636
3637     //create default mkspecs
3638     QString spec = dictionary.contains("XQMAKESPEC") ? dictionary["XQMAKESPEC"] : dictionary["QMAKESPEC"];
3639     if (!copySpec("default", "", spec)
3640         || !copySpec("default-host", "host ", dictionary["QMAKESPEC"])) {
3641         cout << "Error installing default mkspecs" << endl << endl;
3642         exit(EXIT_FAILURE);
3643     }
3644
3645 }
3646 #endif
3647
3648 void Configure::findProjects(const QString& dirName)
3649 {
3650     if (dictionary[ "NOPROCESS" ] == "no") {
3651         QDir dir(dirName);
3652         QString entryName;
3653         int makeListNumber;
3654         ProjectType qmakeTemplate;
3655         const QFileInfoList &list = dir.entryInfoList(QStringList(QLatin1String("*.pro")),
3656                                                       QDir::AllDirs | QDir::Files | QDir::NoDotAndDotDot);
3657         for (int i = 0; i < list.size(); ++i) {
3658             const QFileInfo &fi = list.at(i);
3659             if (fi.fileName() != "qmake.pro") {
3660                 entryName = dirName + "/" + fi.fileName();
3661                 if (fi.isDir()) {
3662                     findProjects(entryName);
3663                 } else {
3664                     qmakeTemplate = projectType(fi.absoluteFilePath());
3665                     switch (qmakeTemplate) {
3666                     case Lib:
3667                     case Subdirs:
3668                         makeListNumber = 1;
3669                         break;
3670                     default:
3671                         makeListNumber = 2;
3672                         break;
3673                     }
3674                     makeList[makeListNumber].append(new MakeItem(sourceDir.relativeFilePath(fi.absolutePath()),
3675                                                     fi.fileName(),
3676                                                     "Makefile",
3677                                                     qmakeTemplate));
3678                 }
3679             }
3680
3681         }
3682     }
3683 }
3684
3685 void Configure::appendMakeItem(int inList, const QString &item)
3686 {
3687     QString dir;
3688     if (item != "src")
3689         dir = "/" + item;
3690     dir.prepend("/src");
3691     makeList[inList].append(new MakeItem(sourcePath + dir,
3692         item + ".pro", buildPath + dir + "/Makefile", Lib));
3693     if (dictionary[ "DSPFILES" ] == "yes") {
3694         makeList[inList].append(new MakeItem(sourcePath + dir,
3695             item + ".pro", buildPath + dir + "/" + item + ".dsp", Lib));
3696     }
3697     if (dictionary[ "VCPFILES" ] == "yes") {
3698         makeList[inList].append(new MakeItem(sourcePath + dir,
3699             item + ".pro", buildPath + dir + "/" + item + ".vcp", Lib));
3700     }
3701     if (dictionary[ "VCPROJFILES" ] == "yes") {
3702         makeList[inList].append(new MakeItem(sourcePath + dir,
3703             item + ".pro", buildPath + dir + "/" + item + ".vcproj", Lib));
3704     }
3705 }
3706
3707 void Configure::generateMakefiles()
3708 {
3709     if (dictionary[ "NOPROCESS" ] == "no") {
3710 #if !defined(EVAL)
3711         cout << "Creating makefiles in src..." << endl;
3712 #endif
3713
3714         QString spec = dictionary.contains("XQMAKESPEC") ? dictionary[ "XQMAKESPEC" ] : dictionary[ "QMAKESPEC" ];
3715         if (spec != "win32-msvc")
3716             dictionary[ "DSPFILES" ] = "no";
3717
3718         if (spec != "win32-msvc.net" && !spec.startsWith("win32-msvc2") && !spec.startsWith(QLatin1String("wince")))
3719             dictionary[ "VCPROJFILES" ] = "no";
3720
3721         int i = 0;
3722         QString pwd = QDir::currentPath();
3723         if (dictionary["FAST"] != "yes") {
3724             QString dirName;
3725             bool generate = true;
3726             bool doDsp = (dictionary["DSPFILES"] == "yes" || dictionary["VCPFILES"] == "yes"
3727                           || dictionary["VCPROJFILES"] == "yes");
3728             while (generate) {
3729                 QString pwd = QDir::currentPath();
3730                 QString dirPath = buildPath + dirName;
3731                 QStringList args;
3732
3733                 args << buildPath + "/bin/qmake";
3734
3735                 if (doDsp) {
3736                     if (dictionary[ "DEPENDENCIES" ] == "no")
3737                         args << "-nodepend";
3738                     args << "-tp" <<  "vc";
3739                     doDsp = false; // DSP files will be done
3740                     printf("Generating Visual Studio project files...\n");
3741                 } else {
3742                     printf("Generating Makefiles...\n");
3743                     generate = false; // Now Makefiles will be done
3744                 }
3745                 args << "-r";
3746                 args << (sourcePath + "/qtbase.pro");
3747                 args << "-o";
3748                 args << buildPath;
3749                 if (!dictionary[ "QMAKEADDITIONALARGS" ].isEmpty())
3750                     args << dictionary[ "QMAKEADDITIONALARGS" ];
3751
3752                 QDir::setCurrent(dirPath);
3753                 if (int exitCode = Environment::execute(args, QStringList(), QStringList())) {
3754                     cout << "Qmake failed, return code " << exitCode  << endl << endl;
3755                     dictionary[ "DONE" ] = "error";
3756                 }
3757             }
3758         } else {
3759             findProjects(sourcePath);
3760             for (i=0; i<3; i++) {
3761                 for (int j=0; j<makeList[i].size(); ++j) {
3762                     MakeItem *it=makeList[i][j];
3763                     if (it->directory == "tools/configure")
3764                         continue; // don't overwrite our own Makefile
3765
3766                     QString dirPath = it->directory + '/';
3767                     QString projectName = it->proFile;
3768                     QString makefileName = buildPath + "/" + dirPath + it->target;
3769
3770                     // For shadowbuilds, we need to create the path first
3771                     QDir buildPathDir(buildPath);
3772                     if (sourcePath != buildPath && !buildPathDir.exists(dirPath))
3773                         buildPathDir.mkpath(dirPath);
3774
3775                     QStringList args;
3776
3777                     args << QDir::toNativeSeparators(buildPath + "/bin/qmake.exe");
3778                     args << sourcePath + "/" + dirPath + projectName;
3779                     args << dictionary[ "QMAKE_ALL_ARGS" ];
3780
3781                     cout << "For " << qPrintable(QDir::toNativeSeparators(dirPath + projectName)) << endl;
3782                     args << "-o";
3783                     args << it->target;
3784                     if (!dictionary[ "QMAKEADDITIONALARGS" ].isEmpty())
3785                         args << dictionary[ "QMAKEADDITIONALARGS" ];
3786
3787                     QDir::setCurrent(dirPath);
3788
3789                     QFile file(makefileName);
3790                     if (!file.open(QFile::WriteOnly | QFile::Text)) {
3791                         printf("failed on dirPath=%s, makefile=%s\n",
3792                                qPrintable(QDir::toNativeSeparators(dirPath)),
3793                                qPrintable(QDir::toNativeSeparators(makefileName)));
3794                         continue;
3795                     }
3796                     QTextStream txt(&file);
3797                     txt << "all:\n";
3798                     txt << "\t" << args.join(" ") << "\n";
3799                     txt << "\t$(MAKE) -$(MAKEFLAGS) -f " << it->target << "\n";
3800                     txt << "first: all\n";
3801                     txt << "qmake: FORCE\n";
3802                     txt << "\t" << args.join(" ") << "\n";
3803                     txt << "FORCE:\n";
3804                 }
3805             }
3806         }
3807         QDir::setCurrent(pwd);
3808     } else {
3809         cout << "Processing of project files have been disabled." << endl;
3810         cout << "Only use this option if you really know what you're doing." << endl << endl;
3811         return;
3812     }
3813 }
3814
3815 void Configure::showSummary()
3816 {
3817     QString make = dictionary[ "MAKE" ];
3818     if (!dictionary.contains("XQMAKESPEC")) {
3819         cout << endl << endl << "Qt is now configured for building. Just run " << qPrintable(make) << "." << endl;
3820         cout << "To reconfigure, run " << qPrintable(make) << " confclean and configure." << endl << endl;
3821     } else if (dictionary.value("QMAKESPEC").startsWith("wince")) {
3822         // we are cross compiling for Windows CE
3823         cout << endl << endl << "Qt is now configured for building. To start the build run:" << endl
3824              << "\tsetcepaths " << dictionary.value("XQMAKESPEC") << endl
3825              << "\t" << qPrintable(make) << endl
3826              << "To reconfigure, run " << qPrintable(make) << " confclean and configure." << endl << endl;
3827     }
3828 }
3829
3830 Configure::ProjectType Configure::projectType(const QString& proFileName)
3831 {
3832     QFile proFile(proFileName);
3833     if (proFile.open(QFile::ReadOnly)) {
3834         QString buffer = proFile.readLine(1024);
3835         while (!buffer.isEmpty()) {
3836             QStringList segments = buffer.split(QRegExp("\\s"));
3837             QStringList::Iterator it = segments.begin();
3838
3839             if (segments.size() >= 3) {
3840                 QString keyword = (*it++);
3841                 QString operation = (*it++);
3842                 QString value = (*it++);
3843
3844                 if (keyword == "TEMPLATE") {
3845                     if (value == "lib")
3846                         return Lib;
3847                     else if (value == "subdirs")
3848                         return Subdirs;
3849                 }
3850             }
3851             // read next line
3852             buffer = proFile.readLine(1024);
3853         }
3854         proFile.close();
3855     }
3856     // Default to app handling
3857     return App;
3858 }
3859
3860 #if !defined(EVAL)
3861
3862 bool Configure::showLicense(QString orgLicenseFile)
3863 {
3864     if (dictionary["LICENSE_CONFIRMED"] == "yes") {
3865         cout << "You have already accepted the terms of the license." << endl << endl;
3866         return true;
3867     }
3868
3869     bool haveGpl3 = false;
3870     QString licenseFile = orgLicenseFile;
3871     QString theLicense;
3872     if (dictionary["EDITION"] == "OpenSource" || dictionary["EDITION"] == "Snapshot") {
3873         haveGpl3 = QFile::exists(orgLicenseFile + "/LICENSE.GPL3");
3874         theLicense = "GNU Lesser General Public License (LGPL) version 2.1";
3875         if (haveGpl3)
3876             theLicense += "\nor the GNU General Public License (GPL) version 3";
3877     } else {
3878         // the first line of the license file tells us which license it is
3879         QFile file(licenseFile);
3880         if (!file.open(QFile::ReadOnly)) {
3881             cout << "Failed to load LICENSE file" << endl;
3882             return false;
3883         }
3884         theLicense = file.readLine().trimmed();
3885     }
3886
3887     forever {
3888         char accept = '?';
3889         cout << "You are licensed to use this software under the terms of" << endl
3890              << "the " << theLicense << "." << endl
3891              << endl;
3892         if (dictionary["EDITION"] == "OpenSource" || dictionary["EDITION"] == "Snapshot") {
3893             if (haveGpl3)
3894                 cout << "Type '3' to view the GNU General Public License version 3 (GPLv3)." << endl;
3895             cout << "Type 'L' to view the Lesser GNU General Public License version 2.1 (LGPLv2.1)." << endl;
3896         } else {
3897             cout << "Type '?' to view the " << theLicense << "." << endl;
3898         }
3899         cout << "Type 'y' to accept this license offer." << endl
3900              << "Type 'n' to decline this license offer." << endl
3901              << endl
3902              << "Do you accept the terms of the license?" << endl;
3903         cin >> accept;
3904         accept = tolower(accept);
3905
3906         if (accept == 'y') {
3907             return true;
3908         } else if (accept == 'n') {
3909             return false;
3910         } else {
3911             if (dictionary["EDITION"] == "OpenSource" || dictionary["EDITION"] == "Snapshot") {
3912                 if (accept == '3')
3913                     licenseFile = orgLicenseFile + "/LICENSE.GPL3";
3914                 else
3915                     licenseFile = orgLicenseFile + "/LICENSE.LGPL";
3916             }
3917             // Get console line height, to fill the screen properly
3918             int i = 0, screenHeight = 25; // default
3919             CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
3920             HANDLE stdOut = GetStdHandle(STD_OUTPUT_HANDLE);
3921             if (GetConsoleScreenBufferInfo(stdOut, &consoleInfo))
3922                 screenHeight = consoleInfo.srWindow.Bottom
3923                              - consoleInfo.srWindow.Top
3924                              - 1; // Some overlap for context
3925
3926             // Prompt the license content to the user
3927             QFile file(licenseFile);
3928             if (!file.open(QFile::ReadOnly)) {
3929                 cout << "Failed to load LICENSE file" << licenseFile << endl;
3930                 return false;
3931             }
3932             QStringList licenseContent = QString(file.readAll()).split('\n');
3933             while (i < licenseContent.size()) {
3934                 cout << licenseContent.at(i) << endl;
3935                 if (++i % screenHeight == 0) {
3936                     cout << "(Press any key for more..)";
3937                     if (_getch() == 3) // _Any_ keypress w/no echo(eat <Enter> for stdout)
3938                         exit(0);      // Exit cleanly for Ctrl+C
3939                     cout << "\r";     // Overwrite text above
3940                 }
3941             }
3942         }
3943     }
3944 }
3945
3946 void Configure::readLicense()
3947 {
3948     dictionary["PLATFORM NAME"] = platformName();
3949     dictionary["LICENSE FILE"] = sourcePath;
3950
3951     bool openSource = false;
3952     bool hasOpenSource = QFile::exists(dictionary["LICENSE FILE"] + "/LICENSE.GPL3") || QFile::exists(dictionary["LICENSE FILE"] + "/LICENSE.LGPL");
3953     if (dictionary["BUILDTYPE"] == "commercial") {
3954         openSource = false;
3955     } else if (dictionary["BUILDTYPE"] == "opensource") {
3956         openSource = true;
3957     } else if (hasOpenSource) { // No Open Source? Just display the commercial license right away
3958         forever {
3959             char accept = '?';
3960             cout << "Which edition of Qt do you want to use ?" << endl;
3961             cout << "Type 'c' if you want to use the Commercial Edition." << endl;
3962             cout << "Type 'o' if you want to use the Open Source Edition." << endl;
3963             cin >> accept;
3964             accept = tolower(accept);
3965
3966             if (accept == 'c') {
3967                 openSource = false;
3968                 break;
3969             } else if (accept == 'o') {
3970                 openSource = true;
3971                 break;
3972             }
3973         }
3974     }
3975     if (hasOpenSource && openSource) {
3976         cout << endl << "This is the " << dictionary["PLATFORM NAME"] << " Open Source Edition." << endl;
3977         licenseInfo["LICENSEE"] = "Open Source";
3978         dictionary["EDITION"] = "OpenSource";
3979         dictionary["QT_EDITION"] = "QT_EDITION_OPENSOURCE";
3980         cout << endl;
3981         if (!showLicense(dictionary["LICENSE FILE"])) {
3982             cout << "Configuration aborted since license was not accepted";
3983             dictionary["DONE"] = "error";
3984             return;
3985         }
3986     } else if (openSource) {
3987         cout << endl << "Cannot find the GPL license files! Please download the Open Source version of the library." << endl;
3988         dictionary["DONE"] = "error";
3989     }
3990 #ifdef COMMERCIAL_VERSION
3991     else {
3992         Tools::checkLicense(dictionary, licenseInfo, firstLicensePath());
3993         if (dictionary["DONE"] != "error") {
3994             // give the user some feedback, and prompt for license acceptance
3995             cout << endl << "This is the " << dictionary["PLATFORM NAME"] << " " << dictionary["EDITION"] << " Edition."<< endl << endl;
3996             if (!showLicense(dictionary["LICENSE FILE"])) {
3997                 cout << "Configuration aborted since license was not accepted";
3998                 dictionary["DONE"] = "error";
3999                 return;
4000             }
4001         }
4002     }
4003 #else // !COMMERCIAL_VERSION
4004     else {
4005         cout << endl << "Cannot build commercial edition from the open source version of the library." << endl;
4006         dictionary["DONE"] = "error";
4007     }
4008 #endif
4009 }
4010
4011 void Configure::reloadCmdLine()
4012 {
4013     if (dictionary[ "REDO" ] == "yes") {
4014         QFile inFile(buildPath + "/configure" + dictionary[ "CUSTOMCONFIG" ] + ".cache");
4015         if (inFile.open(QFile::ReadOnly)) {
4016             QTextStream inStream(&inFile);
4017             QString buffer;
4018             inStream >> buffer;
4019             while (buffer.length()) {
4020                 configCmdLine += buffer;
4021                 inStream >> buffer;
4022             }
4023             inFile.close();
4024         }
4025     }
4026 }
4027
4028 void Configure::saveCmdLine()
4029 {
4030     if (dictionary[ "REDO" ] != "yes") {
4031         QFile outFile(buildPath + "/configure" + dictionary[ "CUSTOMCONFIG" ] + ".cache");
4032         if (outFile.open(QFile::WriteOnly | QFile::Text)) {
4033             QTextStream outStream(&outFile);
4034             for (QStringList::Iterator it = configCmdLine.begin(); it != configCmdLine.end(); ++it) {
4035                 outStream << (*it) << " " << endl;
4036             }
4037             outStream.flush();
4038             outFile.close();
4039         }
4040     }
4041 }
4042 #endif // !EVAL
4043
4044 bool Configure::isDone()
4045 {
4046     return !dictionary["DONE"].isEmpty();
4047 }
4048
4049 bool Configure::isOk()
4050 {
4051     return (dictionary[ "DONE" ] != "error");
4052 }
4053
4054 QString Configure::platformName() const
4055 {
4056     switch (platform()) {
4057     default:
4058     case WINDOWS:
4059         return QStringLiteral("Qt for Windows");
4060     case WINDOWS_CE:
4061         return QStringLiteral("Qt for Windows CE");
4062     case QNX:
4063         return QStringLiteral("Qt for QNX");
4064     case BLACKBERRY:
4065         return QStringLiteral("Qt for Blackberry");
4066     }
4067 }
4068
4069 QString Configure::qpaPlatformName() const
4070 {
4071     switch (platform()) {
4072     default:
4073     case WINDOWS:
4074     case WINDOWS_CE:
4075         return QStringLiteral("windows");
4076     case QNX:
4077         return QStringLiteral("qnx");
4078     case BLACKBERRY:
4079         return QStringLiteral("blackberry");
4080     }
4081 }
4082
4083 int Configure::platform() const
4084 {
4085     const QString qMakeSpec = dictionary.value("QMAKESPEC");
4086     const QString xQMakeSpec = dictionary.value("XQMAKESPEC");
4087
4088     if ((qMakeSpec.startsWith("wince") || xQMakeSpec.startsWith("wince")))
4089         return WINDOWS_CE;
4090
4091     if (xQMakeSpec.contains("qnx"))
4092         return QNX;
4093
4094     if (xQMakeSpec.contains("blackberry"))
4095         return BLACKBERRY;
4096
4097     return WINDOWS;
4098 }
4099
4100 bool
4101 Configure::filesDiffer(const QString &fn1, const QString &fn2)
4102 {
4103     QFile file1(fn1), file2(fn2);
4104     if (!file1.open(QFile::ReadOnly) || !file2.open(QFile::ReadOnly))
4105         return true;
4106     const int chunk = 2048;
4107     int used1 = 0, used2 = 0;
4108     char b1[chunk], b2[chunk];
4109     while (!file1.atEnd() && !file2.atEnd()) {
4110         if (!used1)
4111             used1 = file1.read(b1, chunk);
4112         if (!used2)
4113             used2 = file2.read(b2, chunk);
4114         if (used1 > 0 && used2 > 0) {
4115             const int cmp = qMin(used1, used2);
4116             if (memcmp(b1, b2, cmp))
4117                 return true;
4118             if ((used1 -= cmp))
4119                 memcpy(b1, b1+cmp, used1);
4120             if ((used2 -= cmp))
4121                 memcpy(b2, b2+cmp, used2);
4122         }
4123     }
4124     return !file1.atEnd() || !file2.atEnd();
4125 }
4126
4127 QT_END_NAMESPACE