summaryrefslogtreecommitdiffstats
path: root/tools/configure
diff options
context:
space:
mode:
authorLars Knoll <lars.knoll@nokia.com>2009-03-23 09:18:55 (GMT)
committerSimon Hausmann <simon.hausmann@nokia.com>2009-03-23 09:18:55 (GMT)
commite5fcad302d86d316390c6b0f62759a067313e8a9 (patch)
treec2afbf6f1066b6ce261f14341cf6d310e5595bc1 /tools/configure
downloadQt-e5fcad302d86d316390c6b0f62759a067313e8a9.zip
Qt-e5fcad302d86d316390c6b0f62759a067313e8a9.tar.gz
Qt-e5fcad302d86d316390c6b0f62759a067313e8a9.tar.bz2
Long live Qt 4.5!
Diffstat (limited to 'tools/configure')
-rw-r--r--tools/configure/configure.pro106
-rw-r--r--tools/configure/configure_pch.h74
-rw-r--r--tools/configure/configureapp.cpp3586
-rw-r--r--tools/configure/configureapp.h185
-rw-r--r--tools/configure/environment.cpp686
-rw-r--r--tools/configure/environment.h84
-rw-r--r--tools/configure/main.cpp114
-rw-r--r--tools/configure/tools.cpp172
-rw-r--r--tools/configure/tools.h17
9 files changed, 5024 insertions, 0 deletions
diff --git a/tools/configure/configure.pro b/tools/configure/configure.pro
new file mode 100644
index 0000000..1ce9a1b
--- /dev/null
+++ b/tools/configure/configure.pro
@@ -0,0 +1,106 @@
+TARGET = configure
+DESTDIR = ../..
+
+CONFIG += console flat
+CONFIG -= moc qt
+DEFINES = QT_NODLL QT_NO_CODECS QT_NO_TEXTCODEC QT_NO_UNICODETABLES QT_LITE_COMPONENT QT_NO_STL QT_NO_COMPRESS QT_BUILD_QMAKE QT_NO_THREAD QT_NO_QOBJECT _CRT_SECURE_NO_DEPRECATE
+
+
+win32 : LIBS += -lole32 -ladvapi32
+win32-msvc.net | win32-msvc2* : QMAKE_CXXFLAGS += /EHsc
+win32-g++ : LIBS += -luuid
+
+win32-msvc* {
+ QMAKE_CFLAGS_RELEASE -= -MD
+ QMAKE_CFLAGS_DEBUG -= -MDd
+ QMAKE_CXXFLAGS_RELEASE -= -MD
+ QMAKE_CXXFLAGS_DEBUG -= -MDd
+}
+
+PRECOMPILED_HEADER = configure_pch.h
+
+INCPATH += $$QT_SOURCE_TREE/src/corelib/arch/generic \
+ $$QT_SOURCE_TREE/src/corelib/global \
+ $$QT_BUILD_TREE/include \
+ $$QT_BUILD_TREE/include/QtCore \
+
+HEADERS = configureapp.h environment.h tools.h\
+ $$QT_SOURCE_TREE/src/corelib/tools/qbytearray.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qbytearraymatcher.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qchar.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qhash.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qlist.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qlocale.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qvector.h \
+ $$QT_SOURCE_TREE/src/corelib/codecs/qtextcodec.h \
+ $$QT_SOURCE_TREE/src/corelib/global/qglobal.h \
+ $$QT_SOURCE_TREE/src/corelib/global/qnumeric.h \
+ $$QT_SOURCE_TREE/src/corelib/io/qbuffer.h \
+ $$QT_SOURCE_TREE/src/corelib/io/qdatastream.h \
+ $$QT_SOURCE_TREE/src/corelib/io/qdir.h \
+ $$QT_SOURCE_TREE/src/corelib/io/qdiriterator.h \
+ $$QT_SOURCE_TREE/src/corelib/io/qfile.h \
+ $$QT_SOURCE_TREE/src/corelib/io/qfileinfo.h \
+ $$QT_SOURCE_TREE/src/corelib/io/qfsfileengine.h \
+ $$QT_SOURCE_TREE/src/corelib/io/qfsfileengine_iterator_p.h \
+ $$QT_SOURCE_TREE/src/corelib/io/qiodevice.h \
+ $$QT_SOURCE_TREE/src/corelib/io/qtextstream.h \
+ $$QT_SOURCE_TREE/src/corelib/io/qtemporaryfile.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qbitarray.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qdatetime.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qmap.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qregexp.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qstring.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qstringlist.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qstringmatcher.h \
+ $$QT_SOURCE_TREE/src/corelib/tools/qunicodetables_p.h
+
+
+SOURCES = main.cpp configureapp.cpp environment.cpp tools.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qbytearray.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qbytearraymatcher.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qchar.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qhash.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qlistdata.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qlocale.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qvector.cpp \
+ $$QT_SOURCE_TREE/src/corelib/codecs/qtextcodec.cpp \
+ $$QT_SOURCE_TREE/src/corelib/global/qglobal.cpp \
+ $$QT_SOURCE_TREE/src/corelib/global/qnumeric.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qbuffer.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qdatastream.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qdir.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qdiriterator.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qfile.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qfileinfo.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qabstractfileengine.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qfsfileengine.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qfsfileengine_iterator.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qfsfileengine_iterator_win.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qiodevice.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qtextstream.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qtemporaryfile.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qbitarray.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qdatetime.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qmap.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qregexp.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qstring.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qstringlist.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qstringmatcher.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qunicodetables.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qvsnprintf.cpp \
+ $$QT_SOURCE_TREE/src/corelib/kernel/qvariant.cpp \
+ $$QT_SOURCE_TREE/src/corelib/io/qurl.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qline.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qsize.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qpoint.cpp \
+ $$QT_SOURCE_TREE/src/corelib/tools/qrect.cpp \
+ $$QT_SOURCE_TREE/src/corelib/kernel/qmetatype.cpp \
+ $$QT_SOURCE_TREE/src/corelib/global/qmalloc.cpp
+
+win32:SOURCES += $$QT_SOURCE_TREE/src/corelib/io/qfsfileengine_win.cpp
+
+DEFINES += COMMERCIAL_VERSION
+
+INCLUDEPATH += $$QT_SOURCE_TREE/src/corelib/arch/generic \
+ $$QT_SOURCE_TREE/include/QtCore \
diff --git a/tools/configure/configure_pch.h b/tools/configure/configure_pch.h
new file mode 100644
index 0000000..24eac4f
--- /dev/null
+++ b/tools/configure/configure_pch.h
@@ -0,0 +1,74 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#if (defined(_WIN32) || defined(__NT__))
+# define QT_UNDEF_MACROS_IN_PCH
+# define _WINSCARD_H_
+# define _POSIX_ /* Make sure PATH_MAX et al. are defined */
+# include <limits.h>
+# undef _POSIX_ /* Don't polute */
+
+ /* Make sure IP v6 is defined first of all, before windows.h */
+# ifndef QT_NO_IPV6
+# include <winsock2.h>
+# endif
+# include <stdlib.h>
+#endif
+
+#if defined __cplusplus
+#include <qglobal.h>
+#include <qlist.h>
+#include <qvariant.h> // All moc genereated code has this include
+#include <qplatformdefs.h>
+#include <qregexp.h>
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qtextcodec.h>
+
+#include <limits.h>
+#include <stdlib.h>
+#endif
+
+#if defined(QT_UNDEF_MACROS_IN_PCH)
+# undef max /* These are defined in windef.h, but */
+# undef min /* we don't want them when building Qt */
+# undef _WINSCARD_H_
+#endif
diff --git a/tools/configure/configureapp.cpp b/tools/configure/configureapp.cpp
new file mode 100644
index 0000000..8c0dc39
--- /dev/null
+++ b/tools/configure/configureapp.cpp
@@ -0,0 +1,3586 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "configureapp.h"
+#include "environment.h"
+#ifdef COMMERCIAL_VERSION
+# include "tools.h"
+#endif
+
+#include <QDate>
+#include <qdir.h>
+#include <qtemporaryfile.h>
+#include <qstack.h>
+#include <qdebug.h>
+#include <qfileinfo.h>
+#include <qtextstream.h>
+#include <qregexp.h>
+#include <qhash.h>
+
+#include <iostream>
+#include <windows.h>
+#include <conio.h>
+
+QT_BEGIN_NAMESPACE
+
+std::ostream &operator<<( std::ostream &s, const QString &val ) {
+ s << val.toLocal8Bit().data();
+ return s;
+}
+
+
+using namespace std;
+
+// Macros to simplify options marking
+#define MARK_OPTION(x,y) ( dictionary[ #x ] == #y ? "*" : " " )
+
+
+bool writeToFile(const char* text, const QString &filename)
+{
+ QByteArray symFile(text);
+ QFile file(filename);
+ QDir dir(QFileInfo(file).absoluteDir());
+ if (!dir.exists())
+ dir.mkpath(dir.absolutePath());
+ if (!file.open(QFile::WriteOnly)) {
+ cout << "Couldn't write to " << qPrintable(filename) << ": " << qPrintable(file.errorString())
+ << endl;
+ return false;
+ }
+ file.write(symFile);
+ return true;
+}
+
+Configure::Configure( int& argc, char** argv )
+{
+ useUnixSeparators = false;
+ // Default values for indentation
+ optionIndent = 4;
+ descIndent = 25;
+ outputWidth = 0;
+ // Get console buffer output width
+ CONSOLE_SCREEN_BUFFER_INFO info;
+ HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
+ if (GetConsoleScreenBufferInfo(hStdout, &info))
+ outputWidth = info.dwSize.X - 1;
+ outputWidth = qMin(outputWidth, 79); // Anything wider gets unreadable
+ if (outputWidth < 35) // Insanely small, just use 79
+ outputWidth = 79;
+ int i;
+
+ /*
+ ** Set up the initial state, the default
+ */
+ dictionary[ "CONFIGCMD" ] = argv[ 0 ];
+
+ for ( i = 1; i < argc; i++ )
+ configCmdLine += argv[ i ];
+
+
+ // Get the path to the executable
+ QFileInfo sourcePathInfo;
+ QT_WA({
+ unsigned short module_name[256];
+ GetModuleFileNameW(0, reinterpret_cast<wchar_t *>(module_name), sizeof(module_name));
+ sourcePathInfo = QString::fromUtf16(module_name);
+ }, {
+ char module_name[256];
+ GetModuleFileNameA(0, module_name, sizeof(module_name));
+ sourcePathInfo = QString::fromLocal8Bit(module_name);
+ });
+ sourcePath = sourcePathInfo.absolutePath();
+ sourceDir = sourcePathInfo.dir();
+ buildPath = QDir::currentPath();
+#if 0
+ const QString installPath = QString("C:\\Qt\\%1").arg(QT_VERSION_STR);
+#else
+ const QString installPath = buildPath;
+#endif
+ if(sourceDir != buildDir) { //shadow builds!
+ if (!findFile("perl") && !findFile("perl.exe")) {
+ cout << "Error: Creating a shadow build of Qt requires" << endl
+ << "perl to be in the PATH environment";
+ exit(0); // Exit cleanly for Ctrl+C
+ }
+
+ cout << "Preparing build tree..." << endl;
+ QDir(buildPath).mkpath("bin");
+
+ { //duplicate qmake
+ QStack<QString> qmake_dirs;
+ qmake_dirs.push("qmake");
+ while(!qmake_dirs.isEmpty()) {
+ QString dir = qmake_dirs.pop();
+ QString od(buildPath + "/" + dir);
+ QString id(sourcePath + "/" + dir);
+ QFileInfoList entries = QDir(id).entryInfoList(QDir::NoDotAndDotDot|QDir::AllEntries);
+ for(int i = 0; i < entries.size(); ++i) {
+ QFileInfo fi(entries.at(i));
+ if(fi.isDir()) {
+ qmake_dirs.push(dir + "/" + fi.fileName());
+ QDir().mkpath(od + "/" + fi.fileName());
+ } else {
+ QDir().mkpath(od );
+ bool justCopy = true;
+ const QString fname = fi.fileName();
+ const QString outFile(od + "/" + fname), inFile(id + "/" + fname);
+ if(fi.fileName() == "Makefile") { //ignore
+ } else if(fi.suffix() == "h" || fi.suffix() == "cpp") {
+ QTemporaryFile tmpFile;
+ if(tmpFile.open()) {
+ QTextStream stream(&tmpFile);
+ stream << "#include \"" << inFile << "\"" << endl;
+ justCopy = false;
+ stream.flush();
+ tmpFile.flush();
+ if(filesDiffer(tmpFile.fileName(), outFile)) {
+ QFile::remove(outFile);
+ tmpFile.copy(outFile);
+ }
+ }
+ }
+ if(justCopy && filesDiffer(inFile, outFile))
+ QFile::copy(inFile, outFile);
+ }
+ }
+ }
+ }
+
+ { //make a syncqt script(s) that can be used in the shadow
+ QFile syncqt(buildPath + "/bin/syncqt");
+ if(syncqt.open(QFile::WriteOnly)) {
+ QTextStream stream(&syncqt);
+ stream << "#!/usr/bin/perl -w" << endl
+ << "require \"" << sourcePath + "/bin/syncqt\";" << endl;
+ }
+ QFile syncqt_bat(buildPath + "/bin/syncqt.bat");
+ if(syncqt_bat.open(QFile::WriteOnly)) {
+ QTextStream stream(&syncqt_bat);
+ stream << "@echo off" << endl
+ << "set QTDIR=" << QDir::toNativeSeparators(sourcePath) << endl
+ << "call " << fixSeparators(sourcePath) << fixSeparators("/bin/syncqt.bat -outdir \"") << fixSeparators(buildPath) << "\"" << endl
+ << "set QTDIR=" << QDir::toNativeSeparators(buildPath) << endl;
+ syncqt_bat.close();
+ }
+ }
+
+ // For Windows CE and shadow builds we need to copy these to the
+ // build directory.
+ QFile::copy(sourcePath + "/bin/setcepaths.bat" , buildPath + "/bin/setcepaths.bat");
+
+ //copy the mkspecs
+ buildDir.mkpath("mkspecs");
+ if(!Environment::cpdir(sourcePath + "/mkspecs", buildPath + "/mkspecs")){
+ cout << "Couldn't copy mkspecs!" << sourcePath << " " << buildPath << endl;
+ dictionary["DONE"] = "error";
+ return;
+ }
+ }
+
+ dictionary[ "QT_SOURCE_TREE" ] = fixSeparators(sourcePath);
+ dictionary[ "QT_BUILD_TREE" ] = fixSeparators(buildPath);
+ dictionary[ "QT_INSTALL_PREFIX" ] = fixSeparators(installPath);
+
+ dictionary[ "QMAKESPEC" ] = getenv("QMAKESPEC");
+ if (dictionary[ "QMAKESPEC" ].size() == 0) {
+ dictionary[ "QMAKESPEC" ] = Environment::detectQMakeSpec();
+ dictionary[ "QMAKESPEC_FROM" ] = "detected";
+ } else {
+ dictionary[ "QMAKESPEC_FROM" ] = "env";
+ }
+
+ dictionary[ "ARCHITECTURE" ] = "windows";
+ dictionary[ "QCONFIG" ] = "full";
+ dictionary[ "EMBEDDED" ] = "no";
+ dictionary[ "BUILD_QMAKE" ] = "yes";
+ dictionary[ "DSPFILES" ] = "yes";
+ dictionary[ "VCPROJFILES" ] = "yes";
+ dictionary[ "QMAKE_INTERNAL" ] = "no";
+ dictionary[ "FAST" ] = "no";
+ dictionary[ "NOPROCESS" ] = "no";
+ dictionary[ "STL" ] = "yes";
+ dictionary[ "EXCEPTIONS" ] = "yes";
+ dictionary[ "RTTI" ] = "yes";
+ dictionary[ "MMX" ] = "auto";
+ dictionary[ "3DNOW" ] = "auto";
+ dictionary[ "SSE" ] = "auto";
+ dictionary[ "SSE2" ] = "auto";
+ dictionary[ "IWMMXT" ] = "auto";
+ dictionary[ "SYNCQT" ] = "auto";
+ dictionary[ "CE_CRT" ] = "no";
+ dictionary[ "CETEST" ] = "auto";
+ dictionary[ "CE_SIGNATURE" ] = "no";
+ dictionary[ "SCRIPTTOOLS" ] = "yes";
+ dictionary[ "XMLPATTERNS" ] = "auto";
+ dictionary[ "PHONON" ] = "auto";
+ dictionary[ "PHONON_BACKEND" ] = "yes";
+ dictionary[ "DIRECTSHOW" ] = "no";
+ dictionary[ "WEBKIT" ] = "auto";
+ dictionary[ "PLUGIN_MANIFESTS" ] = "yes";
+
+ QString version;
+ QFile qglobal_h(sourcePath + "/src/corelib/global/qglobal.h");
+ if (qglobal_h.open(QFile::ReadOnly)) {
+ QTextStream read(&qglobal_h);
+ QRegExp version_regexp("^# *define *QT_VERSION_STR *\"([^\"]*)\"");
+ QString line;
+ while (!read.atEnd()) {
+ line = read.readLine();
+ if (version_regexp.exactMatch(line)) {
+ version = version_regexp.cap(1).trimmed();
+ if (!version.isEmpty())
+ break;
+ }
+ }
+ qglobal_h.close();
+ }
+
+ if (version.isEmpty())
+ version = QString("%1.%2.%3").arg(QT_VERSION>>16).arg(((QT_VERSION>>8)&0xff)).arg(QT_VERSION&0xff);
+
+ dictionary[ "VERSION" ] = version;
+ {
+ QRegExp version_re("([0-9]*)\\.([0-9]*)\\.([0-9]*)(|-.*)");
+ if(version_re.exactMatch(version)) {
+ dictionary[ "VERSION_MAJOR" ] = version_re.cap(1);
+ dictionary[ "VERSION_MINOR" ] = version_re.cap(2);
+ dictionary[ "VERSION_PATCH" ] = version_re.cap(3);
+ }
+ }
+
+ dictionary[ "REDO" ] = "no";
+ dictionary[ "DEPENDENCIES" ] = "no";
+
+ dictionary[ "BUILD" ] = "debug";
+ dictionary[ "BUILDALL" ] = "auto"; // Means yes, but not explicitly
+
+ dictionary[ "BUILDTYPE" ] = "none";
+
+ dictionary[ "BUILDDEV" ] = "no";
+ dictionary[ "BUILDNOKIA" ] = "no";
+
+ dictionary[ "SHARED" ] = "yes";
+
+ dictionary[ "ZLIB" ] = "auto";
+
+ dictionary[ "GIF" ] = "auto";
+ dictionary[ "TIFF" ] = "auto";
+ dictionary[ "JPEG" ] = "auto";
+ dictionary[ "PNG" ] = "auto";
+ dictionary[ "MNG" ] = "auto";
+ dictionary[ "LIBTIFF" ] = "auto";
+ dictionary[ "LIBJPEG" ] = "auto";
+ dictionary[ "LIBPNG" ] = "auto";
+ dictionary[ "LIBMNG" ] = "auto";
+
+ dictionary[ "QT3SUPPORT" ] = "yes";
+ dictionary[ "ACCESSIBILITY" ] = "yes";
+ dictionary[ "OPENGL" ] = "yes";
+ dictionary[ "DIRECT3D" ] = "auto";
+ dictionary[ "IPV6" ] = "yes"; // Always, dynamicly loaded
+ dictionary[ "OPENSSL" ] = "auto";
+ dictionary[ "DBUS" ] = "auto";
+
+ dictionary[ "STYLE_WINDOWS" ] = "yes";
+ dictionary[ "STYLE_WINDOWSXP" ] = "auto";
+ dictionary[ "STYLE_WINDOWSVISTA" ] = "auto";
+ dictionary[ "STYLE_PLASTIQUE" ] = "yes";
+ dictionary[ "STYLE_CLEANLOOKS" ]= "yes";
+ dictionary[ "STYLE_WINDOWSCE" ] = "no";
+ dictionary[ "STYLE_WINDOWSMOBILE" ] = "no";
+ dictionary[ "STYLE_MOTIF" ] = "yes";
+ dictionary[ "STYLE_CDE" ] = "yes";
+ dictionary[ "STYLE_GTK" ] = "no";
+
+ dictionary[ "SQL_MYSQL" ] = "no";
+ dictionary[ "SQL_ODBC" ] = "no";
+ dictionary[ "SQL_OCI" ] = "no";
+ dictionary[ "SQL_PSQL" ] = "no";
+ dictionary[ "SQL_TDS" ] = "no";
+ dictionary[ "SQL_DB2" ] = "no";
+ dictionary[ "SQL_SQLITE" ] = "auto";
+ dictionary[ "SQL_SQLITE_LIB" ] = "qt";
+ dictionary[ "SQL_SQLITE2" ] = "no";
+ dictionary[ "SQL_IBASE" ] = "no";
+ dictionary[ "GRAPHICS_SYSTEM" ] = "raster";
+
+ QString tmp = dictionary[ "QMAKESPEC" ];
+ if (tmp.contains("\\")) {
+ tmp = tmp.mid( tmp.lastIndexOf( "\\" ) + 1 );
+ } else {
+ tmp = tmp.mid( tmp.lastIndexOf("/") + 1 );
+ }
+ dictionary[ "QMAKESPEC" ] = tmp;
+
+ dictionary[ "INCREDIBUILD_XGE" ] = "auto";
+}
+
+Configure::~Configure()
+{
+ for (int i=0; i<3; ++i) {
+ QList<MakeItem*> items = makeList[i];
+ for (int j=0; j<items.size(); ++j)
+ delete items[j];
+ }
+}
+
+QString Configure::fixSeparators(QString somePath)
+{
+ return useUnixSeparators ?
+ QDir::fromNativeSeparators(somePath) :
+ QDir::toNativeSeparators(somePath);
+}
+
+// We could use QDir::homePath() + "/.qt-license", but
+// that will only look in the first of $HOME,$USERPROFILE
+// or $HOMEDRIVE$HOMEPATH. So, here we try'em all to be
+// more forgiving for the end user..
+QString Configure::firstLicensePath()
+{
+ QStringList allPaths;
+ allPaths << "./.qt-license"
+ << QString::fromLocal8Bit(getenv("HOME")) + "/.qt-license"
+ << QString::fromLocal8Bit(getenv("USERPROFILE")) + "/.qt-license"
+ << QString::fromLocal8Bit(getenv("HOMEDRIVE")) + QString::fromLocal8Bit(getenv("HOMEPATH")) + "/.qt-license";
+ for (int i = 0; i< allPaths.count(); ++i)
+ if (QFile::exists(allPaths.at(i)))
+ return allPaths.at(i);
+ return QString();
+}
+
+
+// #### somehow I get a compiler error about vc++ reaching the nesting limit without
+// undefining the ansi for scoping.
+#ifdef for
+#undef for
+#endif
+
+void Configure::parseCmdLine()
+{
+ int argCount = configCmdLine.size();
+ int i = 0;
+
+#if !defined(EVAL)
+ if (argCount < 1) // skip rest if no arguments
+ ;
+ else if( configCmdLine.at(i) == "-redo" ) {
+ dictionary[ "REDO" ] = "yes";
+ configCmdLine.clear();
+ reloadCmdLine();
+ }
+ else if( configCmdLine.at(i) == "-loadconfig" ) {
+ ++i;
+ if (i != argCount) {
+ dictionary[ "REDO" ] = "yes";
+ dictionary[ "CUSTOMCONFIG" ] = "_" + configCmdLine.at(i);
+ configCmdLine.clear();
+ reloadCmdLine();
+ } else {
+ dictionary[ "HELP" ] = "yes";
+ }
+ i = 0;
+ }
+ argCount = configCmdLine.size();
+#endif
+
+ // Look first for XQMAKESPEC
+ for(int j = 0 ; j < argCount; ++j)
+ {
+ if( configCmdLine.at(j) == "-xplatform") {
+ ++j;
+ if (j == argCount)
+ break;
+ dictionary["XQMAKESPEC"] = configCmdLine.at(j);
+ if (!dictionary[ "XQMAKESPEC" ].isEmpty())
+ applySpecSpecifics();
+ }
+ }
+
+ for( ; i<configCmdLine.size(); ++i ) {
+ bool continueElse = false;
+ if( configCmdLine.at(i) == "-help"
+ || configCmdLine.at(i) == "-h"
+ || configCmdLine.at(i) == "-?" )
+ dictionary[ "HELP" ] = "yes";
+
+#if !defined(EVAL)
+ else if( configCmdLine.at(i) == "-qconfig" ) {
+ ++i;
+ if (i==argCount)
+ break;
+ dictionary[ "QCONFIG" ] = configCmdLine.at(i);
+ }
+
+ else if ( configCmdLine.at(i) == "-buildkey" ) {
+ ++i;
+ if (i==argCount)
+ break;
+ dictionary[ "USER_BUILD_KEY" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-release" ) {
+ dictionary[ "BUILD" ] = "release";
+ if (dictionary[ "BUILDALL" ] == "auto")
+ dictionary[ "BUILDALL" ] = "no";
+ } else if( configCmdLine.at(i) == "-debug" ) {
+ dictionary[ "BUILD" ] = "debug";
+ if (dictionary[ "BUILDALL" ] == "auto")
+ dictionary[ "BUILDALL" ] = "no";
+ } else if( configCmdLine.at(i) == "-debug-and-release" )
+ dictionary[ "BUILDALL" ] = "yes";
+
+ else if( configCmdLine.at(i) == "-shared" )
+ dictionary[ "SHARED" ] = "yes";
+ else if( configCmdLine.at(i) == "-static" )
+ dictionary[ "SHARED" ] = "no";
+ else if( configCmdLine.at(i) == "-developer-build" )
+ dictionary[ "BUILDDEV" ] = "yes";
+ else if( configCmdLine.at(i) == "-nokia-developer" ) {
+ dictionary[ "BUILDNOKIA" ] = "yes";
+ dictionary[ "BUILDDEV" ] = "yes";
+ dictionary["LICENSE_CONFIRMED"] = "yes";
+ }
+ else if( configCmdLine.at(i) == "-opensource" ) {
+ dictionary[ "BUILDTYPE" ] = "opensource";
+ }
+ else if( configCmdLine.at(i) == "-commercial" ) {
+ dictionary[ "BUILDTYPE" ] = "commercial";
+ }
+#endif
+
+ else if( configCmdLine.at(i) == "-platform" ) {
+ ++i;
+ if (i==argCount)
+ break;
+ dictionary[ "QMAKESPEC" ] = configCmdLine.at(i);
+ dictionary[ "QMAKESPEC_FROM" ] = "commandline";
+ } else if( configCmdLine.at(i) == "-arch" ) {
+ ++i;
+ if (i==argCount)
+ break;
+ dictionary[ "ARCHITECTURE" ] = configCmdLine.at(i);
+ if (configCmdLine.at(i) == "boundschecker") {
+ dictionary[ "ARCHITECTURE" ] = "generic"; // Boundschecker uses the generic arch,
+ qtConfig += "boundschecker"; // but also needs this CONFIG option
+ }
+ } else if( configCmdLine.at(i) == "-embedded" ) {
+ dictionary[ "EMBEDDED" ] = "yes";
+ } else if( configCmdLine.at(i) == "-xplatform") {
+ ++i;
+ // do nothing
+ }
+
+
+#if !defined(EVAL)
+ else if( configCmdLine.at(i) == "-no-zlib" ) {
+ // No longer supported since Qt 4.4.0
+ // But save the information for later so that we can print a warning
+ //
+ // If you REALLY really need no zlib support, you can still disable
+ // it by doing the following:
+ // add "no-zlib" to mkspecs/qconfig.pri
+ // #define QT_NO_COMPRESS (probably by adding to src/corelib/global/qconfig.h)
+ //
+ // There's no guarantee that Qt will build under those conditions
+
+ dictionary[ "ZLIB_FORCED" ] = "yes";
+ } else if( configCmdLine.at(i) == "-qt-zlib" ) {
+ dictionary[ "ZLIB" ] = "qt";
+ } else if( configCmdLine.at(i) == "-system-zlib" ) {
+ dictionary[ "ZLIB" ] = "system";
+ }
+
+ // Image formats --------------------------------------------
+ else if( configCmdLine.at(i) == "-no-gif" )
+ dictionary[ "GIF" ] = "no";
+ else if( configCmdLine.at(i) == "-qt-gif" )
+ dictionary[ "GIF" ] = "auto";
+
+ else if( configCmdLine.at(i) == "-no-libtiff" ) {
+ dictionary[ "TIFF"] = "no";
+ dictionary[ "LIBTIFF" ] = "no";
+ } else if( configCmdLine.at(i) == "-qt-libtiff" ) {
+ dictionary[ "TIFF" ] = "plugin";
+ dictionary[ "LIBTIFF" ] = "qt";
+ } else if( configCmdLine.at(i) == "-system-libtiff" ) {
+ dictionary[ "TIFF" ] = "plugin";
+ dictionary[ "LIBTIFF" ] = "system";
+ }
+
+ else if( configCmdLine.at(i) == "-no-libjpeg" ) {
+ dictionary[ "JPEG" ] = "no";
+ dictionary[ "LIBJPEG" ] = "no";
+ } else if( configCmdLine.at(i) == "-qt-libjpeg" ) {
+ dictionary[ "JPEG" ] = "plugin";
+ dictionary[ "LIBJPEG" ] = "qt";
+ } else if( configCmdLine.at(i) == "-system-libjpeg" ) {
+ dictionary[ "JPEG" ] = "plugin";
+ dictionary[ "LIBJPEG" ] = "system";
+ }
+
+ else if( configCmdLine.at(i) == "-no-libpng" ) {
+ dictionary[ "PNG" ] = "no";
+ dictionary[ "LIBPNG" ] = "no";
+ } else if( configCmdLine.at(i) == "-qt-libpng" ) {
+ dictionary[ "PNG" ] = "qt";
+ dictionary[ "LIBPNG" ] = "qt";
+ } else if( configCmdLine.at(i) == "-system-libpng" ) {
+ dictionary[ "PNG" ] = "qt";
+ dictionary[ "LIBPNG" ] = "system";
+ }
+
+ else if( configCmdLine.at(i) == "-no-libmng" ) {
+ dictionary[ "MNG" ] = "no";
+ dictionary[ "LIBMNG" ] = "no";
+ } else if( configCmdLine.at(i) == "-qt-libmng" ) {
+ dictionary[ "MNG" ] = "qt";
+ dictionary[ "LIBMNG" ] = "qt";
+ } else if( configCmdLine.at(i) == "-system-libmng" ) {
+ dictionary[ "MNG" ] = "qt";
+ dictionary[ "LIBMNG" ] = "system";
+ }
+ // CE- C runtime --------------------------------------------
+ else if( configCmdLine.at(i) == "-crt" ) {
+ ++i;
+ if (i==argCount)
+ break;
+ QDir cDir(configCmdLine.at(i));
+ if (!cDir.exists())
+ cout << "WARNING: Could not find directory (" << qPrintable(configCmdLine.at(i)) << ")for C runtime deployment" << endl;
+ else
+ dictionary[ "CE_CRT" ] = QDir::toNativeSeparators(cDir.absolutePath());
+ } else if (configCmdLine.at(i) == "-qt-crt") {
+ dictionary[ "CE_CRT" ] = "yes";
+ } else if (configCmdLine.at(i) == "-no-crt") {
+ dictionary[ "CE_CRT" ] = "no";
+ }
+ // cetest ---------------------------------------------------
+ else if (configCmdLine.at(i) == "-no-cetest") {
+ dictionary[ "CETEST" ] = "no";
+ } else if (configCmdLine.at(i) == "-cetest") {
+ // although specified to use it, we stay at "auto" state
+ // this is because checkAvailability() adds variables
+ // we need for crosscompilation
+ }
+ // Qt/CE - signing tool -------------------------------------
+ else if( configCmdLine.at(i) == "-signature") {
+ ++i;
+ if (i==argCount)
+ break;
+ QFileInfo info(configCmdLine.at(i));
+ if (!info.exists())
+ cout << "WARNING: Could not find signature file (" << qPrintable(configCmdLine.at(i)) << ")" << endl;
+ else
+ dictionary[ "CE_SIGNATURE" ] = QDir::toNativeSeparators(info.absoluteFilePath());
+ }
+ // Styles ---------------------------------------------------
+ else if( configCmdLine.at(i) == "-qt-style-windows" )
+ dictionary[ "STYLE_WINDOWS" ] = "yes";
+ else if( configCmdLine.at(i) == "-no-style-windows" )
+ dictionary[ "STYLE_WINDOWS" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-style-windowsce" )
+ dictionary[ "STYLE_WINDOWSCE" ] = "yes";
+ else if( configCmdLine.at(i) == "-no-style-windowsce" )
+ dictionary[ "STYLE_WINDOWSCE" ] = "no";
+ else if( configCmdLine.at(i) == "-qt-style-windowsmobile" )
+ dictionary[ "STYLE_WINDOWSMOBILE" ] = "yes";
+ else if( configCmdLine.at(i) == "-no-style-windowsmobile" )
+ dictionary[ "STYLE_WINDOWSMOBILE" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-style-windowsxp" )
+ dictionary[ "STYLE_WINDOWSXP" ] = "yes";
+ else if( configCmdLine.at(i) == "-no-style-windowsxp" )
+ dictionary[ "STYLE_WINDOWSXP" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-style-windowsvista" )
+ dictionary[ "STYLE_WINDOWSVISTA" ] = "yes";
+ else if( configCmdLine.at(i) == "-no-style-windowsvista" )
+ dictionary[ "STYLE_WINDOWSVISTA" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-style-plastique" )
+ dictionary[ "STYLE_PLASTIQUE" ] = "yes";
+ else if( configCmdLine.at(i) == "-no-style-plastique" )
+ dictionary[ "STYLE_PLASTIQUE" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-style-cleanlooks" )
+ dictionary[ "STYLE_CLEANLOOKS" ] = "yes";
+ else if( configCmdLine.at(i) == "-no-style-cleanlooks" )
+ dictionary[ "STYLE_CLEANLOOKS" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-style-motif" )
+ dictionary[ "STYLE_MOTIF" ] = "yes";
+ else if( configCmdLine.at(i) == "-no-style-motif" )
+ dictionary[ "STYLE_MOTIF" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-style-cde" )
+ dictionary[ "STYLE_CDE" ] = "yes";
+ else if( configCmdLine.at(i) == "-no-style-cde" )
+ dictionary[ "STYLE_CDE" ] = "no";
+
+ // Qt 3 Support ---------------------------------------------
+ else if( configCmdLine.at(i) == "-no-qt3support" )
+ dictionary[ "QT3SUPPORT" ] = "no";
+
+ // Work around compiler nesting limitation
+ else
+ continueElse = true;
+ if (!continueElse) {
+ }
+
+ // OpenGL Support -------------------------------------------
+ else if( configCmdLine.at(i) == "-no-opengl" ) {
+ dictionary[ "OPENGL" ] = "no";
+ } else if ( configCmdLine.at(i) == "-opengl-es-cm" ) {
+ dictionary[ "OPENGL" ] = "yes";
+ dictionary[ "OPENGL_ES_CM" ] = "yes";
+ } else if ( configCmdLine.at(i) == "-opengl-es-cl" ) {
+ dictionary[ "OPENGL" ] = "yes";
+ dictionary[ "OPENGL_ES_CL" ] = "yes";
+ }
+ // Databases ------------------------------------------------
+ else if( configCmdLine.at(i) == "-qt-sql-mysql" )
+ dictionary[ "SQL_MYSQL" ] = "yes";
+ else if( configCmdLine.at(i) == "-plugin-sql-mysql" )
+ dictionary[ "SQL_MYSQL" ] = "plugin";
+ else if( configCmdLine.at(i) == "-no-sql-mysql" )
+ dictionary[ "SQL_MYSQL" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-sql-odbc" )
+ dictionary[ "SQL_ODBC" ] = "yes";
+ else if( configCmdLine.at(i) == "-plugin-sql-odbc" )
+ dictionary[ "SQL_ODBC" ] = "plugin";
+ else if( configCmdLine.at(i) == "-no-sql-odbc" )
+ dictionary[ "SQL_ODBC" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-sql-oci" )
+ dictionary[ "SQL_OCI" ] = "yes";
+ else if( configCmdLine.at(i) == "-plugin-sql-oci" )
+ dictionary[ "SQL_OCI" ] = "plugin";
+ else if( configCmdLine.at(i) == "-no-sql-oci" )
+ dictionary[ "SQL_OCI" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-sql-psql" )
+ dictionary[ "SQL_PSQL" ] = "yes";
+ else if( configCmdLine.at(i) == "-plugin-sql-psql" )
+ dictionary[ "SQL_PSQL" ] = "plugin";
+ else if( configCmdLine.at(i) == "-no-sql-psql" )
+ dictionary[ "SQL_PSQL" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-sql-tds" )
+ dictionary[ "SQL_TDS" ] = "yes";
+ else if( configCmdLine.at(i) == "-plugin-sql-tds" )
+ dictionary[ "SQL_TDS" ] = "plugin";
+ else if( configCmdLine.at(i) == "-no-sql-tds" )
+ dictionary[ "SQL_TDS" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-sql-db2" )
+ dictionary[ "SQL_DB2" ] = "yes";
+ else if( configCmdLine.at(i) == "-plugin-sql-db2" )
+ dictionary[ "SQL_DB2" ] = "plugin";
+ else if( configCmdLine.at(i) == "-no-sql-db2" )
+ dictionary[ "SQL_DB2" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-sql-sqlite" )
+ dictionary[ "SQL_SQLITE" ] = "yes";
+ else if( configCmdLine.at(i) == "-plugin-sql-sqlite" )
+ dictionary[ "SQL_SQLITE" ] = "plugin";
+ else if( configCmdLine.at(i) == "-no-sql-sqlite" )
+ dictionary[ "SQL_SQLITE" ] = "no";
+ else if( configCmdLine.at(i) == "-system-sqlite" )
+ dictionary[ "SQL_SQLITE_LIB" ] = "system";
+ else if( configCmdLine.at(i) == "-qt-sql-sqlite2" )
+ dictionary[ "SQL_SQLITE2" ] = "yes";
+ else if( configCmdLine.at(i) == "-plugin-sql-sqlite2" )
+ dictionary[ "SQL_SQLITE2" ] = "plugin";
+ else if( configCmdLine.at(i) == "-no-sql-sqlite2" )
+ dictionary[ "SQL_SQLITE2" ] = "no";
+
+ else if( configCmdLine.at(i) == "-qt-sql-ibase" )
+ dictionary[ "SQL_IBASE" ] = "yes";
+ else if( configCmdLine.at(i) == "-plugin-sql-ibase" )
+ dictionary[ "SQL_IBASE" ] = "plugin";
+ else if( configCmdLine.at(i) == "-no-sql-ibase" )
+ dictionary[ "SQL_IBASE" ] = "no";
+#endif
+ // IDE project generation -----------------------------------
+ else if( configCmdLine.at(i) == "-no-dsp" )
+ dictionary[ "DSPFILES" ] = "no";
+ else if( configCmdLine.at(i) == "-dsp" )
+ dictionary[ "DSPFILES" ] = "yes";
+
+ else if( configCmdLine.at(i) == "-no-vcp" )
+ dictionary[ "VCPFILES" ] = "no";
+ else if( configCmdLine.at(i) == "-vcp" )
+ dictionary[ "VCPFILES" ] = "yes";
+
+ else if( configCmdLine.at(i) == "-no-vcproj" )
+ dictionary[ "VCPROJFILES" ] = "no";
+ else if( configCmdLine.at(i) == "-vcproj" )
+ dictionary[ "VCPROJFILES" ] = "yes";
+
+ else if( configCmdLine.at(i) == "-no-incredibuild-xge" )
+ dictionary[ "INCREDIBUILD_XGE" ] = "no";
+ else if( configCmdLine.at(i) == "-incredibuild-xge" )
+ dictionary[ "INCREDIBUILD_XGE" ] = "yes";
+#if !defined(EVAL)
+ // Others ---------------------------------------------------
+ else if (configCmdLine.at(i) == "-fast" )
+ dictionary[ "FAST" ] = "yes";
+ else if (configCmdLine.at(i) == "-no-fast" )
+ dictionary[ "FAST" ] = "no";
+
+ else if( configCmdLine.at(i) == "-stl" )
+ dictionary[ "STL" ] = "yes";
+ else if( configCmdLine.at(i) == "-no-stl" )
+ dictionary[ "STL" ] = "no";
+
+ else if ( configCmdLine.at(i) == "-exceptions" )
+ dictionary[ "EXCEPTIONS" ] = "yes";
+ else if ( configCmdLine.at(i) == "-no-exceptions" )
+ dictionary[ "EXCEPTIONS" ] = "no";
+
+ else if ( configCmdLine.at(i) == "-rtti" )
+ dictionary[ "RTTI" ] = "yes";
+ else if ( configCmdLine.at(i) == "-no-rtti" )
+ dictionary[ "RTTI" ] = "no";
+
+ else if( configCmdLine.at(i) == "-accessibility" )
+ dictionary[ "ACCESSIBILITY" ] = "yes";
+ else if( configCmdLine.at(i) == "-no-accessibility" ) {
+ dictionary[ "ACCESSIBILITY" ] = "no";
+ cout << "Setting accessibility to NO" << endl;
+ }
+
+ else if (configCmdLine.at(i) == "-no-mmx")
+ dictionary[ "MMX" ] = "no";
+ else if (configCmdLine.at(i) == "-mmx")
+ dictionary[ "MMX" ] = "yes";
+ else if (configCmdLine.at(i) == "-no-3dnow")
+ dictionary[ "3DNOW" ] = "no";
+ else if (configCmdLine.at(i) == "-3dnow")
+ dictionary[ "3DNOW" ] = "yes";
+ else if (configCmdLine.at(i) == "-no-sse")
+ dictionary[ "SSE" ] = "no";
+ else if (configCmdLine.at(i) == "-sse")
+ dictionary[ "SSE" ] = "yes";
+ else if (configCmdLine.at(i) == "-no-sse2")
+ dictionary[ "SSE2" ] = "no";
+ else if (configCmdLine.at(i) == "-sse2")
+ dictionary[ "SSE2" ] = "yes";
+ else if (configCmdLine.at(i) == "-no-iwmmxt")
+ dictionary[ "IWMMXT" ] = "no";
+ else if (configCmdLine.at(i) == "-iwmmxt")
+ dictionary[ "IWMMXT" ] = "yes";
+
+ else if (configCmdLine.at(i) == "-no-direct3d") {
+ dictionary["DIRECT3D"] = "no";
+ }else if (configCmdLine.at(i) == "-direct3d") {
+ dictionary["DIRECT3D"] = "auto"; // have to pass auto detection to enable Direct3D
+ } else if( configCmdLine.at(i) == "-no-openssl" ) {
+ dictionary[ "OPENSSL"] = "no";
+ } else if( configCmdLine.at(i) == "-openssl" ) {
+ dictionary[ "OPENSSL" ] = "yes";
+ } else if( configCmdLine.at(i) == "-openssl-linked" ) {
+ dictionary[ "OPENSSL" ] = "linked";
+ } else if( configCmdLine.at(i) == "-no-qdbus" ) {
+ dictionary[ "DBUS" ] = "no";
+ } else if( configCmdLine.at(i) == "-qdbus" ) {
+ dictionary[ "DBUS" ] = "yes";
+ } else if( configCmdLine.at(i) == "-no-dbus" ) {
+ dictionary[ "DBUS" ] = "no";
+ } else if( configCmdLine.at(i) == "-dbus" ) {
+ dictionary[ "DBUS" ] = "yes";
+ } else if( configCmdLine.at(i) == "-dbus-linked" ) {
+ dictionary[ "DBUS" ] = "linked";
+ } else if( configCmdLine.at(i) == "-no-scripttools" ) {
+ dictionary[ "SCRIPTTOOLS" ] = "no";
+ } else if( configCmdLine.at(i) == "-scripttools" ) {
+ dictionary[ "SCRIPTTOOLS" ] = "yes";
+ } else if( configCmdLine.at(i) == "-no-xmlpatterns" ) {
+ dictionary[ "XMLPATTERNS" ] = "no";
+ } else if( configCmdLine.at(i) == "-xmlpatterns" ) {
+ dictionary[ "XMLPATTERNS" ] = "yes";
+ } else if( configCmdLine.at(i) == "-no-phonon" ) {
+ dictionary[ "PHONON" ] = "no";
+ } else if( configCmdLine.at(i) == "-phonon" ) {
+ dictionary[ "PHONON" ] = "yes";
+ } else if( configCmdLine.at(i) == "-no-phonon-backend" ) {
+ dictionary[ "PHONON_BACKEND" ] = "no";
+ } else if( configCmdLine.at(i) == "-phonon-backend" ) {
+ dictionary[ "PHONON_BACKEND" ] = "yes";
+ } else if( configCmdLine.at(i) == "-phonon-wince-ds9" ) {
+ dictionary[ "DIRECTSHOW" ] = "yes";
+ } else if( configCmdLine.at(i) == "-no-webkit" ) {
+ dictionary[ "WEBKIT" ] = "no";
+ } else if( configCmdLine.at(i) == "-webkit" ) {
+ dictionary[ "WEBKIT" ] = "yes";
+ } else if( configCmdLine.at(i) == "-no-plugin-manifests" ) {
+ dictionary[ "PLUGIN_MANIFESTS" ] = "no";
+ } else if( configCmdLine.at(i) == "-plugin-manifests" ) {
+ dictionary[ "PLUGIN_MANIFESTS" ] = "yes";
+ }
+
+ else if( configCmdLine.at(i) == "-internal" )
+ dictionary[ "QMAKE_INTERNAL" ] = "yes";
+
+ else if( configCmdLine.at(i) == "-no-qmake" )
+ dictionary[ "BUILD_QMAKE" ] = "no";
+ else if( configCmdLine.at(i) == "-qmake" )
+ dictionary[ "BUILD_QMAKE" ] = "yes";
+
+ else if( configCmdLine.at(i) == "-dont-process" )
+ dictionary[ "NOPROCESS" ] = "yes";
+ else if( configCmdLine.at(i) == "-process" )
+ dictionary[ "NOPROCESS" ] = "no";
+
+ else if( configCmdLine.at(i) == "-no-qmake-deps" )
+ dictionary[ "DEPENDENCIES" ] = "no";
+ else if( configCmdLine.at(i) == "-qmake-deps" )
+ dictionary[ "DEPENDENCIES" ] = "yes";
+
+
+ else if( configCmdLine.at(i) == "-qtnamespace" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ qmakeDefines += "QT_NAMESPACE="+configCmdLine.at(i);
+ } else if( configCmdLine.at(i) == "-D" ) {
+ ++i;
+ if (i==argCount)
+ break;
+ qmakeDefines += configCmdLine.at(i);
+ } else if( configCmdLine.at(i) == "-I" ) {
+ ++i;
+ if (i==argCount)
+ break;
+ qmakeIncludes += configCmdLine.at(i);
+ } else if( configCmdLine.at(i) == "-L" ) {
+ ++i;
+ if (i==argCount)
+ break;
+ QFileInfo check(configCmdLine.at(i));
+ if (!check.isDir()) {
+ cout << "Argument passed to -L option is not a directory path. Did you mean the -l option?" << endl;
+ dictionary[ "DONE" ] = "error";
+ break;
+ }
+ qmakeLibs += QString("-L" + configCmdLine.at(i));
+ } else if( configCmdLine.at(i) == "-l" ) {
+ ++i;
+ if (i==argCount)
+ break;
+ qmakeLibs += QString("-l" + configCmdLine.at(i));
+ } else if (configCmdLine.at(i).startsWith("OPENSSL_LIBS=")) {
+ opensslLibs = configCmdLine.at(i);
+ }
+
+ else if( ( configCmdLine.at(i) == "-override-version" ) || ( configCmdLine.at(i) == "-version-override" ) ){
+ ++i;
+ if (i==argCount)
+ break;
+ dictionary[ "VERSION" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-saveconfig" ) {
+ ++i;
+ if (i==argCount)
+ break;
+ dictionary[ "CUSTOMCONFIG" ] = "_" + configCmdLine.at(i);
+ }
+
+ else if (configCmdLine.at(i) == "-confirm-license") {
+ dictionary["LICENSE_CONFIRMED"] = "yes";
+ }
+
+ else if (configCmdLine.at(i) == "-nomake") {
+ ++i;
+ if (i==argCount)
+ break;
+ disabledBuildParts += configCmdLine.at(i);
+ }
+
+ // Directories ----------------------------------------------
+ else if( configCmdLine.at(i) == "-prefix" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "QT_INSTALL_PREFIX" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-bindir" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "QT_INSTALL_BINS" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-libdir" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "QT_INSTALL_LIBS" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-docdir" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "QT_INSTALL_DOCS" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-headerdir" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "QT_INSTALL_HEADERS" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-plugindir" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "QT_INSTALL_PLUGINS" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-datadir" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "QT_INSTALL_DATA" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-translationdir" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "QT_INSTALL_TRANSLATIONS" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-examplesdir" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "QT_INSTALL_EXAMPLES" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-demosdir" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "QT_INSTALL_DEMOS" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-hostprefix" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "QT_HOST_PREFIX" ] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i) == "-make" ) {
+ ++i;
+ if(i==argCount)
+ break;
+ dictionary[ "MAKE" ] = configCmdLine.at(i);
+ }
+
+ else if (configCmdLine.at(i) == "-graphicssystem") {
+ ++i;
+ if (i == argCount)
+ break;
+ QString system = configCmdLine.at(i);
+ if (system == QLatin1String("raster") || system == QLatin1String("opengl"))
+ dictionary["GRAPHICS_SYSTEM"] = configCmdLine.at(i);
+ }
+
+ else if( configCmdLine.at(i).indexOf( QRegExp( "^-(en|dis)able-" ) ) != -1 ) {
+ // Scan to see if any specific modules and drivers are enabled or disabled
+ for( QStringList::Iterator module = modules.begin(); module != modules.end(); ++module ) {
+ if( configCmdLine.at(i) == QString( "-enable-" ) + (*module) ) {
+ enabledModules += (*module);
+ break;
+ }
+ else if( configCmdLine.at(i) == QString( "-disable-" ) + (*module) ) {
+ disabledModules += (*module);
+ break;
+ }
+ }
+ }
+
+ else {
+ dictionary[ "HELP" ] = "yes";
+ cout << "Unknown option " << configCmdLine.at(i) << endl;
+ break;
+ }
+
+#endif
+ }
+
+ // Ensure that QMAKESPEC exists in the mkspecs folder
+ QDir mkspec_dir = fixSeparators(sourcePath + "/mkspecs");
+ QStringList mkspecs = mkspec_dir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot);
+
+ if (dictionary["QMAKESPEC"].toLower() == "features"
+ || !mkspecs.contains(dictionary["QMAKESPEC"], Qt::CaseInsensitive)) {
+ dictionary[ "HELP" ] = "yes";
+ if (dictionary ["QMAKESPEC_FROM"] == "commandline") {
+ cout << "Invalid option \"" << dictionary["QMAKESPEC"] << "\" for -platform." << endl;
+ } else if (dictionary ["QMAKESPEC_FROM"] == "env") {
+ cout << "QMAKESPEC environment variable is set to \"" << dictionary["QMAKESPEC"]
+ << "\" which is not a supported platform" << endl;
+ } else { // was autodetected from environment
+ cout << "Unable to detect the platform from environment. Use -platform command line"
+ "argument or set the QMAKESPEC environment variable and run configure again" << endl;
+ }
+ cout << "See the README file for a list of supported operating systems and compilers." << endl;
+ } else {
+ if( dictionary[ "QMAKESPEC" ].endsWith( "-icc" ) ||
+ dictionary[ "QMAKESPEC" ].endsWith( "-msvc" ) ||
+ dictionary[ "QMAKESPEC" ].endsWith( "-msvc.net" ) ||
+ dictionary[ "QMAKESPEC" ].endsWith( "-msvc2002" ) ||
+ dictionary[ "QMAKESPEC" ].endsWith( "-msvc2003" ) ||
+ dictionary[ "QMAKESPEC" ].endsWith( "-msvc2005" ) ||
+ dictionary[ "QMAKESPEC" ].endsWith( "-msvc2008" )) {
+ if ( dictionary[ "MAKE" ].isEmpty() ) dictionary[ "MAKE" ] = "nmake";
+ dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32";
+ } else if ( dictionary[ "QMAKESPEC" ] == QString( "win32-g++" ) ) {
+ if ( dictionary[ "MAKE" ].isEmpty() ) dictionary[ "MAKE" ] = "mingw32-make";
+ if (Environment::detectExecutable("sh.exe")) {
+ dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32-g++-sh";
+ } else {
+ dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32-g++";
+ }
+ } else {
+ if ( dictionary[ "MAKE" ].isEmpty() ) dictionary[ "MAKE" ] = "make";
+ dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32";
+ }
+ }
+
+ // Ensure that -spec (XQMAKESPEC) exists in the mkspecs folder as well
+ if (dictionary.contains("XQMAKESPEC") &&
+ !mkspecs.contains(dictionary["XQMAKESPEC"], Qt::CaseInsensitive)) {
+ dictionary["HELP"] = "yes";
+ cout << "Invalid option \"" << dictionary["XQMAKESPEC"] << "\" for -xplatform." << endl;
+ }
+
+ // Ensure that the crt to be deployed can be found
+ if (dictionary["CE_CRT"] != QLatin1String("yes") && dictionary["CE_CRT"] != QLatin1String("no")) {
+ QDir cDir(dictionary["CE_CRT"]);
+ QStringList entries = cDir.entryList();
+ bool hasDebug = entries.contains("msvcr80.dll");
+ bool hasRelease = entries.contains("msvcr80d.dll");
+ if ((dictionary["BUILDALL"] == "auto") && (!hasDebug || !hasRelease)) {
+ cout << "Could not find debug and release c-runtime." << endl;
+ cout << "You need to have msvcr80.dll and msvcr80d.dll in" << endl;
+ cout << "the path specified. Setting to -no-crt";
+ dictionary[ "CE_CRT" ] = "no";
+ } else if ((dictionary["BUILD"] == "debug") && !hasDebug) {
+ cout << "Could not find debug c-runtime (msvcr80d.dll) in the directory specified." << endl;
+ cout << "Setting c-runtime automatic deployment to -no-crt" << endl;
+ dictionary[ "CE_CRT" ] = "no";
+ } else if ((dictionary["BUILD"] == "release") && !hasRelease) {
+ cout << "Could not find release c-runtime (msvcr80.dll) in the directory specified." << endl;
+ cout << "Setting c-runtime automatic deployment to -no-crt" << endl;
+ dictionary[ "CE_CRT" ] = "no";
+ }
+ }
+
+ useUnixSeparators = (dictionary["QMAKESPEC"] == "win32-g++");
+
+
+#if !defined(EVAL)
+ for( QStringList::Iterator dis = disabledModules.begin(); dis != disabledModules.end(); ++dis ) {
+ modules.removeAll( (*dis) );
+ }
+ for( QStringList::Iterator ena = enabledModules.begin(); ena != enabledModules.end(); ++ena ) {
+ if( modules.indexOf( (*ena) ) == -1 )
+ modules += (*ena);
+ }
+ qtConfig += modules;
+
+ for( QStringList::Iterator it = disabledModules.begin(); it != disabledModules.end(); ++it )
+ qtConfig.removeAll(*it);
+
+ if( ( dictionary[ "REDO" ] != "yes" ) && ( dictionary[ "HELP" ] != "yes" ) )
+ saveCmdLine();
+#endif
+}
+
+#if !defined(EVAL)
+void Configure::validateArgs()
+{
+ QStringList configs;
+ // Validate the specified config
+
+ QDir dir;
+ QStringList filters;
+ filters << "qconfig-*.h";
+ dir.setNameFilters(filters);
+ dir.setPath(sourcePath + "/src/corelib/global/");
+
+ QStringList stringList = dir.entryList();
+
+ QStringList::Iterator it;
+ for( it = stringList.begin(); it != stringList.end(); ++it )
+ allConfigs << it->remove("qconfig-").remove(".h");
+ allConfigs << "full";
+
+ QStringList::Iterator config;
+ for( config = allConfigs.begin(); config != allConfigs.end(); ++config ) {
+ configs += (*config) + "-config";
+ if( (*config) == dictionary[ "QCONFIG" ] )
+ break;
+ }
+ if( config == allConfigs.end() ) {
+ dictionary[ "HELP" ] = "yes";
+ cout << "No such configuration \"" << qPrintable(dictionary[ "QCONFIG" ]) << "\"" << endl ;
+ }
+ else
+ qmakeConfig += configs;
+}
+#endif
+
+
+// Output helper functions --------------------------------[ Start ]-
+/*!
+ Determines the length of a string token.
+*/
+static int tokenLength(const char *str)
+{
+ if (*str == 0)
+ return 0;
+
+ const char *nextToken = strpbrk(str, " _/\n\r");
+ if (nextToken == str || !nextToken)
+ return 1;
+
+ return int(nextToken - str);
+}
+
+/*!
+ Prints out a string which starts at position \a startingAt, and
+ indents each wrapped line with \a wrapIndent characters.
+ The wrap point is set to the console width, unless that width
+ cannot be determined, or is too small.
+*/
+void Configure::desc(const char *description, int startingAt, int wrapIndent)
+{
+ int linePos = startingAt;
+
+ bool firstLine = true;
+ const char *nextToken = description;
+ while (*nextToken) {
+ int nextTokenLen = tokenLength(nextToken);
+ if (*nextToken == '\n' // Wrap on newline, duh
+ || (linePos + nextTokenLen > outputWidth)) // Wrap at outputWidth
+ {
+ printf("\n");
+ linePos = 0;
+ firstLine = false;
+ if (*nextToken == '\n')
+ ++nextToken;
+ continue;
+ }
+ if (!firstLine && linePos < wrapIndent) { // Indent to wrapIndent
+ printf("%*s", wrapIndent , "");
+ linePos = wrapIndent;
+ if (*nextToken == ' ') {
+ ++nextToken;
+ continue;
+ }
+ }
+ printf("%.*s", nextTokenLen, nextToken);
+ linePos += nextTokenLen;
+ nextToken += nextTokenLen;
+ }
+}
+
+/*!
+ Prints out an option with its description wrapped at the
+ description starting point. If \a skipIndent is true, the
+ indentation to the option is not outputted (used by marked option
+ version of desc()). Extra spaces between option and its
+ description is filled with\a fillChar, if there's available
+ space.
+*/
+void Configure::desc(const char *option, const char *description, bool skipIndent, char fillChar)
+{
+ if (!skipIndent)
+ printf("%*s", optionIndent, "");
+
+ int remaining = descIndent - optionIndent - strlen(option);
+ int wrapIndent = descIndent + qMax(0, 1 - remaining);
+ printf("%s", option);
+
+ if (remaining > 2) {
+ printf(" "); // Space in front
+ for (int i = remaining; i > 2; --i)
+ printf("%c", fillChar); // Fill, if available space
+ }
+ printf(" "); // Space between option and description
+
+ desc(description, wrapIndent, wrapIndent);
+ printf("\n");
+}
+
+/*!
+ Same as above, except it also marks an option with an '*', if
+ the option is default action.
+*/
+void Configure::desc(const char *mark_option, const char *mark, const char *option, const char *description, char fillChar)
+{
+ const QString markedAs = dictionary.value(mark_option);
+ if (markedAs == "auto" && markedAs == mark) // both "auto", always => +
+ printf(" + ");
+ else if (markedAs == "auto") // setting marked as "auto" and option is default => +
+ printf(" %c " , (defaultTo(mark_option) == QLatin1String(mark))? '+' : ' ');
+ else if (QLatin1String(mark) == "auto" && markedAs != "no") // description marked as "auto" and option is available => +
+ printf(" %c " , checkAvailability(mark_option) ? '+' : ' ');
+ else // None are "auto", (markedAs == mark) => *
+ printf(" %c " , markedAs == QLatin1String(mark) ? '*' : ' ');
+
+ desc(option, description, true, fillChar);
+}
+
+/*!
+ Modifies the default configuration based on given -platform option.
+ Eg. switches to different default styles for Windows CE.
+*/
+void Configure::applySpecSpecifics()
+{
+ if (dictionary[ "XQMAKESPEC" ].startsWith("wince")) {
+ dictionary[ "STYLE_WINDOWSXP" ] = "no";
+ dictionary[ "STYLE_WINDOWSVISTA" ] = "no";
+ dictionary[ "STYLE_PLASTIQUE" ] = "no";
+ dictionary[ "STYLE_CLEANLOOKS" ] = "no";
+ dictionary[ "STYLE_WINDOWSCE" ] = "yes";
+ dictionary[ "STYLE_WINDOWSMOBILE" ] = "yes";
+ dictionary[ "STYLE_MOTIF" ] = "no";
+ dictionary[ "STYLE_CDE" ] = "no";
+ dictionary[ "QT3SUPPORT" ] = "no";
+ dictionary[ "OPENGL" ] = "no";
+ dictionary[ "OPENSSL" ] = "no";
+ dictionary[ "STL" ] = "no";
+ dictionary[ "EXCEPTIONS" ] = "no";
+ dictionary[ "RTTI" ] = "no";
+ dictionary[ "ARCHITECTURE" ] = "windowsce";
+ dictionary[ "3DNOW" ] = "no";
+ dictionary[ "SSE" ] = "no";
+ dictionary[ "SSE2" ] = "no";
+ dictionary[ "MMX" ] = "no";
+ dictionary[ "IWMMXT" ] = "no";
+ dictionary[ "CE_CRT" ] = "yes";
+ dictionary[ "DIRECT3D" ] = "no";
+ dictionary[ "WEBKIT" ] = "no";
+ dictionary[ "PHONON" ] = "yes";
+ dictionary[ "DIRECTSHOW" ] = "no";
+ // We only apply MMX/IWMMXT for mkspecs we know they work
+ if (dictionary[ "XQMAKESPEC" ].startsWith("wincewm")) {
+ dictionary[ "MMX" ] = "yes";
+ dictionary[ "IWMMXT" ] = "yes";
+ dictionary[ "DIRECTSHOW" ] = "yes";
+ }
+ dictionary[ "QT_HOST_PREFIX" ] = dictionary[ "QT_INSTALL_PREFIX" ];
+ dictionary[ "QT_INSTALL_PREFIX" ] = "";
+
+ } else if(dictionary[ "XQMAKESPEC" ].startsWith("linux")) { //TODO actually wrong.
+ //TODO
+ dictionary[ "STYLE_WINDOWSXP" ] = "no";
+ dictionary[ "STYLE_WINDOWSVISTA" ] = "no";
+ dictionary[ "KBD_DRIVERS" ] = "tty";
+ dictionary[ "GFX_DRIVERS" ] = "linuxfb vnc";
+ dictionary[ "MOUSE_DRIVERS" ] = "pc linuxtp";
+ dictionary[ "QT3SUPPORT" ] = "no";
+ dictionary[ "OPENGL" ] = "no";
+ dictionary[ "EXCEPTIONS" ] = "no";
+ dictionary[ "DBUS"] = "no";
+ dictionary[ "QT_QWS_DEPTH" ] = "4 8 16 24 32";
+ dictionary[ "QT_SXE" ] = "no";
+ dictionary[ "QT_INOTIFY" ] = "no";
+ dictionary[ "QT_LPR" ] = "no";
+ dictionary[ "QT_CUPS" ] = "no";
+ dictionary[ "QT_GLIB" ] = "no";
+ dictionary[ "QT_ICONV" ] = "no";
+
+ dictionary["DECORATIONS"] = "default windows styled";
+ dictionary[ "QMAKEADDITIONALARGS" ] = "-unix";
+ }
+}
+
+QString Configure::locateFileInPaths(const QString &fileName, const QStringList &paths)
+{
+ QDir d;
+ for( QStringList::ConstIterator it = paths.begin(); it != paths.end(); ++it ) {
+ // Remove any leading or trailing ", this is commonly used in the environment
+ // variables
+ QString path = (*it);
+ if ( path.startsWith( "\"" ) )
+ path = path.right( path.length() - 1 );
+ if ( path.endsWith( "\"" ) )
+ path = path.left( path.length() - 1 );
+ if( d.exists(path + QDir::separator() + fileName) ) {
+ return (path);
+ }
+ }
+ return QString();
+}
+
+QString Configure::locateFile( const QString &fileName )
+{
+ QString file = fileName.toLower();
+ QStringList paths;
+#if defined(Q_OS_WIN32)
+ QRegExp splitReg("[;,]");
+#else
+ QRegExp splitReg("[:]");
+#endif
+ if (file.endsWith(".h"))
+ paths = QString::fromLocal8Bit(getenv("INCLUDE")).split(splitReg, QString::SkipEmptyParts);
+ else if ( file.endsWith( ".lib" ) )
+ paths = QString::fromLocal8Bit(getenv("LIB")).split(splitReg, QString::SkipEmptyParts);
+ else
+ paths = QString::fromLocal8Bit(getenv("PATH")).split(splitReg, QString::SkipEmptyParts);
+ return locateFileInPaths(file, paths);
+}
+
+// Output helper functions ---------------------------------[ Stop ]-
+
+
+bool Configure::displayHelp()
+{
+ if( dictionary[ "HELP" ] == "yes" ) {
+ desc("Usage: configure [-buildkey <key>]\n"
+// desc("Usage: configure [-prefix dir] [-bindir <dir>] [-libdir <dir>]\n"
+// "[-docdir <dir>] [-headerdir <dir>] [-plugindir <dir>]\n"
+// "[-datadir <dir>] [-translationdir <dir>]\n"
+// "[-examplesdir <dir>] [-demosdir <dir>][-buildkey <key>]\n"
+ "[-release] [-debug] [-debug-and-release] [-shared] [-static]\n"
+ "[-no-fast] [-fast] [-no-exceptions] [-exceptions]\n"
+ "[-no-accessibility] [-accessibility] [-no-rtti] [-rtti]\n"
+ "[-no-stl] [-stl] [-no-sql-<driver>] [-qt-sql-<driver>]\n"
+ "[-plugin-sql-<driver>] [-system-sqlite] [-arch <arch>]\n"
+ "[-D <define>] [-I <includepath>] [-L <librarypath>]\n"
+ "[-help] [-no-dsp] [-dsp] [-no-vcproj] [-vcproj]\n"
+ "[-no-qmake] [-qmake] [-dont-process] [-process]\n"
+ "[-no-style-<style>] [-qt-style-<style>] [-redo]\n"
+ "[-saveconfig <config>] [-loadconfig <config>]\n"
+ "[-qt-zlib] [-system-zlib] [-no-gif] [-qt-gif] [-no-libpng]\n"
+ "[-qt-libpng] [-system-libpng] [-no-libtiff] [-qt-libtiff]\n"
+ "[-system-libtiff] [-no-libjpeg] [-qt-libjpeg] [-system-libjpeg]\n"
+ "[-no-libmng] [-qt-libmng] [-system-libmng] [-no-qt3support] [-mmx]\n"
+ "[-no-mmx] [-3dnow] [-no-3dnow] [-sse] [-no-sse] [-sse2] [-no-sse2]\n"
+ "[-no-iwmmxt] [-iwmmxt] [-direct3d] [-openssl] [-openssl-linked]\n"
+ "[-no-openssl] [-no-dbus] [-dbus] [-dbus-linked] [-platform <spec>]\n"
+ "[-qtnamespace <namespace>] [-no-phonon] [-phonon]\n"
+ "[-no-phonon-backend] [-phonon-backend]\n"
+ "[-no-webkit] [-webkit]\n"
+ "[-no-scripttools] [-scripttools]\n"
+ "[-graphicssystem raster|opengl]\n\n", 0, 7);
+
+ desc("Installation options:\n\n");
+
+#if !defined(EVAL)
+/*
+ desc(" These are optional, but you may specify install directories.\n\n", 0, 1);
+
+ desc( "-prefix dir", "This will install everything relative to dir\n(default $QT_INSTALL_PREFIX)\n");
+
+ desc(" You may use these to separate different parts of the install:\n\n", 0, 1);
+
+ desc( "-bindir <dir>", "Executables will be installed to dir\n(default PREFIX/bin)");
+ desc( "-libdir <dir>", "Libraries will be installed to dir\n(default PREFIX/lib)");
+ desc( "-docdir <dir>", "Documentation will be installed to dir\n(default PREFIX/doc)");
+ desc( "-headerdir <dir>", "Headers will be installed to dir\n(default PREFIX/include)");
+ desc( "-plugindir <dir>", "Plugins will be installed to dir\n(default PREFIX/plugins)");
+ desc( "-datadir <dir>", "Data used by Qt programs will be installed to dir\n(default PREFIX)");
+ desc( "-translationdir <dir>","Translations of Qt programs will be installed to dir\n(default PREFIX/translations)\n");
+ desc( "-examplesdir <dir>", "Examples will be installed to dir\n(default PREFIX/examples)");
+ desc( "-demosdir <dir>", "Demos will be installed to dir\n(default PREFIX/demos)");
+*/
+ desc(" You may use these options to turn on strict plugin loading:\n\n", 0, 1);
+
+ desc( "-buildkey <key>", "Build the Qt library and plugins using the specified <key>. "
+ "When the library loads plugins, it will only load those that have a matching <key>.\n");
+
+ desc("Configure options:\n\n");
+
+ desc(" The defaults (*) are usually acceptable. A plus (+) denotes a default value"
+ " that needs to be evaluated. If the evaluation succeeds, the feature is"
+ " included. Here is a short explanation of each option:\n\n", 0, 1);
+
+ desc("BUILD", "release","-release", "Compile and link Qt with debugging turned off.");
+ desc("BUILD", "debug", "-debug", "Compile and link Qt with debugging turned on.");
+ desc("BUILDALL", "yes", "-debug-and-release", "Compile and link two Qt libraries, with and without debugging turned on.\n");
+
+ desc("OPENSOURCE", "opensource", "-opensource", "Compile and link the Open-Source Edition of Qt.");
+ desc("COMMERCIAL", "commercial", "-commercial", "Compile and link the Commercial Edition of Qt.\n");
+
+ desc("BUILDDEV", "yes", "-developer-build", "Compile and link Qt with Qt developer options (including auto-tests exporting)\n");
+
+ desc("SHARED", "yes", "-shared", "Create and use shared Qt libraries.");
+ desc("SHARED", "no", "-static", "Create and use static Qt libraries.\n");
+
+ desc("FAST", "no", "-no-fast", "Configure Qt normally by generating Makefiles for all project files.");
+ desc("FAST", "yes", "-fast", "Configure Qt quickly by generating Makefiles only for library and "
+ "subdirectory targets. All other Makefiles are created as wrappers "
+ "which will in turn run qmake\n");
+
+ desc("EXCEPTIONS", "no", "-no-exceptions", "Disable exceptions on platforms that support it.");
+ desc("EXCEPTIONS", "yes","-exceptions", "Enable exceptions on platforms that support it.\n");
+
+ desc("ACCESSIBILITY", "no", "-no-accessibility", "Do not compile Windows Active Accessibility support.");
+ desc("ACCESSIBILITY", "yes", "-accessibility", "Compile Windows Active Accessibility support.\n");
+
+ desc("STL", "no", "-no-stl", "Do not compile STL support.");
+ desc("STL", "yes", "-stl", "Compile STL support.\n");
+
+ desc( "-no-sql-<driver>", "Disable SQL <driver> entirely, by default none are turned on.");
+ desc( "-qt-sql-<driver>", "Enable a SQL <driver> in the Qt Library.");
+ desc( "-plugin-sql-<driver>", "Enable SQL <driver> as a plugin to be linked to at run time.\n"
+ "Available values for <driver>:");
+ desc("SQL_MYSQL", "auto", "", " mysql", ' ');
+ desc("SQL_PSQL", "auto", "", " psql", ' ');
+ desc("SQL_OCI", "auto", "", " oci", ' ');
+ desc("SQL_ODBC", "auto", "", " odbc", ' ');
+ desc("SQL_TDS", "auto", "", " tds", ' ');
+ desc("SQL_DB2", "auto", "", " db2", ' ');
+ desc("SQL_SQLITE", "auto", "", " sqlite", ' ');
+ desc("SQL_SQLITE2", "auto", "", " sqlite2", ' ');
+ desc("SQL_IBASE", "auto", "", " ibase", ' ');
+ desc( "", "(drivers marked with a '+' have been detected as available on this system)\n", false, ' ');
+
+ desc( "-system-sqlite", "Use sqlite from the operating system.\n");
+
+ desc("QT3SUPPORT", "no","-no-qt3support", "Disables the Qt 3 support functionality.\n");
+ desc("OPENGL", "no","-no-opengl", "Disables OpenGL functionality\n");
+
+#endif
+ desc( "-platform <spec>", "The operating system and compiler you are building on.\n(default %QMAKESPEC%)\n");
+ desc( "-xplatform <spec>", "The operating system and compiler you are cross compiling to.\n");
+ desc( "", "See the README file for a list of supported operating systems and compilers.\n", false, ' ');
+
+#if !defined(EVAL)
+ desc( "-qtnamespace <namespace>", "Wraps all Qt library code in 'namespace name {...}\n");
+ desc( "-D <define>", "Add an explicit define to the preprocessor.");
+ desc( "-I <includepath>", "Add an explicit include path.");
+ desc( "-L <librarypath>", "Add an explicit library path.");
+ desc( "-l <libraryname>", "Add an explicit library name, residing in a librarypath.\n");
+#endif
+ desc( "-graphicssystem <sys>", "Specify which graphicssystem should be used.\n"
+ "Available values for <sys>:");
+ desc("GRAPHICS_SYSTEM", "raster", "", " raster - Software rasterizer", ' ');
+ desc("GRAPHICS_SYSTEM", "opengl", "", " opengl - Using OpenGL accelleration, experimental!", ' ');
+
+
+ desc( "-help, -h, -?", "Display this information.\n");
+
+#if !defined(EVAL)
+ // 3rd party stuff options go below here --------------------------------------------------------------------------------
+ desc("Third Party Libraries:\n\n");
+
+ desc("ZLIB", "qt", "-qt-zlib", "Use the zlib bundled with Qt.");
+ desc("ZLIB", "system", "-system-zlib", "Use zlib from the operating system.\nSee http://www.gzip.org/zlib\n");
+
+ desc("GIF", "no", "-no-gif", "Do not compile the plugin for GIF reading support.");
+ desc("GIF", "auto", "-qt-gif", "Compile the plugin for GIF reading support.\nSee also src/plugins/imageformats/gif/qgifhandler.h\n");
+
+ desc("LIBPNG", "no", "-no-libpng", "Do not compile in PNG support.");
+ desc("LIBPNG", "qt", "-qt-libpng", "Use the libpng bundled with Qt.");
+ desc("LIBPNG", "system","-system-libpng", "Use libpng from the operating system.\nSee http://www.libpng.org/pub/png\n");
+
+ desc("LIBMNG", "no", "-no-libmng", "Do not compile in MNG support.");
+ desc("LIBMNG", "qt", "-qt-libmng", "Use the libmng bundled with Qt.");
+ desc("LIBMNG", "system","-system-libmng", "Use libmng from the operating system.\nSee See http://www.libmng.com\n");
+
+ desc("LIBTIFF", "no", "-no-libtiff", "Do not compile the plugin for TIFF support.");
+ desc("LIBTIFF", "qt", "-qt-libtiff", "Use the libtiff bundled with Qt.");
+ desc("LIBTIFF", "system","-system-libtiff", "Use libtiff from the operating system.\nSee http://www.libtiff.org\n");
+
+ desc("LIBJPEG", "no", "-no-libjpeg", "Do not compile the plugin for JPEG support.");
+ desc("LIBJPEG", "qt", "-qt-libjpeg", "Use the libjpeg bundled with Qt.");
+ desc("LIBJPEG", "system","-system-libjpeg", "Use libjpeg from the operating system.\nSee http://www.ijg.org\n");
+
+#endif
+ // Qt\Windows only options go below here --------------------------------------------------------------------------------
+ desc("Qt for Windows only:\n\n");
+
+ desc("DSPFILES", "no", "-no-dsp", "Do not generate VC++ .dsp files.");
+ desc("DSPFILES", "yes", "-dsp", "Generate VC++ .dsp files, only if spec \"win32-msvc\".\n");
+
+ desc("VCPROJFILES", "no", "-no-vcproj", "Do not generate VC++ .vcproj files.");
+ desc("VCPROJFILES", "yes", "-vcproj", "Generate VC++ .vcproj files, only if platform \"win32-msvc.net\".\n");
+
+ desc("INCREDIBUILD_XGE", "no", "-no-incredibuild-xge", "Do not add IncrediBuild XGE distribution commands to custom build steps.");
+ 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");
+
+ desc("PLUGIN_MANIFESTS", "no", "-no-plugin-manifests", "Do not embed manifests in plugins.");
+ desc("PLUGIN_MANIFESTS", "yes", "-plugin-manifests", "Embed manifests in plugins.\n");
+
+#if !defined(EVAL)
+ desc("BUILD_QMAKE", "no", "-no-qmake", "Do not compile qmake.");
+ desc("BUILD_QMAKE", "yes", "-qmake", "Compile qmake.\n");
+
+ desc("NOPROCESS", "yes", "-dont-process", "Do not generate Makefiles/Project files. This will override -no-fast if specified.");
+ desc("NOPROCESS", "no", "-process", "Generate Makefiles/Project files.\n");
+
+ desc("RTTI", "no", "-no-rtti", "Do not compile runtime type information.");
+ desc("RTTI", "yes", "-rtti", "Compile runtime type information.\n");
+ desc("MMX", "no", "-no-mmx", "Do not compile with use of MMX instructions");
+ desc("MMX", "yes", "-mmx", "Compile with use of MMX instructions");
+ desc("3DNOW", "no", "-no-3dnow", "Do not compile with use of 3DNOW instructions");
+ desc("3DNOW", "yes", "-3dnow", "Compile with use of 3DNOW instructions");
+ desc("SSE", "no", "-no-sse", "Do not compile with use of SSE instructions");
+ desc("SSE", "yes", "-sse", "Compile with use of SSE instructions");
+ desc("SSE2", "no", "-no-sse2", "Do not compile with use of SSE2 instructions");
+ desc("SSE2", "yes", "-sse2", "Compile with use of SSE2 instructions");
+ desc("DIRECT3D", "yes", "-direct3d", "Compile in Direct3D support (experimental - see INSTALL for more info)");
+ desc("OPENSSL", "no", "-no-openssl", "Do not compile in OpenSSL support");
+ desc("OPENSSL", "yes", "-openssl", "Compile in run-time OpenSSL support");
+ desc("OPENSSL", "linked","-openssl-linked", "Compile in linked OpenSSL support");
+ desc("DBUS", "no", "-no-dbus", "Do not compile in D-Bus support");
+ desc("DBUS", "yes", "-dbus", "Compile in D-Bus support and load libdbus-1 dynamically");
+ desc("DBUS", "linked", "-dbus-linked", "Compile in D-Bus support and link to libdbus-1");
+ desc("PHONON", "no", "-no-phonon", "Do not compile in the Phonon module");
+ desc("PHONON", "yes", "-phonon", "Compile the Phonon module (Phonon is built if a decent C++ compiler is used.)");
+ desc("PHONON_BACKEND","no", "-no-phonon-backend","Do not compile the platform-specific Phonon backend-plugin");
+ desc("PHONON_BACKEND","yes","-phonon-backend", "Compile in the platform-specific Phonon backend-plugin");
+ desc("WEBKIT", "no", "-no-webkit", "Do not compile in the WebKit module");
+ desc("WEBKIT", "yes", "-webkit", "Compile in the WebKit module (WebKit is built if a decent C++ compiler is used.)");
+ desc("SCRIPTTOOLS", "no", "-no-scripttools", "Do not build the QtScriptTools module.");
+ desc("SCRIPTTOOLS", "yes", "-scripttools", "Build the QtScriptTools module.");
+
+ desc( "-arch <arch>", "Specify an architecture.\n"
+ "Available values for <arch>:");
+ desc("ARCHITECTURE","windows", "", " windows", ' ');
+ desc("ARCHITECTURE","windowsce", "", " windowsce", ' ');
+ desc("ARCHITECTURE","boundschecker", "", " boundschecker", ' ');
+ desc("ARCHITECTURE","generic", "", " generic\n", ' ');
+
+ desc( "-no-style-<style>", "Disable <style> entirely.");
+ desc( "-qt-style-<style>", "Enable <style> in the Qt Library.\nAvailable styles: ");
+
+ desc("STYLE_WINDOWS", "yes", "", " windows", ' ');
+ desc("STYLE_WINDOWSXP", "auto", "", " windowsxp", ' ');
+ desc("STYLE_WINDOWSVISTA", "auto", "", " windowsvista", ' ');
+ desc("STYLE_PLASTIQUE", "yes", "", " plastique", ' ');
+ desc("STYLE_CLEANLOOKS", "yes", "", " cleanlooks", ' ');
+ desc("STYLE_MOTIF", "yes", "", " motif", ' ');
+ desc("STYLE_CDE", "yes", "", " cde", ' ');
+ desc("STYLE_WINDOWSCE", "yes", "", " windowsce", ' ');
+ desc("STYLE_WINDOWSMOBILE" , "yes", "", " windowsmobile\n", ' ');
+
+/* We do not support -qconfig on Windows yet
+
+ desc( "-qconfig <local>", "Use src/tools/qconfig-local.h rather than the default.\nPossible values for local:");
+ for (int i=0; i<allConfigs.size(); ++i)
+ desc( "", qPrintable(QString(" %1").arg(allConfigs.at(i))), false, ' ');
+ printf("\n");
+*/
+#endif
+ desc( "-loadconfig <config>", "Run configure with the parameters from file configure_<config>.cache.");
+ desc( "-saveconfig <config>", "Run configure and save the parameters in file configure_<config>.cache.");
+ desc( "-redo", "Run configure with the same parameters as last time.\n");
+
+ // Qt\Windows CE only options go below here -----------------------------------------------------------------------------
+ desc("Qt for Windows CE only:\n\n");
+ desc("IWMMXT", "no", "-no-iwmmxt", "Do not compile with use of IWMMXT instructions");
+ desc("IWMMXT", "yes", "-iwmmxt", "Do compile with use of IWMMXT instructions (Qt for Windows CE on Arm only)");
+ desc("CE_CRT", "no", "-no-crt" , "Do not add the C runtime to default deployment rules");
+ desc("CE_CRT", "yes", "-qt-crt", "Qt identifies C runtime during project generation");
+ desc( "-crt <path>", "Specify path to C runtime used for project generation.");
+ desc("CETEST", "no", "-no-cetest", "Do not compile Windows CE remote test application");
+ desc("CETEST", "yes", "-cetest", "Compile Windows CE remote test application");
+ desc( "-signature <file>", "Use file for signing the target project");
+ desc("OPENGL_ES_CM", "no", "-opengl-es-cm", "Enable support for OpenGL ES Common");
+ desc("OPENGL_ES_CL", "no", "-opengl-es-cl", "Enable support for OpenGL ES Common Lite");
+ desc("DIRECTSHOW", "no", "-phonon-wince-ds9", "Enable Phonon Direct Show 9 backend for Windows CE");
+
+ return true;
+ }
+ return false;
+}
+
+bool Configure::findFileInPaths(const QString &fileName, const QStringList &paths)
+{
+ QDir d;
+ for( QStringList::ConstIterator it = paths.begin(); it != paths.end(); ++it ) {
+ // Remove any leading or trailing ", this is commonly used in the environment
+ // variables
+ QString path = (*it);
+ if ( path.startsWith( "\"" ) )
+ path = path.right( path.length() - 1 );
+ if ( path.endsWith( "\"" ) )
+ path = path.left( path.length() - 1 );
+ if( d.exists( path + QDir::separator() + fileName ) )
+ return true;
+ }
+ return false;
+}
+
+bool Configure::findFile( const QString &fileName )
+{
+ QString file = fileName.toLower();
+ QStringList paths;
+#if defined(Q_OS_WIN32)
+ QRegExp splitReg("[;,]");
+#else
+ QRegExp splitReg("[:]");
+#endif
+ if (file.endsWith(".h"))
+ paths = QString::fromLocal8Bit(getenv("INCLUDE")).split(splitReg, QString::SkipEmptyParts);
+ else if ( file.endsWith( ".lib" ) )
+ paths = QString::fromLocal8Bit(getenv("LIB")).split(splitReg, QString::SkipEmptyParts);
+ else
+ paths = QString::fromLocal8Bit(getenv("PATH")).split(splitReg, QString::SkipEmptyParts);
+ return findFileInPaths(file, paths);
+}
+
+/*!
+ Default value for options marked as "auto" if the test passes.
+ (Used both by the autoDetection() below, and the desc() function
+ to mark (+) the default option of autodetecting options.
+*/
+QString Configure::defaultTo(const QString &option)
+{
+ // We prefer using the system version of the 3rd party libs
+ if (option == "ZLIB"
+ || option == "LIBJPEG"
+ || option == "LIBPNG"
+ || option == "LIBMNG"
+ || option == "LIBTIFF")
+ return "system";
+
+ // We want PNG built-in
+ if (option == "PNG")
+ return "qt";
+
+ // The JPEG image library can only be a plugin
+ if (option == "JPEG"
+ || option == "MNG" || option == "TIFF")
+ return "plugin";
+
+ // GIF off by default
+ if (option == "GIF") {
+ if (dictionary["SHARED"] == "yes")
+ return "plugin";
+ else
+ return "yes";
+ }
+
+ // By default we do not want to compile OCI driver when compiling with
+ // MinGW, due to lack of such support from Oracle. It prob. wont work.
+ // (Customer may force the use though)
+ if (dictionary["QMAKESPEC"].endsWith("-g++")
+ && option == "SQL_OCI")
+ return "no";
+
+ if (option == "SQL_MYSQL"
+ || option == "SQL_MYSQL"
+ || option == "SQL_ODBC"
+ || option == "SQL_OCI"
+ || option == "SQL_PSQL"
+ || option == "SQL_TDS"
+ || option == "SQL_DB2"
+ || option == "SQL_SQLITE"
+ || option == "SQL_SQLITE2"
+ || option == "SQL_IBASE")
+ return "plugin";
+
+ if (option == "SYNCQT"
+ && (!QFile::exists(sourcePath + "/bin/syncqt") ||
+ !QFile::exists(sourcePath + "/bin/syncqt.bat")))
+ return "no";
+
+ return "yes";
+}
+
+/*!
+ Checks the system for the availability of a feature.
+ Returns true if the feature is available, else false.
+*/
+bool Configure::checkAvailability(const QString &part)
+{
+ bool available = false;
+ if (part == "STYLE_WINDOWSXP")
+ available = (dictionary.value("QMAKESPEC") == "win32-g++" || findFile("uxtheme.h"));
+
+ else if (part == "ZLIB")
+ available = findFile("zlib.h");
+
+ else if (part == "LIBJPEG")
+ available = findFile("jpeglib.h");
+ else if (part == "LIBPNG")
+ available = findFile("png.h");
+ else if (part == "LIBMNG")
+ available = findFile("libmng.h");
+ else if (part == "LIBTIFF")
+ available = findFile("tiffio.h");
+ else if (part == "SQL_MYSQL")
+ available = findFile("mysql.h") && findFile("libmySQL.lib");
+ else if (part == "SQL_ODBC")
+ available = findFile("sql.h") && findFile("sqlext.h") && findFile("odbc32.lib");
+ else if (part == "SQL_OCI")
+ available = findFile("oci.h") && findFile("oci.lib");
+ else if (part == "SQL_PSQL")
+ available = findFile("libpq-fe.h") && findFile("libpq.lib") && findFile("ws2_32.lib") && findFile("advapi32.lib");
+ else if (part == "SQL_TDS")
+ available = findFile("sybfront.h") && findFile("sybdb.h") && findFile("ntwdblib.lib");
+ else if (part == "SQL_DB2")
+ available = findFile("sqlcli.h") && findFile("sqlcli1.h") && findFile("db2cli.lib");
+ else if (part == "SQL_SQLITE")
+ available = true; // Built in, we have a fork
+ else if (part == "SQL_SQLITE_LIB") {
+ if (dictionary[ "SQL_SQLITE_LIB" ] == "system") {
+ available = findFile("sqlite3.h") && findFile("sqlite3.lib");
+ if (available)
+ dictionary[ "QT_LFLAGS_SQLITE" ] += "sqlite3.lib";
+ } else
+ available = true;
+ } else if (part == "SQL_SQLITE2")
+ available = findFile("sqlite.h") && findFile("sqlite.lib");
+ else if (part == "SQL_IBASE")
+ available = findFile("ibase.h") && (findFile("gds32_ms.lib") || findFile("gds32.lib"));
+ else if (part == "IWMMXT")
+ available = (dictionary[ "ARCHITECTURE" ] == "windowsce");
+ else if (part == "OPENGL_ES_CM")
+ available = (dictionary[ "ARCHITECTURE" ] == "windowsce");
+ else if (part == "OPENGL_ES_CL")
+ available = (dictionary[ "ARCHITECTURE" ] == "windowsce");
+ else if (part == "DIRECTSHOW")
+ available = (dictionary[ "ARCHITECTURE" ] == "windowsce");
+ else if (part == "SSE2")
+ available = (dictionary.value("QMAKESPEC") != "win32-msvc") && (dictionary.value("QMAKESPEC") != "win32-g++");
+ else if (part == "3DNOW" )
+ available = (dictionary.value("QMAKESPEC") != "win32-msvc") && (dictionary.value("QMAKESPEC") != "win32-icc") && findFile("mm3dnow.h") && (dictionary.value("QMAKESPEC") != "win32-g++");
+ else if (part == "MMX" || part == "SSE")
+ available = (dictionary.value("QMAKESPEC") != "win32-msvc") && (dictionary.value("QMAKESPEC") != "win32-g++");
+ else if (part == "OPENSSL")
+ available = findFile("openssl\\ssl.h");
+ else if (part == "DBUS")
+ available = findFile("dbus\\dbus.h");
+ else if (part == "CETEST") {
+ QString rapiHeader = locateFile("rapi.h");
+ QString rapiLib = locateFile("rapi.lib");
+ available = (dictionary[ "ARCHITECTURE" ] == "windowsce") && !rapiHeader.isEmpty() && !rapiLib.isEmpty();
+ if (available) {
+ dictionary[ "QT_CE_RAPI_INC" ] += QLatin1String("\"") + rapiHeader + QLatin1String("\"");
+ dictionary[ "QT_CE_RAPI_LIB" ] += QLatin1String("\"") + rapiLib + QLatin1String("\"");
+ }
+ }
+ else if (part == "INCREDIBUILD_XGE")
+ available = findFile("BuildConsole.exe") && findFile("xgConsole.exe");
+ else if (part == "XMLPATTERNS")
+ {
+ /* MSVC 6.0 and MSVC 2002/7.0 has too poor C++ support for QtXmlPatterns. */
+ return dictionary.value("QMAKESPEC") != "win32-msvc"
+ && dictionary.value("QMAKESPEC") != "win32-msvc.net" // Leave for now, since we can't be sure if they are using 2002 or 2003 with this spec
+ && dictionary.value("QMAKESPEC") != "win32-msvc2002"
+ && dictionary.value("EXCEPTIONS") == "yes";
+ } else if (part == "DIRECT3D") {
+ QString sdk_dir(QString::fromLocal8Bit(getenv("DXSDK_DIR")));
+ QDir dir;
+ bool has_d3d = false;
+
+ if (!sdk_dir.isEmpty() && dir.exists(sdk_dir))
+ has_d3d = true;
+
+ if (has_d3d && !QFile::exists(sdk_dir + QLatin1String("\\include\\d3d9.h"))) {
+ cout << "No Direct3D version 9 SDK found." << endl;
+ has_d3d = false;
+ }
+
+ // find the first dxguid.lib in the current LIB paths, if it is NOT
+ // the D3D SDK one, we're most likely in trouble..
+ if (has_d3d) {
+ has_d3d = false;
+ QString env_lib(QString::fromLocal8Bit(getenv("LIB")));
+ QStringList lib_paths = env_lib.split(';');
+ for (int i=0; i<lib_paths.size(); ++i) {
+ QString lib_path = lib_paths.at(i);
+ if (QFile::exists(lib_path + QLatin1String("\\dxguid.lib")))
+ {
+ if (lib_path.startsWith(sdk_dir)) {
+ has_d3d = true;
+ } else {
+ cout << "Your D3D/Platform SDK library paths seem to appear in the wrong order." << endl;
+ }
+ break;
+ }
+ }
+ }
+
+ available = has_d3d;
+ if (!has_d3d) {
+ cout << "Setting Direct3D to NO, since the proper Direct3D SDK was not detected." << endl
+ << "Make sure you have the Direct3D SDK installed, and that you have run" << endl
+ << "the <path to SDK>\\Utilities\\Bin\\dx_setenv.cmd script." << endl
+ << "The D3D SDK library path *needs* to appear before the Platform SDK library" << endl
+ << "path in your LIB environment variable." << endl;
+ }
+ } else if (part == "PHONON") {
+ available = findFile("vmr9.h") && findFile("dshow.h") && findFile("strmiids.lib") &&
+ findFile("dmoguids.lib") && findFile("msdmo.lib") && findFile("d3d9.h");
+
+ if (!available) {
+ cout << "All the required DirectShow/Direct3D files couldn't be found." << endl
+ << "Make sure you have either the platform SDK AND the DirectX SDK or the Windows SDK installed." << endl
+ << "If you have the DirectX SDK installed, please make sure that you have run the <path to SDK>\\SetEnv.Cmd script." << endl;
+ }
+ } else if (part == "WEBKIT") {
+ available = (dictionary.value("QMAKESPEC") == "win32-msvc2005") || (dictionary.value("QMAKESPEC") == "win32-msvc2008") || (dictionary.value("QMAKESPEC") == "win32-g++");
+ } else if (part == "SCRIPTTOOLS") {
+ available = true;
+ }
+
+ return available;
+}
+
+/*
+ Autodetect options marked as "auto".
+*/
+void Configure::autoDetection()
+{
+ // Style detection
+ if (dictionary["STYLE_WINDOWSXP"] == "auto")
+ dictionary["STYLE_WINDOWSXP"] = checkAvailability("STYLE_WINDOWSXP") ? defaultTo("STYLE_WINDOWSXP") : "no";
+ if (dictionary["STYLE_WINDOWSVISTA"] == "auto") // Vista style has the same requirements as XP style
+ dictionary["STYLE_WINDOWSVISTA"] = checkAvailability("STYLE_WINDOWSXP") ? defaultTo("STYLE_WINDOWSVISTA") : "no";
+
+ // Compression detection
+ if (dictionary["ZLIB"] == "auto")
+ dictionary["ZLIB"] = checkAvailability("ZLIB") ? defaultTo("ZLIB") : "qt";
+
+ // Image format detection
+ if (dictionary["GIF"] == "auto")
+ dictionary["GIF"] = defaultTo("GIF");
+ if (dictionary["JPEG"] == "auto")
+ dictionary["JPEG"] = defaultTo("JPEG");
+ if (dictionary["PNG"] == "auto")
+ dictionary["PNG"] = defaultTo("PNG");
+ if (dictionary["MNG"] == "auto")
+ dictionary["MNG"] = defaultTo("MNG");
+ if (dictionary["TIFF"] == "auto")
+ dictionary["TIFF"] = dictionary["ZLIB"] == "no" ? "no" : defaultTo("TIFF");
+ if (dictionary["LIBJPEG"] == "auto")
+ dictionary["LIBJPEG"] = checkAvailability("LIBJPEG") ? defaultTo("LIBJPEG") : "qt";
+ if (dictionary["LIBPNG"] == "auto")
+ dictionary["LIBPNG"] = checkAvailability("LIBPNG") ? defaultTo("LIBPNG") : "qt";
+ if (dictionary["LIBMNG"] == "auto")
+ dictionary["LIBMNG"] = checkAvailability("LIBMNG") ? defaultTo("LIBMNG") : "qt";
+ if (dictionary["LIBTIFF"] == "auto")
+ dictionary["LIBTIFF"] = checkAvailability("LIBTIFF") ? defaultTo("LIBTIFF") : "qt";
+
+ // SQL detection (not on by default)
+ if (dictionary["SQL_MYSQL"] == "auto")
+ dictionary["SQL_MYSQL"] = checkAvailability("SQL_MYSQL") ? defaultTo("SQL_MYSQL") : "no";
+ if (dictionary["SQL_ODBC"] == "auto")
+ dictionary["SQL_ODBC"] = checkAvailability("SQL_ODBC") ? defaultTo("SQL_ODBC") : "no";
+ if (dictionary["SQL_OCI"] == "auto")
+ dictionary["SQL_OCI"] = checkAvailability("SQL_OCI") ? defaultTo("SQL_OCI") : "no";
+ if (dictionary["SQL_PSQL"] == "auto")
+ dictionary["SQL_PSQL"] = checkAvailability("SQL_PSQL") ? defaultTo("SQL_PSQL") : "no";
+ if (dictionary["SQL_TDS"] == "auto")
+ dictionary["SQL_TDS"] = checkAvailability("SQL_TDS") ? defaultTo("SQL_TDS") : "no";
+ if (dictionary["SQL_DB2"] == "auto")
+ dictionary["SQL_DB2"] = checkAvailability("SQL_DB2") ? defaultTo("SQL_DB2") : "no";
+ if (dictionary["SQL_SQLITE"] == "auto")
+ dictionary["SQL_SQLITE"] = checkAvailability("SQL_SQLITE") ? defaultTo("SQL_SQLITE") : "no";
+ if (dictionary["SQL_SQLITE_LIB"] == "system")
+ if (!checkAvailability("SQL_SQLITE_LIB"))
+ dictionary["SQL_SQLITE_LIB"] = "no";
+ if (dictionary["SQL_SQLITE2"] == "auto")
+ dictionary["SQL_SQLITE2"] = checkAvailability("SQL_SQLITE2") ? defaultTo("SQL_SQLITE2") : "no";
+ if (dictionary["SQL_IBASE"] == "auto")
+ dictionary["SQL_IBASE"] = checkAvailability("SQL_IBASE") ? defaultTo("SQL_IBASE") : "no";
+ if (dictionary["MMX"] == "auto")
+ dictionary["MMX"] = checkAvailability("MMX") ? "yes" : "no";
+ if (dictionary["3DNOW"] == "auto")
+ dictionary["3DNOW"] = checkAvailability("3DNOW") ? "yes" : "no";
+ if (dictionary["SSE"] == "auto")
+ dictionary["SSE"] = checkAvailability("SSE") ? "yes" : "no";
+ if (dictionary["SSE2"] == "auto")
+ dictionary["SSE2"] = checkAvailability("SSE2") ? "yes" : "no";
+ if (dictionary["IWMMXT"] == "auto")
+ dictionary["IWMMXT"] = checkAvailability("IWMMXT") ? "yes" : "no";
+ if (dictionary["OPENSSL"] == "auto")
+ dictionary["OPENSSL"] = checkAvailability("OPENSSL") ? "yes" : "no";
+ if (dictionary["DBUS"] == "auto")
+ dictionary["DBUS"] = checkAvailability("DBUS") ? "yes" : "no";
+ if (dictionary["SCRIPTTOOLS"] == "auto")
+ dictionary["SCRIPTTOOLS"] = checkAvailability("SCRIPTTOOLS") ? "yes" : "no";
+ if (dictionary["XMLPATTERNS"] == "auto")
+ dictionary["XMLPATTERNS"] = checkAvailability("XMLPATTERNS") ? "yes" : "no";
+ if (dictionary["DIRECT3D"] == "auto")
+ dictionary["DIRECT3D"] = checkAvailability("DIRECT3D") ? "yes" : "no";
+ if (dictionary["PHONON"] == "auto")
+ dictionary["PHONON"] = checkAvailability("PHONON") ? "yes" : "no";
+ if (dictionary["WEBKIT"] == "auto")
+ dictionary["WEBKIT"] = checkAvailability("WEBKIT") ? "yes" : "no";
+
+ // Qt/WinCE remote test application
+ if (dictionary["CETEST"] == "auto")
+ dictionary["CETEST"] = checkAvailability("CETEST") ? "yes" : "no";
+
+ // Detection of IncrediBuild buildconsole
+ if (dictionary["INCREDIBUILD_XGE"] == "auto")
+ dictionary["INCREDIBUILD_XGE"] = checkAvailability("INCREDIBUILD_XGE") ? "yes" : "no";
+
+ // Mark all unknown "auto" to the default value..
+ for (QMap<QString,QString>::iterator i = dictionary.begin(); i != dictionary.end(); ++i) {
+ if (i.value() == "auto")
+ i.value() = defaultTo(i.key());
+ }
+}
+
+bool Configure::verifyConfiguration()
+{
+ if (dictionary["SQL_SQLITE_LIB"] == "no" && dictionary["SQL_SQLITE"] != "no") {
+ cout << "WARNING: Configure could not detect the presence of a system SQLite3 lib." << endl
+ << "Configure will therefore continue with the SQLite3 lib bundled with Qt." << endl
+ << "(Press any key to continue..)";
+ if(_getch() == 3) // _Any_ keypress w/no echo(eat <Enter> for stdout)
+ exit(0); // Exit cleanly for Ctrl+C
+
+ dictionary["SQL_SQLITE_LIB"] = "qt"; // Set to Qt's bundled lib an continue
+ }
+ if (dictionary["QMAKESPEC"].endsWith("-g++")
+ && dictionary["SQL_OCI"] != "no") {
+ cout << "WARNING: Qt does not support compiling the Oracle database driver with" << endl
+ << "MinGW, due to lack of such support from Oracle. Consider disabling the" << endl
+ << "Oracle driver, as the current build will most likely fail." << endl;
+ cout << "(Press any key to continue..)";
+ if(_getch() == 3) // _Any_ keypress w/no echo(eat <Enter> for stdout)
+ exit(0); // Exit cleanly for Ctrl+C
+ }
+ if (dictionary["QMAKESPEC"].endsWith("win32-msvc.net")) {
+ cout << "WARNING: The makespec win32-msvc.net is deprecated. Consider using" << endl
+ << "win32-msvc2002 or win32-msvc2003 instead." << endl;
+ cout << "(Press any key to continue..)";
+ if(_getch() == 3) // _Any_ keypress w/no echo(eat <Enter> for stdout)
+ exit(0); // Exit cleanly for Ctrl+C
+ }
+
+ return true;
+}
+
+/*
+ Things that affect the Qt API/ABI:
+ Options:
+ minimal-config small-config medium-config large-config full-config
+
+ Options:
+ debug release
+ stl
+
+ Things that do not affect the Qt API/ABI:
+ system-jpeg no-jpeg jpeg
+ system-mng no-mng mng
+ system-png no-png png
+ system-zlib no-zlib zlib
+ system-tiff no-tiff tiff
+ no-gif gif
+ dll staticlib
+
+ internal
+ nocrosscompiler
+ GNUmake
+ largefile
+ nis
+ nas
+ tablet
+ ipv6
+
+ X11 : x11sm xinerama xcursor xfixes xrandr xrender fontconfig xkb
+ Embedded: embedded freetype
+*/
+void Configure::generateBuildKey()
+{
+ QString spec = dictionary["QMAKESPEC"];
+
+ QString compiler = "msvc"; // ICC is compatible
+ if (spec.endsWith("-g++"))
+ compiler = "mingw";
+ else if (spec.endsWith("-borland"))
+ compiler = "borland";
+
+ // Build options which changes the Qt API/ABI
+ QStringList build_options;
+ if (!dictionary["QCONFIG"].isEmpty())
+ build_options += dictionary["QCONFIG"] + "-config ";
+ if (dictionary["STL"] == "no")
+ build_options += "no-stl";
+ build_options.sort();
+
+ // Sorted defines that start with QT_NO_
+ QStringList build_defines = qmakeDefines.filter(QRegExp("^QT_NO_"));
+ build_defines.sort();
+
+ // Build up the QT_BUILD_KEY ifdef
+ QString buildKey = "QT_BUILD_KEY \"";
+ if (!dictionary["USER_BUILD_KEY"].isEmpty())
+ buildKey += dictionary["USER_BUILD_KEY"] + " ";
+
+ QString build32Key = buildKey + "Windows " + compiler + " %1 " + build_options.join(" ") + " " + build_defines.join(" ");
+ QString build64Key = buildKey + "Windows x64 " + compiler + " %1 " + build_options.join(" ") + " " + build_defines.join(" ");
+ build32Key = build32Key.simplified();
+ build64Key = build64Key.simplified();
+ build32Key.prepend("# define ");
+ build64Key.prepend("# define ");
+
+ QString buildkey = // Debug builds
+ "#if (defined(_DEBUG) || defined(DEBUG))\n"
+ "# if (defined(WIN64) || defined(_WIN64) || defined(__WIN64__))\n"
+ + build64Key.arg("debug") + "\"\n"
+ "# else\n"
+ + build32Key.arg("debug") + "\"\n"
+ "# endif\n"
+ "#else\n"
+ // Release builds
+ "# if (defined(WIN64) || defined(_WIN64) || defined(__WIN64__))\n"
+ + build64Key.arg("release") + "\"\n"
+ "# else\n"
+ + build32Key.arg("release") + "\"\n"
+ "# endif\n"
+ "#endif\n";
+
+ dictionary["BUILD_KEY"] = buildkey;
+}
+
+void Configure::generateOutputVars()
+{
+ // Generate variables for output
+ // Build key ----------------------------------------------------
+ if ( dictionary.contains("BUILD_KEY") ) {
+ qmakeVars += dictionary.value("BUILD_KEY");
+ }
+
+ QString build = dictionary[ "BUILD" ];
+ bool buildAll = (dictionary[ "BUILDALL" ] == "yes");
+ if ( build == "debug") {
+ if (buildAll)
+ qtConfig += "release";
+ qtConfig += "debug";
+ } else if (build == "release") {
+ if (buildAll)
+ qtConfig += "debug";
+ qtConfig += "release";
+ }
+
+ // Compression --------------------------------------------------
+ if( dictionary[ "ZLIB" ] == "qt" )
+ qtConfig += "zlib";
+ else if( dictionary[ "ZLIB" ] == "system" )
+ qtConfig += "system-zlib";
+
+ // Image formates -----------------------------------------------
+ if( dictionary[ "GIF" ] == "no" )
+ qtConfig += "no-gif";
+ else if( dictionary[ "GIF" ] == "yes" )
+ qtConfig += "gif";
+ else if( dictionary[ "GIF" ] == "plugin" )
+ qmakeFormatPlugins += "gif";
+
+ if( dictionary[ "TIFF" ] == "no" )
+ qtConfig += "no-tiff";
+ else if( dictionary[ "TIFF" ] == "plugin" )
+ qmakeFormatPlugins += "tiff";
+ if( dictionary[ "LIBTIFF" ] == "system" )
+ qtConfig += "system-tiff";
+
+ if( dictionary[ "JPEG" ] == "no" )
+ qtConfig += "no-jpeg";
+ else if( dictionary[ "JPEG" ] == "plugin" )
+ qmakeFormatPlugins += "jpeg";
+ if( dictionary[ "LIBJPEG" ] == "system" )
+ qtConfig += "system-jpeg";
+
+ if( dictionary[ "PNG" ] == "no" )
+ qtConfig += "no-png";
+ else if( dictionary[ "PNG" ] == "qt" )
+ qtConfig += "png";
+ if( dictionary[ "LIBPNG" ] == "system" )
+ qtConfig += "system-png";
+
+ if( dictionary[ "MNG" ] == "no" )
+ qtConfig += "no-mng";
+ else if( dictionary[ "MNG" ] == "qt" )
+ qtConfig += "mng";
+ if( dictionary[ "LIBMNG" ] == "system" )
+ qtConfig += "system-mng";
+
+ // Styles -------------------------------------------------------
+ if ( dictionary[ "STYLE_WINDOWS" ] == "yes" )
+ qmakeStyles += "windows";
+
+ if ( dictionary[ "STYLE_PLASTIQUE" ] == "yes" )
+ qmakeStyles += "plastique";
+
+ if ( dictionary[ "STYLE_CLEANLOOKS" ] == "yes" )
+ qmakeStyles += "cleanlooks";
+
+ if ( dictionary[ "STYLE_WINDOWSXP" ] == "yes" )
+ qmakeStyles += "windowsxp";
+
+ if ( dictionary[ "STYLE_WINDOWSVISTA" ] == "yes" )
+ qmakeStyles += "windowsvista";
+
+ if ( dictionary[ "STYLE_MOTIF" ] == "yes" )
+ qmakeStyles += "motif";
+
+ if ( dictionary[ "STYLE_SGI" ] == "yes" )
+ qmakeStyles += "sgi";
+
+ if ( dictionary[ "STYLE_WINDOWSCE" ] == "yes" )
+ qmakeStyles += "windowsce";
+
+ if ( dictionary[ "STYLE_WINDOWSMOBILE" ] == "yes" )
+ qmakeStyles += "windowsmobile";
+
+ if ( dictionary[ "STYLE_CDE" ] == "yes" )
+ qmakeStyles += "cde";
+
+ // Databases ----------------------------------------------------
+ if ( dictionary[ "SQL_MYSQL" ] == "yes" )
+ qmakeSql += "mysql";
+ else if ( dictionary[ "SQL_MYSQL" ] == "plugin" )
+ qmakeSqlPlugins += "mysql";
+
+ if ( dictionary[ "SQL_ODBC" ] == "yes" )
+ qmakeSql += "odbc";
+ else if ( dictionary[ "SQL_ODBC" ] == "plugin" )
+ qmakeSqlPlugins += "odbc";
+
+ if ( dictionary[ "SQL_OCI" ] == "yes" )
+ qmakeSql += "oci";
+ else if ( dictionary[ "SQL_OCI" ] == "plugin" )
+ qmakeSqlPlugins += "oci";
+
+ if ( dictionary[ "SQL_PSQL" ] == "yes" )
+ qmakeSql += "psql";
+ else if ( dictionary[ "SQL_PSQL" ] == "plugin" )
+ qmakeSqlPlugins += "psql";
+
+ if ( dictionary[ "SQL_TDS" ] == "yes" )
+ qmakeSql += "tds";
+ else if ( dictionary[ "SQL_TDS" ] == "plugin" )
+ qmakeSqlPlugins += "tds";
+
+ if ( dictionary[ "SQL_DB2" ] == "yes" )
+ qmakeSql += "db2";
+ else if ( dictionary[ "SQL_DB2" ] == "plugin" )
+ qmakeSqlPlugins += "db2";
+
+ if ( dictionary[ "SQL_SQLITE" ] == "yes" )
+ qmakeSql += "sqlite";
+ else if ( dictionary[ "SQL_SQLITE" ] == "plugin" )
+ qmakeSqlPlugins += "sqlite";
+
+ if ( dictionary[ "SQL_SQLITE_LIB" ] == "system" )
+ qmakeConfig += "system-sqlite";
+
+ if ( dictionary[ "SQL_SQLITE2" ] == "yes" )
+ qmakeSql += "sqlite2";
+ else if ( dictionary[ "SQL_SQLITE2" ] == "plugin" )
+ qmakeSqlPlugins += "sqlite2";
+
+ if ( dictionary[ "SQL_IBASE" ] == "yes" )
+ qmakeSql += "ibase";
+ else if ( dictionary[ "SQL_IBASE" ] == "plugin" )
+ qmakeSqlPlugins += "ibase";
+
+ // Other options ------------------------------------------------
+ if( dictionary[ "BUILDALL" ] == "yes" ) {
+ qmakeConfig += "build_all";
+ }
+ qmakeConfig += dictionary[ "BUILD" ];
+ dictionary[ "QMAKE_OUTDIR" ] = dictionary[ "BUILD" ];
+
+ if ( dictionary[ "SHARED" ] == "yes" ) {
+ QString version = dictionary[ "VERSION" ];
+ if (!version.isEmpty()) {
+ qmakeVars += "QMAKE_QT_VERSION_OVERRIDE = " + version.left(version.indexOf("."));
+ version.remove(QLatin1Char('.'));
+ }
+ dictionary[ "QMAKE_OUTDIR" ] += "_shared";
+ } else {
+ dictionary[ "QMAKE_OUTDIR" ] += "_static";
+ }
+
+ if( dictionary[ "ACCESSIBILITY" ] == "yes" )
+ qtConfig += "accessibility";
+
+ if( !qmakeLibs.isEmpty() )
+ qmakeVars += "LIBS += " + qmakeLibs.join( " " );
+
+ if( !dictionary["QT_LFLAGS_SQLITE"].isEmpty() )
+ qmakeVars += "QT_LFLAGS_SQLITE += " + dictionary["QT_LFLAGS_SQLITE"];
+
+ if (dictionary[ "QT3SUPPORT" ] == "yes")
+ qtConfig += "qt3support";
+
+ if (dictionary[ "OPENGL" ] == "yes")
+ qtConfig += "opengl";
+
+ if ( dictionary["OPENGL_ES_CM"] == "yes" ) {
+ qtConfig += "opengles1";
+ }
+
+ if ( dictionary["OPENGL_ES_CL"] == "yes" ) {
+ qtConfig += "opengles1cl";
+ }
+
+ if ( dictionary["DIRECTSHOW"] == "yes" )
+ qtConfig += "directshow";
+
+ if (dictionary[ "DIRECT3D" ] == "yes")
+ qtConfig += "direct3d";
+
+ if (dictionary[ "OPENSSL" ] == "yes")
+ qtConfig += "openssl";
+ else if (dictionary[ "OPENSSL" ] == "linked")
+ qtConfig += "openssl-linked";
+
+ if (dictionary[ "DBUS" ] == "yes")
+ qtConfig += "dbus";
+ else if (dictionary[ "DBUS" ] == "linked")
+ qtConfig += "dbus dbus-linked";
+
+ if (dictionary["IPV6"] == "yes")
+ qtConfig += "ipv6";
+ else if (dictionary["IPV6"] == "no")
+ qtConfig += "no-ipv6";
+
+ if (dictionary[ "CETEST" ] == "yes")
+ qtConfig += "cetest";
+
+ if (dictionary[ "SCRIPTTOOLS" ] == "yes")
+ qtConfig += "scripttools";
+
+ if (dictionary[ "XMLPATTERNS" ] == "yes")
+ qtConfig += "xmlpatterns";
+
+ if (dictionary["PHONON"] == "yes") {
+ qtConfig += "phonon";
+ if (dictionary["PHONON_BACKEND"] == "yes")
+ qtConfig += "phonon-backend";
+ }
+
+ if (dictionary["WEBKIT"] == "yes")
+ qtConfig += "webkit";
+
+ // We currently have no switch for QtSvg, so add it unconditionally.
+ qtConfig += "svg";
+
+ // Add config levels --------------------------------------------
+ QStringList possible_configs = QStringList()
+ << "minimal"
+ << "small"
+ << "medium"
+ << "large"
+ << "full";
+
+ QString set_config = dictionary["QCONFIG"];
+ if (possible_configs.contains(set_config)) {
+ foreach(QString cfg, possible_configs) {
+ qtConfig += (cfg + "-config");
+ if (cfg == set_config)
+ break;
+ }
+ }
+
+ // Directories and settings for .qmake.cache --------------------
+
+ // if QT_INSTALL_* have not been specified on commandline, define them now from QT_INSTALL_PREFIX
+ // if prefix is empty (WINCE), make all of them empty, if they aren't set
+ bool qipempty = false;
+ if(dictionary[ "QT_INSTALL_PREFIX" ].isEmpty())
+ qipempty = true;
+
+ if( !dictionary[ "QT_INSTALL_DOCS" ].size() )
+ dictionary[ "QT_INSTALL_DOCS" ] = qipempty ? "" : fixSeparators( dictionary[ "QT_INSTALL_PREFIX" ] + "/doc" );
+ if( !dictionary[ "QT_INSTALL_HEADERS" ].size() )
+ dictionary[ "QT_INSTALL_HEADERS" ] = qipempty ? "" : fixSeparators( dictionary[ "QT_INSTALL_PREFIX" ] + "/include" );
+ if( !dictionary[ "QT_INSTALL_LIBS" ].size() )
+ dictionary[ "QT_INSTALL_LIBS" ] = qipempty ? "" : fixSeparators( dictionary[ "QT_INSTALL_PREFIX" ] + "/lib" );
+ if( !dictionary[ "QT_INSTALL_BINS" ].size() )
+ dictionary[ "QT_INSTALL_BINS" ] = qipempty ? "" : fixSeparators( dictionary[ "QT_INSTALL_PREFIX" ] + "/bin" );
+ if( !dictionary[ "QT_INSTALL_PLUGINS" ].size() )
+ dictionary[ "QT_INSTALL_PLUGINS" ] = qipempty ? "" : fixSeparators( dictionary[ "QT_INSTALL_PREFIX" ] + "/plugins" );
+ if( !dictionary[ "QT_INSTALL_DATA" ].size() )
+ dictionary[ "QT_INSTALL_DATA" ] = qipempty ? "" : fixSeparators( dictionary[ "QT_INSTALL_PREFIX" ] );
+ if( !dictionary[ "QT_INSTALL_TRANSLATIONS" ].size() )
+ dictionary[ "QT_INSTALL_TRANSLATIONS" ] = qipempty ? "" : fixSeparators( dictionary[ "QT_INSTALL_PREFIX" ] + "/translations" );
+ if( !dictionary[ "QT_INSTALL_EXAMPLES" ].size() )
+ dictionary[ "QT_INSTALL_EXAMPLES" ] = qipempty ? "" : fixSeparators( dictionary[ "QT_INSTALL_PREFIX" ] + "/examples");
+ if( !dictionary[ "QT_INSTALL_DEMOS" ].size() )
+ dictionary[ "QT_INSTALL_DEMOS" ] = qipempty ? "" : fixSeparators( dictionary[ "QT_INSTALL_PREFIX" ] + "/demos" );
+
+ if(dictionary.contains("XQMAKESPEC") && dictionary[ "XQMAKESPEC" ].startsWith("linux"))
+ dictionary[ "QMAKE_RPATHDIR" ] = dictionary[ "QT_INSTALL_LIBS" ];
+
+ qmakeVars += QString("OBJECTS_DIR = ") + fixSeparators( "tmp/obj/" + dictionary[ "QMAKE_OUTDIR" ] );
+ qmakeVars += QString("MOC_DIR = ") + fixSeparators( "tmp/moc/" + dictionary[ "QMAKE_OUTDIR" ] );
+ qmakeVars += QString("RCC_DIR = ") + fixSeparators("tmp/rcc/" + dictionary["QMAKE_OUTDIR"]);
+
+ if (!qmakeDefines.isEmpty())
+ qmakeVars += QString("DEFINES += ") + qmakeDefines.join( " " );
+ if (!qmakeIncludes.isEmpty())
+ qmakeVars += QString("INCLUDEPATH += ") + qmakeIncludes.join( " " );
+ if (!opensslLibs.isEmpty())
+ qmakeVars += opensslLibs;
+ else if (dictionary[ "OPENSSL" ] == "linked")
+ qmakeVars += QString("OPENSSL_LIBS = -lssleay32 -llibeay32");
+ if (!qmakeSql.isEmpty())
+ qmakeVars += QString("sql-drivers += ") + qmakeSql.join( " " );
+ if (!qmakeSqlPlugins.isEmpty())
+ qmakeVars += QString("sql-plugins += ") + qmakeSqlPlugins.join( " " );
+ if (!qmakeStyles.isEmpty())
+ qmakeVars += QString("styles += ") + qmakeStyles.join( " " );
+ if (!qmakeStylePlugins.isEmpty())
+ qmakeVars += QString("style-plugins += ") + qmakeStylePlugins.join( " " );
+ if (!qmakeFormatPlugins.isEmpty())
+ qmakeVars += QString("imageformat-plugins += ") + qmakeFormatPlugins.join( " " );
+
+ if (dictionary["QMAKESPEC"].endsWith("-g++")) {
+ QString includepath = qgetenv("INCLUDE");
+ bool hasSh = Environment::detectExecutable("sh.exe");
+ QChar separator = (!includepath.contains(":\\") && hasSh ? QChar(':') : QChar(';'));
+ qmakeVars += QString("TMPPATH = $$quote($$(INCLUDE))");
+ qmakeVars += QString("QMAKE_INCDIR_POST += $$split(TMPPATH,\"%1\")").arg(separator);
+ qmakeVars += QString("TMPPATH = $$quote($$(LIB))");
+ qmakeVars += QString("QMAKE_LIBDIR_POST += $$split(TMPPATH,\"%1\")").arg(separator);
+ }
+
+ if( !dictionary[ "QMAKESPEC" ].length() ) {
+ cout << "Configure could not detect your compiler. QMAKESPEC must either" << endl
+ << "be defined as an environment variable, or specified as an" << endl
+ << "argument with -platform" << endl;
+ dictionary[ "HELP" ] = "yes";
+
+ QStringList winPlatforms;
+ QDir mkspecsDir( sourcePath + "/mkspecs" );
+ const QFileInfoList &specsList = mkspecsDir.entryInfoList();
+ for(int i = 0; i < specsList.size(); ++i) {
+ const QFileInfo &fi = specsList.at(i);
+ if( fi.fileName().left( 5 ) == "win32" ) {
+ winPlatforms += fi.fileName();
+ }
+ }
+ cout << "Available platforms are: " << qPrintable(winPlatforms.join( ", " )) << endl;
+ dictionary[ "DONE" ] = "error";
+ }
+}
+
+#if !defined(EVAL)
+void Configure::generateCachefile()
+{
+ // Generate .qmake.cache
+ QFile cacheFile( buildPath + "/.qmake.cache" );
+ if( cacheFile.open( QFile::WriteOnly | QFile::Text ) ) { // Truncates any existing file.
+ QTextStream cacheStream( &cacheFile );
+ for( QStringList::Iterator var = qmakeVars.begin(); var != qmakeVars.end(); ++var ) {
+ cacheStream << (*var) << endl;
+ }
+ cacheStream << "CONFIG += " << qmakeConfig.join( " " ) << " incremental create_prl link_prl depend_includepath QTDIR_build" << endl;
+
+ QStringList buildParts;
+ buildParts << "libs" << "tools" << "examples" << "demos" << "docs" << "translations";
+ foreach(QString item, disabledBuildParts) {
+ buildParts.removeAll(item);
+ }
+ cacheStream << "QT_BUILD_PARTS = " << buildParts.join( " " ) << endl;
+
+ QString targetSpec = dictionary.contains("XQMAKESPEC") ? dictionary[ "XQMAKESPEC" ] : dictionary[ "QMAKESPEC" ];
+ QString mkspec_path = fixSeparators(sourcePath + "/mkspecs/" + targetSpec);
+ if(QFile::exists(mkspec_path))
+ cacheStream << "QMAKESPEC = " << mkspec_path << endl;
+ else
+ cacheStream << "QMAKESPEC = " << fixSeparators(targetSpec) << endl;
+ cacheStream << "ARCH = " << fixSeparators(dictionary[ "ARCHITECTURE" ]) << endl;
+ cacheStream << "QT_BUILD_TREE = " << fixSeparators(dictionary[ "QT_BUILD_TREE" ]) << endl;
+ cacheStream << "QT_SOURCE_TREE = " << fixSeparators(dictionary[ "QT_SOURCE_TREE" ]) << endl;
+
+ if (dictionary["QT_EDITION"] != "QT_EDITION_OPENSOURCE")
+ cacheStream << "DEFINES *= QT_EDITION=QT_EDITION_DESKTOP" << endl;
+
+ //so that we can build without an install first (which would be impossible)
+ cacheStream << "QMAKE_MOC = $$QT_BUILD_TREE" << fixSeparators("/bin/moc.exe") << endl;
+ cacheStream << "QMAKE_UIC = $$QT_BUILD_TREE" << fixSeparators("/bin/uic.exe") << endl;
+ cacheStream << "QMAKE_UIC3 = $$QT_BUILD_TREE" << fixSeparators("/bin/uic3.exe") << endl;
+ cacheStream << "QMAKE_RCC = $$QT_BUILD_TREE" << fixSeparators("/bin/rcc.exe") << endl;
+ cacheStream << "QMAKE_DUMPCPP = $$QT_BUILD_TREE" << fixSeparators("/bin/dumpcpp.exe") << endl;
+ cacheStream << "QMAKE_INCDIR_QT = $$QT_BUILD_TREE" << fixSeparators("/include") << endl;
+ cacheStream << "QMAKE_LIBDIR_QT = $$QT_BUILD_TREE" << fixSeparators("/lib") << endl;
+ if (dictionary["CETEST"] == "yes") {
+ cacheStream << "QT_CE_RAPI_INC = " << fixSeparators(dictionary[ "QT_CE_RAPI_INC" ]) << endl;
+ cacheStream << "QT_CE_RAPI_LIB = " << fixSeparators(dictionary[ "QT_CE_RAPI_LIB" ]) << endl;
+ }
+
+ // embedded
+ if( !dictionary["KBD_DRIVERS"].isEmpty())
+ cacheStream << "kbd-drivers += "<< dictionary["KBD_DRIVERS"]<<endl;
+ if( !dictionary["GFX_DRIVERS"].isEmpty())
+ cacheStream << "gfx-drivers += "<< dictionary["GFX_DRIVERS"]<<endl;
+ if( !dictionary["MOUSE_DRIVERS"].isEmpty())
+ cacheStream << "mouse-drivers += "<< dictionary["MOUSE_DRIVERS"]<<endl;
+ if( !dictionary["DECORATIONS"].isEmpty())
+ cacheStream << "decorations += "<<dictionary["DECORATIONS"]<<endl;
+
+ if( !dictionary["QMAKE_RPATHDIR"].isEmpty() )
+ cacheStream << "QMAKE_RPATHDIR += "<<dictionary["QMAKE_RPATHDIR"];
+
+ cacheStream.flush();
+ cacheFile.close();
+ }
+ QFile configFile( dictionary[ "QT_BUILD_TREE" ] + "/mkspecs/qconfig.pri" );
+ if( configFile.open( QFile::WriteOnly | QFile::Text ) ) { // Truncates any existing file.
+ QTextStream configStream( &configFile );
+ configStream << "CONFIG+= ";
+ configStream << dictionary[ "BUILD" ];
+ if( dictionary[ "SHARED" ] == "yes" )
+ configStream << " shared";
+ else
+ configStream << " static";
+
+ if( dictionary[ "STL" ] == "yes" )
+ configStream << " stl";
+ if ( dictionary[ "EXCEPTIONS" ] == "yes" )
+ configStream << " exceptions";
+ if ( dictionary[ "EXCEPTIONS" ] == "no" )
+ configStream << " exceptions_off";
+ if ( dictionary[ "RTTI" ] == "yes" )
+ configStream << " rtti";
+ if ( dictionary[ "MMX" ] == "yes" )
+ configStream << " mmx";
+ if ( dictionary[ "3DNOW" ] == "yes" )
+ configStream << " 3dnow";
+ if ( dictionary[ "SSE" ] == "yes" )
+ configStream << " sse";
+ if ( dictionary[ "SSE2" ] == "yes" )
+ configStream << " sse2";
+ if ( dictionary[ "IWMMXT" ] == "yes" )
+ configStream << " iwmmxt";
+ if ( dictionary["INCREDIBUILD_XGE"] == "yes" )
+ configStream << " incredibuild_xge";
+ if ( dictionary["PLUGIN_MANIFESTS"] == "no" )
+ configStream << " no_plugin_manifest";
+
+ configStream << endl;
+ configStream << "QT_ARCH = " << dictionary[ "ARCHITECTURE" ] << endl;
+ if (dictionary["QT_EDITION"].contains("OPENSOURCE"))
+ configStream << "QT_EDITION = " << QLatin1String("OpenSource") << endl;
+ else
+ configStream << "QT_EDITION = " << dictionary["EDITION"] << endl;
+ configStream << "QT_CONFIG += " << qtConfig.join(" ") << endl;
+
+ configStream << "#versioning " << endl
+ << "QT_VERSION = " << dictionary["VERSION"] << endl
+ << "QT_MAJOR_VERSION = " << dictionary["VERSION_MAJOR"] << endl
+ << "QT_MINOR_VERSION = " << dictionary["VERSION_MINOR"] << endl
+ << "QT_PATCH_VERSION = " << dictionary["VERSION_PATCH"] << endl;
+
+ configStream << "#Qt for Windows CE c-runtime deployment" << endl
+ << "QT_CE_C_RUNTIME = " << fixSeparators(dictionary[ "CE_CRT" ]) << endl;
+
+ if(dictionary["CE_SIGNATURE"] != QLatin1String("no"))
+ configStream << "DEFAULT_SIGNATURE=" << dictionary["CE_SIGNATURE"] << endl;
+
+ if(!dictionary["QMAKE_RPATHDIR"].isEmpty())
+ configStream<<"QMAKE_RPATHDIR += "<<dictionary["QMAKE_RPATHDIR"];
+
+ configStream.flush();
+ configFile.close();
+ }
+}
+#endif
+
+QString Configure::addDefine(QString def)
+{
+ QString result, defNeg, defD = def;
+
+ defD.replace(QRegExp("=.*"), "");
+ def.replace(QRegExp("="), " ");
+
+ if(def.startsWith("QT_NO_")) {
+ defNeg = defD;
+ defNeg.replace("QT_NO_", "QT_");
+ } else if(def.startsWith("QT_")) {
+ defNeg = defD;
+ defNeg.replace("QT_", "QT_NO_");
+ }
+
+ if (defNeg.isEmpty()) {
+ result = "#ifndef $DEFD\n"
+ "# define $DEF\n"
+ "#endif\n\n";
+ } else {
+ result = "#if defined($DEFD) && defined($DEFNEG)\n"
+ "# undef $DEFD\n"
+ "#elif !defined($DEFD)\n"
+ "# define $DEF\n"
+ "#endif\n\n";
+ }
+ result.replace("$DEFNEG", defNeg);
+ result.replace("$DEFD", defD);
+ result.replace("$DEF", def);
+ return result;
+}
+
+#if !defined(EVAL)
+void Configure::generateConfigfiles()
+{
+ QDir(buildPath).mkpath("src/corelib/global");
+ QString outName( buildPath + "/src/corelib/global/qconfig.h" );
+ QTemporaryFile tmpFile;
+ QTextStream tmpStream;
+
+ if(tmpFile.open()) {
+ tmpStream.setDevice(&tmpFile);
+
+ if( dictionary[ "QCONFIG" ] == "full" ) {
+ tmpStream << "/* Everything */" << endl;
+ } else {
+ QString configName( "qconfig-" + dictionary[ "QCONFIG" ] + ".h" );
+ tmpStream << "/* Copied from " << configName << "*/" << endl;
+ tmpStream << "#ifndef QT_BOOTSTRAPPED" << endl;
+ QFile inFile( sourcePath + "/src/corelib/global/" + configName );
+ if( inFile.open( QFile::ReadOnly ) ) {
+ QByteArray buffer = inFile.readAll();
+ tmpFile.write( buffer.constData(), buffer.size() );
+ inFile.close();
+ }
+ tmpStream << "#endif // QT_BOOTSTRAPPED" << endl;
+ }
+ tmpStream << endl;
+
+ if( dictionary[ "SHARED" ] == "yes" ) {
+ tmpStream << "#ifndef QT_DLL" << endl;
+ tmpStream << "#define QT_DLL" << endl;
+ tmpStream << "#endif" << endl;
+ }
+ tmpStream << endl;
+ tmpStream << "/* License information */" << endl;
+ tmpStream << "#define QT_PRODUCT_LICENSEE \"" << licenseInfo[ "LICENSEE" ] << "\"" << endl;
+ tmpStream << "#define QT_PRODUCT_LICENSE \"" << dictionary[ "EDITION" ] << "\"" << endl;
+ tmpStream << endl;
+ tmpStream << "// Qt Edition" << endl;
+ tmpStream << "#ifndef QT_EDITION" << endl;
+ tmpStream << "# define QT_EDITION " << dictionary["QT_EDITION"] << endl;
+ tmpStream << "#endif" << endl;
+ tmpStream << endl;
+ tmpStream << dictionary["BUILD_KEY"];
+ tmpStream << endl;
+ if (dictionary["BUILDDEV"] == "yes") {
+ dictionary["QMAKE_INTERNAL"] = "yes";
+ tmpStream << "/* Used for example to export symbols for the certain autotests*/" << endl;
+ tmpStream << "#define QT_BUILD_INTERNAL" << endl;
+ tmpStream << endl;
+ }
+ tmpStream << "/* Machine byte-order */" << endl;
+ tmpStream << "#define Q_BIG_ENDIAN 4321" << endl;
+ tmpStream << "#define Q_LITTLE_ENDIAN 1234" << endl;
+ if ( QSysInfo::ByteOrder == QSysInfo::BigEndian )
+ tmpStream << "#define Q_BYTE_ORDER Q_BIG_ENDIAN" << endl;
+ else
+ tmpStream << "#define Q_BYTE_ORDER Q_LITTLE_ENDIAN" << endl;
+
+ tmpStream << endl << "// Compile time features" << endl;
+ tmpStream << "#define QT_ARCH_" << dictionary["ARCHITECTURE"].toUpper() << endl;
+ QStringList qconfigList;
+ if(dictionary["STL"] == "no") qconfigList += "QT_NO_STL";
+ if(dictionary["STYLE_WINDOWS"] != "yes") qconfigList += "QT_NO_STYLE_WINDOWS";
+ if(dictionary["STYLE_PLASTIQUE"] != "yes") qconfigList += "QT_NO_STYLE_PLASTIQUE";
+ if(dictionary["STYLE_CLEANLOOKS"] != "yes") qconfigList += "QT_NO_STYLE_CLEANLOOKS";
+ if(dictionary["STYLE_WINDOWSXP"] != "yes" && dictionary["STYLE_WINDOWSVISTA"] != "yes")
+ qconfigList += "QT_NO_STYLE_WINDOWSXP";
+ if(dictionary["STYLE_WINDOWSVISTA"] != "yes") qconfigList += "QT_NO_STYLE_WINDOWSVISTA";
+ if(dictionary["STYLE_MOTIF"] != "yes") qconfigList += "QT_NO_STYLE_MOTIF";
+ if(dictionary["STYLE_CDE"] != "yes") qconfigList += "QT_NO_STYLE_CDE";
+ if(dictionary["STYLE_WINDOWSCE"] != "yes") qconfigList += "QT_NO_STYLE_WINDOWSCE";
+ if(dictionary["STYLE_WINDOWSMOBILE"] != "yes") qconfigList += "QT_NO_STYLE_WINDOWSMOBILE";
+ if(dictionary["STYLE_GTK"] != "yes") qconfigList += "QT_NO_STYLE_GTK";
+
+ if(dictionary["GIF"] == "yes") qconfigList += "QT_BUILTIN_GIF_READER=1";
+ if(dictionary["PNG"] == "no") qconfigList += "QT_NO_IMAGEFORMAT_PNG";
+ if(dictionary["MNG"] == "no") qconfigList += "QT_NO_IMAGEFORMAT_MNG";
+ if(dictionary["JPEG"] == "no") qconfigList += "QT_NO_IMAGEFORMAT_JPEG";
+ if(dictionary["TIFF"] == "no") qconfigList += "QT_NO_IMAGEFORMAT_TIFF";
+ if(dictionary["ZLIB"] == "no") {
+ qconfigList += "QT_NO_ZLIB";
+ qconfigList += "QT_NO_COMPRESS";
+ }
+
+ if(dictionary["QT3SUPPORT"] == "no") qconfigList += "QT_NO_QT3SUPPORT";
+ if(dictionary["ACCESSIBILITY"] == "no") qconfigList += "QT_NO_ACCESSIBILITY";
+ if(dictionary["EXCEPTIONS"] == "no") qconfigList += "QT_NO_EXCEPTIONS";
+ if(dictionary["OPENGL"] == "no") qconfigList += "QT_NO_OPENGL";
+ if(dictionary["DIRECT3D"] == "no") qconfigList += "QT_NO_DIRECT3D";
+ if(dictionary["OPENSSL"] == "no") qconfigList += "QT_NO_OPENSSL";
+ if(dictionary["OPENSSL"] == "linked") qconfigList += "QT_LINKED_OPENSSL";
+ if(dictionary["DBUS"] == "no") qconfigList += "QT_NO_DBUS";
+ if(dictionary["IPV6"] == "no") qconfigList += "QT_NO_IPV6";
+ if(dictionary["WEBKIT"] == "no") qconfigList += "QT_NO_WEBKIT";
+ if(dictionary["PHONON"] == "no") qconfigList += "QT_NO_PHONON";
+ if(dictionary["XMLPATTERNS"] == "no") qconfigList += "QT_NO_XMLPATTERNS";
+ if(dictionary["SCRIPTTOOLS"] == "no") qconfigList += "QT_NO_SCRIPTTOOLS";
+
+ if(dictionary["OPENGL_ES_CM"] == "yes" ||
+ dictionary["OPENGL_ES_CL"] == "yes") qconfigList += "QT_OPENGL_ES";
+
+ if(dictionary["OPENGL_ES_CM"] == "yes") qconfigList += "QT_OPENGL_ES_1";
+ if(dictionary["OPENGL_ES_CL"] == "yes") qconfigList += "QT_OPENGL_ES_1_CL";
+
+ if(dictionary["SQL_MYSQL"] == "yes") qconfigList += "QT_SQL_MYSQL";
+ if(dictionary["SQL_ODBC"] == "yes") qconfigList += "QT_SQL_ODBC";
+ if(dictionary["SQL_OCI"] == "yes") qconfigList += "QT_SQL_OCI";
+ if(dictionary["SQL_PSQL"] == "yes") qconfigList += "QT_SQL_PSQL";
+ if(dictionary["SQL_TDS"] == "yes") qconfigList += "QT_SQL_TDS";
+ if(dictionary["SQL_DB2"] == "yes") qconfigList += "QT_SQL_DB2";
+ if(dictionary["SQL_SQLITE"] == "yes") qconfigList += "QT_SQL_SQLITE";
+ if(dictionary["SQL_SQLITE2"] == "yes") qconfigList += "QT_SQL_SQLITE2";
+ if(dictionary["SQL_IBASE"] == "yes") qconfigList += "QT_SQL_IBASE";
+
+ if (dictionary["GRAPHICS_SYSTEM"] == "opengl") qconfigList += "QT_GRAPHICSSYSTEM_OPENGL";
+ if (dictionary["GRAPHICS_SYSTEM"] == "raster") qconfigList += "QT_GRAPHICSSYSTEM_RASTER";
+
+ qconfigList.sort();
+ for (int i = 0; i < qconfigList.count(); ++i)
+ tmpStream << addDefine(qconfigList.at(i));
+
+ if(dictionary["EMBEDDED"] == "yes")
+ {
+ // Check for keyboard, mouse, gfx.
+ QStringList kbdDrivers = dictionary["KBD_DRIVERS"].split(" ");;
+ QStringList allKbdDrivers;
+ allKbdDrivers<<"tty"<<"usb"<<"sl5000"<<"yopy"<<"vr41xx"<<"qvfb"<<"um";
+ foreach(QString kbd, allKbdDrivers) {
+ if( !kbdDrivers.contains(kbd))
+ tmpStream<<"#define QT_NO_QWS_KBD_"<<kbd.toUpper()<<endl;
+ }
+
+ QStringList mouseDrivers = dictionary["MOUSE_DRIVERS"].split(" ");
+ QStringList allMouseDrivers;
+ allMouseDrivers << "pc"<<"bus"<<"linuxtp"<<"yopy"<<"vr41xx"<<"tslib"<<"qvfb";
+ foreach(QString mouse, allMouseDrivers) {
+ if( !mouseDrivers.contains(mouse) )
+ tmpStream<<"#define QT_NO_QWS_MOUSE_"<<mouse.toUpper()<<endl;
+ }
+
+ QStringList gfxDrivers = dictionary["GFX_DRIVERS"].split(" ");
+ QStringList allGfxDrivers;
+ allGfxDrivers<<"linuxfb"<<"transformed"<<"qvfb"<<"vnc"<<"multiscreen"<<"ahi";
+ foreach(QString gfx, allGfxDrivers) {
+ if( !gfxDrivers.contains(gfx))
+ tmpStream<<"#define QT_NO_QWS_"<<gfx.toUpper()<<endl;
+ }
+
+ tmpStream<<"#define Q_WS_QWS"<<endl;
+
+ QStringList depths = dictionary[ "QT_QWS_DEPTH" ].split(" ");
+ foreach(QString depth, depths)
+ tmpStream<<"#define QT_QWS_DEPTH_"+depth<<endl;
+ }
+
+ if( dictionary[ "QT_CUPS" ] == "no")
+ tmpStream<<"#define QT_NO_CUPS"<<endl;
+
+ if( dictionary[ "QT_ICONV" ] == "no")
+ tmpStream<<"#define QT_NO_ICONV"<<endl;
+
+ if(dictionary[ "QT_GLIB" ] == "no")
+ tmpStream<<"#define QT_NO_GLIB"<<endl;
+
+ if(dictionary[ "QT_LPR" ] == "no")
+ tmpStream<<"#define QT_NO_LPR"<<endl;
+
+ if(dictionary[ "QT_INOTIFY" ] == "no" )
+ tmpStream<<"#define QT_NO_INOTIFY"<<endl;
+
+ if(dictionary[ "QT_SXE" ] == "no")
+ tmpStream<<"#define QT_NO_SXE"<<endl;
+
+ tmpStream.flush();
+ tmpFile.flush();
+
+ // Replace old qconfig.h with new one
+ ::SetFileAttributesA(outName.toLocal8Bit(), FILE_ATTRIBUTE_NORMAL);
+ QFile::remove(outName);
+ tmpFile.copy(outName);
+ tmpFile.close();
+
+ if(!QFile::exists(buildPath + "/include/QtCore/qconfig.h")) {
+ if (!writeToFile("#include \"../../src/corelib/global/qconfig.h\"\n",
+ buildPath + "/include/QtCore/qconfig.h")
+ || !writeToFile("#include \"../../src/corelib/global/qconfig.h\"\n",
+ buildPath + "/include/Qt/qconfig.h")) {
+ dictionary["DONE"] = "error";
+ return;
+ }
+ }
+ }
+
+ // Copy configured mkspec to default directory, but remove the old one first, if there is any
+ QString defSpec = buildPath + "/mkspecs/default";
+ QFileInfo defSpecInfo(defSpec);
+ if (defSpecInfo.exists()) {
+ if (!Environment::rmdir(defSpec)) {
+ cout << "Couldn't update default mkspec! Are files in " << qPrintable(defSpec) << " read-only?" << endl;
+ dictionary["DONE"] = "error";
+ return;
+ }
+ }
+
+ QString spec = dictionary.contains("XQMAKESPEC") ? dictionary["XQMAKESPEC"] : dictionary["QMAKESPEC"];
+ QString pltSpec = sourcePath + "/mkspecs/" + spec;
+ if (!Environment::cpdir(pltSpec, defSpec)) {
+ cout << "Couldn't update default mkspec! Does " << qPrintable(pltSpec) << " exist?" << endl;
+ dictionary["DONE"] = "error";
+ return;
+ }
+
+ outName = defSpec + "/qmake.conf";
+ ::SetFileAttributesA(outName.toLocal8Bit(), FILE_ATTRIBUTE_NORMAL );
+ QFile qmakeConfFile(outName);
+ if (qmakeConfFile.open(QFile::Append | QFile::WriteOnly | QFile::Text)) {
+ QTextStream qmakeConfStream;
+ qmakeConfStream.setDevice(&qmakeConfFile);
+ qmakeConfStream << endl << "QMAKESPEC_ORIGINAL=" << pltSpec << endl;
+ qmakeConfStream.flush();
+ qmakeConfFile.close();
+ }
+
+ // Generate the new qconfig.cpp file
+ QDir(buildPath).mkpath("src/corelib/global");
+ outName = buildPath + "/src/corelib/global/qconfig.cpp";
+
+ QTemporaryFile tmpFile2;
+ if (tmpFile2.open()) {
+ tmpStream.setDevice(&tmpFile2);
+ tmpStream << "/* Licensed */" << endl
+ << "static const char qt_configure_licensee_str [512 + 12] = \"qt_lcnsuser=" << licenseInfo["LICENSEE"] << "\";" << endl
+ << "static const char qt_configure_licensed_products_str [512 + 12] = \"qt_lcnsprod=" << dictionary["EDITION"] << "\";" << endl;
+ if(!dictionary[ "QT_HOST_PREFIX" ].isNull())
+ tmpStream << "#if !defined(QT_BOOTSTRAPPED) && !defined(QT_BUILD_QMAKE)" << endl;
+ tmpStream << "static const char qt_configure_prefix_path_str [512 + 12] = \"qt_prfxpath=" << QString(dictionary["QT_INSTALL_PREFIX"]).replace( "\\", "\\\\" ) << "\";" << endl
+ << "static const char qt_configure_documentation_path_str[512 + 12] = \"qt_docspath=" << QString(dictionary["QT_INSTALL_DOCS"]).replace( "\\", "\\\\" ) << "\";" << endl
+ << "static const char qt_configure_headers_path_str [512 + 12] = \"qt_hdrspath=" << QString(dictionary["QT_INSTALL_HEADERS"]).replace( "\\", "\\\\" ) << "\";" << endl
+ << "static const char qt_configure_libraries_path_str [512 + 12] = \"qt_libspath=" << QString(dictionary["QT_INSTALL_LIBS"]).replace( "\\", "\\\\" ) << "\";" << endl
+ << "static const char qt_configure_binaries_path_str [512 + 12] = \"qt_binspath=" << QString(dictionary["QT_INSTALL_BINS"]).replace( "\\", "\\\\" ) << "\";" << endl
+ << "static const char qt_configure_plugins_path_str [512 + 12] = \"qt_plugpath=" << QString(dictionary["QT_INSTALL_PLUGINS"]).replace( "\\", "\\\\" ) << "\";" << endl
+ << "static const char qt_configure_data_path_str [512 + 12] = \"qt_datapath=" << QString(dictionary["QT_INSTALL_DATA"]).replace( "\\", "\\\\" ) << "\";" << endl
+ << "static const char qt_configure_translations_path_str [512 + 12] = \"qt_trnspath=" << QString(dictionary["QT_INSTALL_TRANSLATIONS"]).replace( "\\", "\\\\" ) << "\";" << endl
+ << "static const char qt_configure_examples_path_str [512 + 12] = \"qt_xmplpath=" << QString(dictionary["QT_INSTALL_EXAMPLES"]).replace( "\\", "\\\\" ) << "\";" << endl
+ << "static const char qt_configure_demos_path_str [512 + 12] = \"qt_demopath=" << QString(dictionary["QT_INSTALL_DEMOS"]).replace( "\\", "\\\\" ) << "\";" << endl
+ //<< "static const char qt_configure_settings_path_str [256] = \"qt_stngpath=" << QString(dictionary["QT_INSTALL_SETTINGS"]).replace( "\\", "\\\\" ) << "\";" << endl
+ ;
+ if(!dictionary[ "QT_HOST_PREFIX" ].isNull()) {
+ tmpStream << "#else" << endl
+ << "static const char qt_configure_prefix_path_str [512 + 12] = \"qt_prfxpath=" << QString(dictionary[ "QT_HOST_PREFIX" ]).replace( "\\", "\\\\" ) << "\";" << endl
+ << "static const char qt_configure_documentation_path_str[512 + 12] = \"qt_docspath=" << fixSeparators(dictionary[ "QT_HOST_PREFIX" ] + "/doc").replace( "\\", "\\\\" ) <<"\";" << endl
+ << "static const char qt_configure_headers_path_str [512 + 12] = \"qt_hdrspath=" << fixSeparators(dictionary[ "QT_HOST_PREFIX" ] + "/include").replace( "\\", "\\\\" ) <<"\";" << endl
+ << "static const char qt_configure_libraries_path_str [512 + 12] = \"qt_libspath=" << fixSeparators(dictionary[ "QT_HOST_PREFIX" ] + "/lib").replace( "\\", "\\\\" ) <<"\";" << endl
+ << "static const char qt_configure_binaries_path_str [512 + 12] = \"qt_binspath=" << fixSeparators(dictionary[ "QT_HOST_PREFIX" ] + "/bin").replace( "\\", "\\\\" ) <<"\";" << endl
+ << "static const char qt_configure_plugins_path_str [512 + 12] = \"qt_plugpath=" << fixSeparators(dictionary[ "QT_HOST_PREFIX" ] + "/plugins").replace( "\\", "\\\\" ) <<"\";" << endl
+ << "static const char qt_configure_data_path_str [512 + 12] = \"qt_datapath=" << fixSeparators(dictionary[ "QT_HOST_PREFIX" ]).replace( "\\", "\\\\" ) <<"\";" << endl
+ << "static const char qt_configure_translations_path_str [512 + 12] = \"qt_trnspath=" << fixSeparators(dictionary[ "QT_HOST_PREFIX" ] + "/translations").replace( "\\", "\\\\" ) <<"\";" << endl
+ << "static const char qt_configure_examples_path_str [512 + 12] = \"qt_xmplpath=" << fixSeparators(dictionary[ "QT_HOST_PREFIX" ] + "/example").replace( "\\", "\\\\" ) <<"\";" << endl
+ << "static const char qt_configure_demos_path_str [512 + 12] = \"qt_demopath=" << fixSeparators(dictionary[ "QT_HOST_PREFIX" ] + "/demos").replace( "\\", "\\\\" ) <<"\";" << endl
+ << "#endif //QT_BOOTSTRAPPED" << endl;
+ }
+ tmpStream << "/* strlen( \"qt_lcnsxxxx\" ) == 12 */" << endl
+ << "#define QT_CONFIGURE_LICENSEE qt_configure_licensee_str + 12;" << endl
+ << "#define QT_CONFIGURE_LICENSED_PRODUCTS qt_configure_licensed_products_str + 12;" << endl
+ << "#define QT_CONFIGURE_PREFIX_PATH qt_configure_prefix_path_str + 12;" << endl
+ << "#define QT_CONFIGURE_DOCUMENTATION_PATH qt_configure_documentation_path_str + 12;" << endl
+ << "#define QT_CONFIGURE_HEADERS_PATH qt_configure_headers_path_str + 12;" << endl
+ << "#define QT_CONFIGURE_LIBRARIES_PATH qt_configure_libraries_path_str + 12;" << endl
+ << "#define QT_CONFIGURE_BINARIES_PATH qt_configure_binaries_path_str + 12;" << endl
+ << "#define QT_CONFIGURE_PLUGINS_PATH qt_configure_plugins_path_str + 12;" << endl
+ << "#define QT_CONFIGURE_DATA_PATH qt_configure_data_path_str + 12;" << endl
+ << "#define QT_CONFIGURE_TRANSLATIONS_PATH qt_configure_translations_path_str + 12;" << endl
+ << "#define QT_CONFIGURE_EXAMPLES_PATH qt_configure_examples_path_str + 12;" << endl
+ << "#define QT_CONFIGURE_DEMOS_PATH qt_configure_demos_path_str + 12;" << endl
+ //<< "#define QT_CONFIGURE_SETTINGS_PATH qt_configure_settings_path_str + 12;" << endl
+ << endl;
+
+ tmpStream.flush();
+ tmpFile2.flush();
+
+ // Replace old qconfig.cpp with new one
+ ::SetFileAttributesA(outName.toLocal8Bit(), FILE_ATTRIBUTE_NORMAL );
+ QFile::remove( outName );
+ tmpFile2.copy(outName);
+ tmpFile2.close();
+ }
+}
+#endif
+
+#if !defined(EVAL)
+void Configure::displayConfig()
+{
+ // Give some feedback
+ cout << "Environment:" << endl;
+ QString env = QString::fromLocal8Bit(getenv("INCLUDE")).replace(QRegExp("[;,]"), "\r\n ");
+ if (env.isEmpty())
+ env = "Unset";
+ cout << " INCLUDE=\r\n " << env << endl;
+ env = QString::fromLocal8Bit(getenv("LIB")).replace(QRegExp("[;,]"), "\r\n ");
+ if (env.isEmpty())
+ env = "Unset";
+ cout << " LIB=\r\n " << env << endl;
+ env = QString::fromLocal8Bit(getenv("PATH")).replace(QRegExp("[;,]"), "\r\n ");
+ if (env.isEmpty())
+ env = "Unset";
+ cout << " PATH=\r\n " << env << endl;
+
+ if (dictionary["EDITION"] == "OpenSource") {
+ cout << "You are licensed to use this software under the terms of the GNU GPL version 3.";
+ cout << "You are licensed to use this software under the terms of the Lesser GNU LGPL version 2.1." << endl;
+ cout << "See " << dictionary["LICENSE FILE"] << "3" << endl << endl
+ << " or " << dictionary["LICENSE FILE"] << "L" << endl << endl;
+ } else {
+ QString l1 = licenseInfo[ "LICENSEE" ];
+ QString l2 = licenseInfo[ "LICENSEID" ];
+ QString l3 = dictionary["EDITION"] + ' ' + "Edition";
+ QString l4 = licenseInfo[ "EXPIRYDATE" ];
+ cout << "Licensee...................." << (l1.isNull() ? "" : l1) << endl;
+ cout << "License ID.................." << (l2.isNull() ? "" : l2) << endl;
+ cout << "Product license............." << (l3.isNull() ? "" : l3) << endl;
+ cout << "Expiry Date................." << (l4.isNull() ? "" : l4) << endl << endl;
+ }
+
+ cout << "Configuration:" << endl;
+ cout << " " << qmakeConfig.join( "\r\n " ) << endl;
+ cout << "Qt Configuration:" << endl;
+ cout << " " << qtConfig.join( "\r\n " ) << endl;
+ cout << endl;
+
+ if (dictionary.contains("XQMAKESPEC"))
+ cout << "QMAKESPEC..................." << dictionary[ "XQMAKESPEC" ] << " (" << dictionary["QMAKESPEC_FROM"] << ")" << endl;
+ else
+ cout << "QMAKESPEC..................." << dictionary[ "QMAKESPEC" ] << " (" << dictionary["QMAKESPEC_FROM"] << ")" << endl;
+ cout << "Architecture................" << dictionary[ "ARCHITECTURE" ] << endl;
+ cout << "Maketool...................." << dictionary[ "MAKE" ] << endl;
+ cout << "Debug symbols..............." << (dictionary[ "BUILD" ] == "debug" ? "yes" : "no") << endl;
+ cout << "Accessibility support......." << dictionary[ "ACCESSIBILITY" ] << endl;
+ cout << "STL support................." << dictionary[ "STL" ] << endl;
+ cout << "Exception support..........." << dictionary[ "EXCEPTIONS" ] << endl;
+ cout << "RTTI support................" << dictionary[ "RTTI" ] << endl;
+ cout << "MMX support................." << dictionary[ "MMX" ] << endl;
+ cout << "3DNOW support..............." << dictionary[ "3DNOW" ] << endl;
+ cout << "SSE support................." << dictionary[ "SSE" ] << endl;
+ cout << "SSE2 support................" << dictionary[ "SSE2" ] << endl;
+ cout << "IWMMXT support.............." << dictionary[ "IWMMXT" ] << endl;
+ cout << "OpenGL support.............." << dictionary[ "OPENGL" ] << endl;
+ cout << "Direct3D support............" << dictionary[ "DIRECT3D" ] << endl;
+ cout << "OpenSSL support............." << dictionary[ "OPENSSL" ] << endl;
+ cout << "QtDBus support.............." << dictionary[ "DBUS" ] << endl;
+ cout << "QtXmlPatterns support......." << dictionary[ "XMLPATTERNS" ] << endl;
+ cout << "Phonon support.............." << dictionary[ "PHONON" ] << endl;
+ cout << "WebKit support.............." << dictionary[ "WEBKIT" ] << endl;
+ cout << "QtScriptTools support......." << dictionary[ "SCRIPTTOOLS" ] << endl;
+ cout << "Graphics System............." << dictionary[ "GRAPHICS_SYSTEM" ] << endl;
+ cout << "Qt3 compatibility..........." << dictionary[ "QT3SUPPORT" ] << endl << endl;
+
+ cout << "Third Party Libraries:" << endl;
+ cout << " ZLIB support............" << dictionary[ "ZLIB" ] << endl;
+ cout << " GIF support............." << dictionary[ "GIF" ] << endl;
+ cout << " TIFF support............" << dictionary[ "TIFF" ] << endl;
+ cout << " JPEG support............" << dictionary[ "JPEG" ] << endl;
+ cout << " PNG support............." << dictionary[ "PNG" ] << endl;
+ cout << " MNG support............." << dictionary[ "MNG" ] << endl << endl;
+
+ cout << "Styles:" << endl;
+ cout << " Windows................." << dictionary[ "STYLE_WINDOWS" ] << endl;
+ cout << " Windows XP.............." << dictionary[ "STYLE_WINDOWSXP" ] << endl;
+ cout << " Windows Vista..........." << dictionary[ "STYLE_WINDOWSVISTA" ] << endl;
+ cout << " Plastique..............." << dictionary[ "STYLE_PLASTIQUE" ] << endl;
+ cout << " Cleanlooks.............." << dictionary[ "STYLE_CLEANLOOKS" ] << endl;
+ cout << " Motif..................." << dictionary[ "STYLE_MOTIF" ] << endl;
+ cout << " CDE....................." << dictionary[ "STYLE_CDE" ] << endl;
+ cout << " Windows CE.............." << dictionary[ "STYLE_WINDOWSCE" ] << endl;
+ cout << " Windows Mobile.........." << dictionary[ "STYLE_WINDOWSMOBILE" ] << endl << endl;
+
+ cout << "Sql Drivers:" << endl;
+ cout << " ODBC...................." << dictionary[ "SQL_ODBC" ] << endl;
+ cout << " MySQL..................." << dictionary[ "SQL_MYSQL" ] << endl;
+ cout << " OCI....................." << dictionary[ "SQL_OCI" ] << endl;
+ cout << " PostgreSQL.............." << dictionary[ "SQL_PSQL" ] << endl;
+ cout << " TDS....................." << dictionary[ "SQL_TDS" ] << endl;
+ cout << " DB2....................." << dictionary[ "SQL_DB2" ] << endl;
+ cout << " SQLite.................." << dictionary[ "SQL_SQLITE" ] << " (" << dictionary[ "SQL_SQLITE_LIB" ] << ")" << endl;
+ cout << " SQLite2................." << dictionary[ "SQL_SQLITE2" ] << endl;
+ cout << " InterBase..............." << dictionary[ "SQL_IBASE" ] << endl << endl;
+
+ cout << "Sources are in.............." << dictionary[ "QT_SOURCE_TREE" ] << endl;
+ cout << "Build is done in............" << dictionary[ "QT_BUILD_TREE" ] << endl;
+ cout << "Install prefix.............." << dictionary[ "QT_INSTALL_PREFIX" ] << endl;
+ cout << "Headers installed to........" << dictionary[ "QT_INSTALL_HEADERS" ] << endl;
+ cout << "Libraries installed to......" << dictionary[ "QT_INSTALL_LIBS" ] << endl;
+ cout << "Plugins installed to........" << dictionary[ "QT_INSTALL_PLUGINS" ] << endl;
+ cout << "Binaries installed to......." << dictionary[ "QT_INSTALL_BINS" ] << endl;
+ cout << "Docs installed to..........." << dictionary[ "QT_INSTALL_DOCS" ] << endl;
+ cout << "Data installed to..........." << dictionary[ "QT_INSTALL_DATA" ] << endl;
+ cout << "Translations installed to..." << dictionary[ "QT_INSTALL_TRANSLATIONS" ] << endl;
+ cout << "Examples installed to......." << dictionary[ "QT_INSTALL_EXAMPLES" ] << endl;
+ cout << "Demos installed to.........." << dictionary[ "QT_INSTALL_DEMOS" ] << endl << endl;
+
+ if (dictionary.contains("XQMAKESPEC") && dictionary["XQMAKESPEC"].startsWith(QLatin1String("wince"))) {
+ cout << "Using c runtime detection..." << dictionary[ "CE_CRT" ] << endl;
+ cout << "Cetest support.............." << dictionary[ "CETEST" ] << endl;
+ cout << "Signature..................." << dictionary[ "CE_SIGNATURE"] << endl << endl;
+ }
+
+ if(dictionary["ASSISTANT_WEBKIT"] == "yes")
+ cout << "Using WebKit as html rendering engine in Qt Assistant." << endl;
+
+ if(checkAvailability("INCREDIBUILD_XGE"))
+ cout << "Using IncrediBuild XGE......" << dictionary["INCREDIBUILD_XGE"] << endl;
+ if( !qmakeDefines.isEmpty() ) {
+ cout << "Defines.....................";
+ for( QStringList::Iterator defs = qmakeDefines.begin(); defs != qmakeDefines.end(); ++defs )
+ cout << (*defs) << " ";
+ cout << endl;
+ }
+ if( !qmakeIncludes.isEmpty() ) {
+ cout << "Include paths...............";
+ for( QStringList::Iterator incs = qmakeIncludes.begin(); incs != qmakeIncludes.end(); ++incs )
+ cout << (*incs) << " ";
+ cout << endl;
+ }
+ if( !qmakeLibs.isEmpty() ) {
+ cout << "Additional libraries........";
+ for( QStringList::Iterator libs = qmakeLibs.begin(); libs != qmakeLibs.end(); ++libs )
+ cout << (*libs) << " ";
+ cout << endl;
+ }
+ if( dictionary[ "QMAKE_INTERNAL" ] == "yes" ) {
+ cout << "Using internal configuration." << endl;
+ }
+ if( dictionary[ "SHARED" ] == "no" ) {
+ cout << "WARNING: Using static linking will disable the use of plugins." << endl;
+ cout << " Make sure you compile ALL needed modules into the library." << endl;
+ }
+ if( dictionary[ "OPENSSL" ] == "linked" && opensslLibs.isEmpty() ) {
+ cout << "NOTE: When linking against OpenSSL, you can override the default" << endl;
+ cout << "library names through OPENSSL_LIBS." << endl;
+ cout << "For example:" << endl;
+ cout << " configure -openssl-linked OPENSSL_LIBS='-lssleay32 -llibeay32'" << endl;
+ }
+ if( dictionary[ "ZLIB_FORCED" ] == "yes" ) {
+ QString which_zlib = "supplied";
+ if( dictionary[ "ZLIB" ] == "system")
+ which_zlib = "system";
+
+ cout << "NOTE: The -no-zlib option was supplied but is no longer supported." << endl
+ << endl
+ << "Qt now requires zlib support in all builds, so the -no-zlib" << endl
+ << "option was ignored. Qt will be built using the " << which_zlib
+ << "zlib" << endl;
+ }
+}
+#endif
+
+#if !defined(EVAL)
+void Configure::generateHeaders()
+{
+ if (dictionary["SYNCQT"] == "yes"
+ && findFile("perl.exe")) {
+ cout << "Running syncqt..." << endl;
+ QStringList args;
+ args += buildPath + "/bin/syncqt.bat";
+ QStringList env;
+ env += QString("QTDIR=" + sourcePath);
+ env += QString("PATH=" + buildPath + "/bin/;" + qgetenv("PATH"));
+ Environment::execute(args, env, QStringList());
+ }
+}
+
+void Configure::buildQmake()
+{
+ if( dictionary[ "BUILD_QMAKE" ] == "yes" ) {
+ QStringList args;
+
+ // Build qmake
+ QString pwd = QDir::currentPath();
+ QDir::setCurrent(buildPath + "/qmake" );
+
+ QString makefile = "Makefile";
+ {
+ QFile out(makefile);
+ if(out.open(QFile::WriteOnly | QFile::Text)) {
+ QTextStream stream(&out);
+ stream << "#AutoGenerated by configure.exe" << endl
+ << "BUILD_PATH = " << QDir::convertSeparators(buildPath) << endl
+ << "SOURCE_PATH = " << QDir::convertSeparators(sourcePath) << endl;
+ stream << "QMAKESPEC = " << dictionary["QMAKESPEC"] << endl;
+
+ if (dictionary["EDITION"] == "OpenSource" ||
+ dictionary["QT_EDITION"].contains("OPENSOURCE"))
+ stream << "QMAKE_OPENSOURCE_EDITION = yes" << endl;
+ stream << "\n\n";
+
+ QFile in(sourcePath + "/qmake/" + dictionary["QMAKEMAKEFILE"]);
+ if(in.open(QFile::ReadOnly | QFile::Text)) {
+ QString d = in.readAll();
+ //### need replaces (like configure.sh)? --Sam
+ stream << d << endl;
+ }
+ stream.flush();
+ out.close();
+ }
+ }
+
+ args += dictionary[ "MAKE" ];
+ args += "-f";
+ args += makefile;
+
+ cout << "Creating qmake..." << endl;
+ int exitCode = 0;
+ if( exitCode = Environment::execute(args, QStringList(), QStringList()) ) {
+ args.clear();
+ args += dictionary[ "MAKE" ];
+ args += "-f";
+ args += makefile;
+ args += "clean";
+ if( exitCode = Environment::execute(args, QStringList(), QStringList())) {
+ cout << "Cleaning qmake failed, return code " << exitCode << endl << endl;
+ dictionary[ "DONE" ] = "error";
+ } else {
+ args.clear();
+ args += dictionary[ "MAKE" ];
+ args += "-f";
+ args += makefile;
+ if (exitCode = Environment::execute(args, QStringList(), QStringList())) {
+ cout << "Building qmake failed, return code " << exitCode << endl << endl;
+ dictionary[ "DONE" ] = "error";
+ }
+ }
+ }
+ QDir::setCurrent( pwd );
+ }
+}
+#endif
+
+void Configure::buildHostTools()
+{
+ if (!dictionary.contains("XQMAKESPEC"))
+ return;
+
+ QString pwd = QDir::currentPath();
+ QStringList hostToolsDirs;
+ hostToolsDirs
+ << "src/tools/bootstrap"
+ << "src/tools/moc"
+ << "src/tools/rcc"
+ << "src/tools/uic"
+ << "tools/checksdk";
+
+ if (dictionary[ "CETEST" ] == "yes")
+ hostToolsDirs << "tools/qtestlib/wince/cetest";
+
+ for (int i = 0; i < hostToolsDirs.count(); ++i) {
+ cout << "Creating " << hostToolsDirs.at(i) << " ..." << endl;
+ QString toolBuildPath = buildPath + "/" + hostToolsDirs.at(i);
+ QString toolSourcePath = sourcePath + "/" + hostToolsDirs.at(i);
+
+ // generate Makefile
+ QStringList args;
+ args << QDir::toNativeSeparators(buildPath + "/bin/qmake");
+ args << "-spec" << dictionary["QMAKESPEC"] << "-r";
+ args << "-o" << QDir::toNativeSeparators(toolBuildPath + "/Makefile");
+
+ QDir().mkpath(toolBuildPath);
+ QDir::setCurrent(toolSourcePath);
+ int exitCode = 0;
+ if (exitCode = Environment::execute(args, QStringList(), QStringList())) {
+ cout << "qmake failed, return code " << exitCode << endl << endl;
+ dictionary["DONE"] = "error";
+ break;
+ }
+
+ // build app
+ args.clear();
+ args += dictionary["MAKE"];
+ QDir::setCurrent(toolBuildPath);
+ if (exitCode = Environment::execute(args, QStringList(), QStringList())) {
+ args.clear();
+ args += dictionary["MAKE"];
+ args += "clean";
+ if(exitCode = Environment::execute(args, QStringList(), QStringList())) {
+ cout << "Cleaning " << hostToolsDirs.at(i) << " failed, return code " << exitCode << endl << endl;
+ dictionary["DONE"] = "error";
+ break;
+ } else {
+ args.clear();
+ args += dictionary["MAKE"];
+ if (exitCode = Environment::execute(args, QStringList(), QStringList())) {
+ cout << "Building " << hostToolsDirs.at(i) << " failed, return code " << exitCode << endl << endl;
+ dictionary["DONE"] = "error";
+ break;
+ }
+ }
+ }
+ }
+ QDir::setCurrent(pwd);
+}
+
+void Configure::findProjects( const QString& dirName )
+{
+ if( dictionary[ "NOPROCESS" ] == "no" ) {
+ QDir dir( dirName );
+ QString entryName;
+ int makeListNumber;
+ ProjectType qmakeTemplate;
+ const QFileInfoList &list = dir.entryInfoList(QStringList(QLatin1String("*.pro")),
+ QDir::AllDirs | QDir::Files | QDir::NoDotAndDotDot);
+ for(int i = 0; i < list.size(); ++i) {
+ const QFileInfo &fi = list.at(i);
+ if(fi.fileName() != "qmake.pro") {
+ entryName = dirName + "/" + fi.fileName();
+ if(fi.isDir()) {
+ findProjects( entryName );
+ } else {
+ qmakeTemplate = projectType( fi.absoluteFilePath() );
+ switch ( qmakeTemplate ) {
+ case Lib:
+ case Subdirs:
+ makeListNumber = 1;
+ break;
+ default:
+ makeListNumber = 2;
+ break;
+ }
+ makeList[makeListNumber].append(new MakeItem(sourceDir.relativeFilePath(fi.absolutePath()),
+ fi.fileName(),
+ "Makefile",
+ qmakeTemplate));
+ }
+ }
+
+ }
+ }
+}
+
+void Configure::appendMakeItem(int inList, const QString &item)
+{
+ QString dir;
+ if (item != "src")
+ dir = "/" + item;
+ dir.prepend("/src");
+ makeList[inList].append(new MakeItem(sourcePath + dir,
+ item + ".pro", buildPath + dir + "/Makefile", Lib ) );
+ if( dictionary[ "DSPFILES" ] == "yes" ) {
+ makeList[inList].append( new MakeItem(sourcePath + dir,
+ item + ".pro", buildPath + dir + "/" + item + ".dsp", Lib ) );
+ }
+ if( dictionary[ "VCPFILES" ] == "yes" ) {
+ makeList[inList].append( new MakeItem(sourcePath + dir,
+ item + ".pro", buildPath + dir + "/" + item + ".vcp", Lib ) );
+ }
+ if( dictionary[ "VCPROJFILES" ] == "yes" ) {
+ makeList[inList].append( new MakeItem(sourcePath + dir,
+ item + ".pro", buildPath + dir + "/" + item + ".vcproj", Lib ) );
+ }
+}
+
+void Configure::generateMakefiles()
+{
+ if( dictionary[ "NOPROCESS" ] == "no" ) {
+#if !defined(EVAL)
+ cout << "Creating makefiles in src..." << endl;
+#endif
+
+ QString spec = dictionary.contains("XQMAKESPEC") ? dictionary[ "XQMAKESPEC" ] : dictionary[ "QMAKESPEC" ];
+ if( spec != "win32-msvc" )
+ dictionary[ "DSPFILES" ] = "no";
+
+ if( spec != "win32-msvc.net" && !spec.startsWith("win32-msvc2") && !spec.startsWith(QLatin1String("wince")))
+ dictionary[ "VCPROJFILES" ] = "no";
+
+ int i = 0;
+ QString pwd = QDir::currentPath();
+ if (dictionary["FAST"] != "yes") {
+ QString dirName;
+ bool generate = true;
+ bool doDsp = (dictionary["DSPFILES"] == "yes" || dictionary["VCPFILES"] == "yes"
+ || dictionary["VCPROJFILES"] == "yes");
+ while (generate) {
+ QString pwd = QDir::currentPath();
+ QString dirPath = fixSeparators(buildPath + dirName);
+ QStringList args;
+
+ args << fixSeparators( buildPath + "/bin/qmake" );
+
+ if (doDsp) {
+ if( dictionary[ "DEPENDENCIES" ] == "no" )
+ args << "-nodepend";
+ args << "-tp" << "vc";
+ doDsp = false; // DSP files will be done
+ printf("Generating Visual Studio project files...\n");
+ } else {
+ printf("Generating Makefiles...\n");
+ generate = false; // Now Makefiles will be done
+ }
+ args << "-spec";
+ args << spec;
+ args << "-r";
+ args << (sourcePath + "/projects.pro");
+ args << "-o";
+ args << buildPath;
+ if(!dictionary[ "QMAKEADDITIONALARGS" ].isEmpty())
+ args << dictionary[ "QMAKEADDITIONALARGS" ];
+
+ QDir::setCurrent( fixSeparators( dirPath ) );
+ if( int exitCode = Environment::execute(args, QStringList(), QStringList()) ) {
+ cout << "Qmake failed, return code " << exitCode << endl << endl;
+ dictionary[ "DONE" ] = "error";
+ }
+ }
+ } else {
+ findProjects(sourcePath);
+ for ( i=0; i<3; i++ ) {
+ for ( int j=0; j<makeList[i].size(); ++j) {
+ MakeItem *it=makeList[i][j];
+ QString dirPath = fixSeparators( it->directory + "/" );
+ QString projectName = it->proFile;
+ QString makefileName = buildPath + "/" + dirPath + it->target;
+
+ // For shadowbuilds, we need to create the path first
+ QDir buildPathDir(buildPath);
+ if (sourcePath != buildPath && !buildPathDir.exists(dirPath))
+ buildPathDir.mkpath(dirPath);
+
+ QStringList args;
+
+ args << fixSeparators( buildPath + "/bin/qmake" );
+ args << sourcePath + "/" + dirPath + projectName;
+ args << dictionary[ "QMAKE_ALL_ARGS" ];
+
+ cout << "For " << qPrintable(dirPath + projectName) << endl;
+ args << "-o";
+ args << it->target;
+ args << "-spec";
+ args << spec;
+ if(!dictionary[ "QMAKEADDITIONALARGS" ].isEmpty())
+ args << dictionary[ "QMAKEADDITIONALARGS" ];
+
+ QDir::setCurrent( fixSeparators( dirPath ) );
+
+ QFile file(makefileName);
+ if (!file.open(QFile::WriteOnly)) {
+ printf("failed on dirPath=%s, makefile=%s\n",
+ qPrintable(dirPath), qPrintable(makefileName));
+ continue;
+ }
+ QTextStream txt(&file);
+ txt << "all:\n";
+ txt << "\t" << args.join(" ") << "\n";
+ txt << "\t" << dictionary[ "MAKE" ] << " -f " << it->target << "\n";
+ txt << "first: all\n";
+ txt << "qmake:\n";
+ txt << "\t" << args.join(" ") << "\n";
+ }
+ }
+ }
+ QDir::setCurrent( pwd );
+ } else {
+ cout << "Processing of project files have been disabled." << endl;
+ cout << "Only use this option if you really know what you're doing." << endl << endl;
+ dictionary[ "DONE" ] = "yes";
+ return;
+ }
+}
+
+void Configure::showSummary()
+{
+ QString make = dictionary[ "MAKE" ];
+ cout << endl << endl << "Qt is now configured for building. Just run " << qPrintable(make) << "." << endl;
+ cout << "To reconfigure, run " << qPrintable(make) << " confclean and configure." << endl << endl;
+}
+
+Configure::ProjectType Configure::projectType( const QString& proFileName )
+{
+ QFile proFile( proFileName );
+ if( proFile.open( QFile::ReadOnly ) ) {
+ QString buffer = proFile.readLine(1024);
+ while (!buffer.isEmpty()) {
+ QStringList segments = buffer.split(QRegExp( "\\s" ));
+ QStringList::Iterator it = segments.begin();
+
+ if(segments.size() >= 3) {
+ QString keyword = (*it++);
+ QString operation = (*it++);
+ QString value = (*it++);
+
+ if( keyword == "TEMPLATE" ) {
+ if( value == "lib" )
+ return Lib;
+ else if( value == "subdirs" )
+ return Subdirs;
+ }
+ }
+ // read next line
+ buffer = proFile.readLine(1024);
+ }
+ proFile.close();
+ }
+ // Default to app handling
+ return App;
+}
+
+#if !defined(EVAL)
+
+bool Configure::showLicense(QString orgLicenseFile)
+{
+ if (dictionary["LICENSE_CONFIRMED"] == "yes") {
+ cout << "You have already accepted the terms of the license." << endl << endl;
+ return true;
+ }
+
+ QString licenseFile = orgLicenseFile;
+ QString theLicense;
+ if (dictionary["EDITION"] == "OpenSource" || dictionary["EDITION"] == "Snapshot") {
+ theLicense = "GNU General Public License (GPL) version 3 \nor the GNU Lesser General Public License (LGPL) version 2.1";
+ } else {
+ // the first line of the license file tells us which license it is
+ QFile file(licenseFile);
+ if (!file.open(QFile::ReadOnly)) {
+ cout << "Failed to load LICENSE file" << endl;
+ return false;
+ }
+ theLicense = file.readLine().trimmed();
+ }
+
+ forever {
+ char accept = '?';
+ cout << "You are licensed to use this software under the terms of" << endl
+ << "the " << theLicense << "." << endl
+ << endl;
+ if (dictionary["EDITION"] == "OpenSource" || dictionary["EDITION"] == "Snapshot") {
+ cout << "Type '3' to view the GNU General Public License version 3 (GPLv3)." << endl;
+ cout << "Type 'L' to view the Lesser GNU General Public License version 2.1 (LGPLv2.1)." << endl;
+ } else {
+ cout << "Type '?' to view the " << theLicense << "." << endl;
+ }
+ cout << "Type 'y' to accept this license offer." << endl
+ << "Type 'n' to decline this license offer." << endl
+ << endl
+ << "Do you accept the terms of the license?" << endl;
+ cin >> accept;
+ accept = tolower(accept);
+
+ if (accept == 'y') {
+ return true;
+ } else if (accept == 'n') {
+ return false;
+ } else {
+ if (dictionary["EDITION"] == "OpenSource" || dictionary["EDITION"] == "Snapshot") {
+ if (accept == '3')
+ licenseFile = orgLicenseFile + "/LICENSE.GPL3";
+ else
+ licenseFile = orgLicenseFile + "/LICENSE.LGPL";
+ }
+ // Get console line height, to fill the screen properly
+ int i = 0, screenHeight = 25; // default
+ CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
+ HANDLE stdOut = GetStdHandle(STD_OUTPUT_HANDLE);
+ if (GetConsoleScreenBufferInfo(stdOut, &consoleInfo))
+ screenHeight = consoleInfo.srWindow.Bottom
+ - consoleInfo.srWindow.Top
+ - 1; // Some overlap for context
+
+ // Prompt the license content to the user
+ QFile file(licenseFile);
+ if (!file.open(QFile::ReadOnly)) {
+ cout << "Failed to load LICENSE file" << licenseFile << endl;
+ return false;
+ }
+ QStringList licenseContent = QString(file.readAll()).split('\n');
+ while(i < licenseContent.size()) {
+ cout << licenseContent.at(i) << endl;
+ if (++i % screenHeight == 0) {
+ cout << "(Press any key for more..)";
+ if(_getch() == 3) // _Any_ keypress w/no echo(eat <Enter> for stdout)
+ exit(0); // Exit cleanly for Ctrl+C
+ cout << "\r"; // Overwrite text above
+ }
+ }
+ }
+ }
+}
+
+void Configure::readLicense()
+{
+ dictionary[ "PLATFORM NAME" ] = (QFile::exists(dictionary["QT_SOURCE_TREE"] + "/src/corelib/kernel/qfunctions_wince.h")
+ && (dictionary.value("QMAKESPEC").startsWith("wince") || dictionary.value("XQMAKESPEC").startsWith("wince")))
+ ? "Qt for Windows CE" : "Qt for Windows";
+ bool openSource = false;
+ if (dictionary["BUILDNOKIA"] == "yes" || dictionary["BUILDTYPE"] == "commercial") {
+ openSource = false;
+ } else if (dictionary["BUILDTYPE"] == "opensource") {
+ openSource = true;
+ } else {
+ forever {
+ char accept = '?';
+ cout << "Which edition of Qt do you want to use ?" << endl;
+ cout << "Type 'c' if you want to use the Commercial Edition." << endl;
+ cout << "Type 'o' if you want to use the Open Source Edition." << endl;
+ cin >> accept;
+ accept = tolower(accept);
+
+ if (accept == 'c') {
+ openSource = false;
+ break;
+ } else if (accept == 'o') {
+ openSource = true;
+ break;
+ }
+ }
+ }
+ if (openSource) {
+ dictionary["LICENSE FILE"] = sourcePath;
+ if (QFile::exists(dictionary["LICENSE FILE"] + "/LICENSE.GPL3") || QFile::exists(dictionary["LICENSE FILE"] + "/LICENSE.LGPL")) {
+ cout << endl << "This is the " << dictionary["PLATFORM NAME"] << " Open Source Edition." << endl;
+ licenseInfo["LICENSEE"] = "Open Source";
+ dictionary["EDITION"] = "OpenSource";
+ dictionary["QT_EDITION"] = "QT_EDITION_OPENSOURCE";
+ cout << endl;
+ if (!showLicense(dictionary["LICENSE FILE"])) {
+ cout << "Configuration aborted since license was not accepted";
+ dictionary["DONE"] = "error";
+ return;
+ }
+ return;
+ }
+#ifndef COMMERCIAL_VERSION
+ else {
+ cout << endl << "Cannot find the GPL license files!" << endl;
+ dictionary["DONE"] = "error";
+ }
+#else
+ } else {
+ Tools::checkLicense(dictionary, licenseInfo, firstLicensePath());
+ if (dictionary["DONE"] != "error") {
+ // give the user some feedback, and prompt for license acceptance
+ cout << endl << "This is the " << dictionary["PLATFORM NAME"] << " " << dictionary["EDITION"] << " Edition."<< endl << endl;
+ if (!showLicense(dictionary["LICENSE FILE"])) {
+ cout << "Configuration aborted since license was not accepted";
+ dictionary["DONE"] = "error";
+ return;
+ }
+ }
+ }
+#endif // COMMERCIAL_VERSION
+}
+
+void Configure::reloadCmdLine()
+{
+ if( dictionary[ "REDO" ] == "yes" ) {
+ QFile inFile( buildPath + "/configure" + dictionary[ "CUSTOMCONFIG" ] + ".cache" );
+ if( inFile.open( QFile::ReadOnly ) ) {
+ QTextStream inStream( &inFile );
+ QString buffer;
+ inStream >> buffer;
+ while( buffer.length() ) {
+ configCmdLine += buffer;
+ inStream >> buffer;
+ }
+ inFile.close();
+ }
+ }
+}
+
+void Configure::saveCmdLine()
+{
+ if( dictionary[ "REDO" ] != "yes" ) {
+ QFile outFile( buildPath + "/configure" + dictionary[ "CUSTOMCONFIG" ] + ".cache" );
+ if( outFile.open( QFile::WriteOnly | QFile::Text ) ) {
+ QTextStream outStream( &outFile );
+ for( QStringList::Iterator it = configCmdLine.begin(); it != configCmdLine.end(); ++it ) {
+ outStream << (*it) << " " << endl;
+ }
+ outStream.flush();
+ outFile.close();
+ }
+ }
+}
+#endif // !EVAL
+
+bool Configure::isDone()
+{
+ return !dictionary["DONE"].isEmpty();
+}
+
+bool Configure::isOk()
+{
+ return (dictionary[ "DONE" ] != "error");
+}
+
+bool
+Configure::filesDiffer(const QString &fn1, const QString &fn2)
+{
+ QFile file1(fn1), file2(fn2);
+ if(!file1.open(QFile::ReadOnly) || !file2.open(QFile::ReadOnly))
+ return true;
+ const int chunk = 2048;
+ int used1 = 0, used2 = 0;
+ char b1[chunk], b2[chunk];
+ while(!file1.atEnd() && !file2.atEnd()) {
+ if(!used1)
+ used1 = file1.read(b1, chunk);
+ if(!used2)
+ used2 = file2.read(b2, chunk);
+ if(used1 > 0 && used2 > 0) {
+ const int cmp = qMin(used1, used2);
+ if(memcmp(b1, b2, cmp))
+ return true;
+ if((used1 -= cmp))
+ memcpy(b1, b1+cmp, used1);
+ if((used2 -= cmp))
+ memcpy(b2, b2+cmp, used2);
+ }
+ }
+ return !file1.atEnd() || !file2.atEnd();
+}
+
+QT_END_NAMESPACE
diff --git a/tools/configure/configureapp.h b/tools/configure/configureapp.h
new file mode 100644
index 0000000..e09ac56
--- /dev/null
+++ b/tools/configure/configureapp.h
@@ -0,0 +1,185 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qmap.h>
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qlist.h>
+#include <qtextstream.h>
+#include <qdir.h>
+
+QT_BEGIN_NAMESPACE
+
+class MakeItem;
+
+class Configure
+{
+public:
+ Configure( int& argc, char** argv );
+ ~Configure();
+
+ void parseCmdLine();
+#if !defined(EVAL)
+ void validateArgs();
+#endif
+ bool displayHelp();
+
+ QString defaultTo(const QString &option);
+ bool checkAvailability(const QString &part);
+ void autoDetection();
+ bool verifyConfiguration();
+
+ void generateOutputVars();
+#if !defined(EVAL)
+ void generateHeaders();
+ void generateBuildKey();
+ void generateCachefile();
+ void displayConfig();
+ void buildQmake();
+ void buildHostTools();
+#endif
+ void generateMakefiles();
+ void appendMakeItem(int inList, const QString &item);
+#if !defined(EVAL)
+ void generateConfigfiles();
+#endif
+ void showSummary();
+ void findProjects( const QString& dirName );
+ QString firstLicensePath();
+
+#if !defined(EVAL)
+ bool showLicense(QString licenseFile);
+ void readLicense();
+#endif
+
+ QString addDefine(QString def);
+
+ enum ProjectType {
+ App,
+ Lib,
+ Subdirs
+ };
+
+ ProjectType projectType( const QString& proFileName );
+ bool isDone();
+ bool isOk();
+private:
+ // Our variable dictionaries
+ QMap<QString,QString> dictionary;
+ QStringList licensedModules;
+ QStringList allSqlDrivers;
+ QStringList allConfigs;
+ QStringList disabledModules;
+ QStringList enabledModules;
+ QStringList modules;
+ QStringList disabledBuildParts;
+// QStringList sqlDrivers;
+ QStringList configCmdLine;
+ QStringList qmakeConfig;
+ QStringList qtConfig;
+
+ QStringList qmakeSql;
+ QStringList qmakeSqlPlugins;
+
+ QStringList qmakeStyles;
+ QStringList qmakeStylePlugins;
+
+ QStringList qmakeFormatPlugins;
+
+ QStringList qmakeVars;
+ QStringList qmakeDefines;
+ // makeList[0] for qt and qtmain
+ // makeList[1] for subdirs and libs
+ // makeList[2] for the rest
+ QList<MakeItem*> makeList[3];
+ QStringList qmakeIncludes;
+ QStringList qmakeLibs;
+ QString opensslLibs;
+
+ QMap<QString,QString> licenseInfo;
+ QString outputLine;
+
+ QTextStream outStream;
+ QString sourcePath, buildPath;
+ QDir sourceDir, buildDir;
+
+ // Variables for usage output
+ int optionIndent;
+ int descIndent;
+ int outputWidth;
+
+ bool useUnixSeparators;
+ QString fixSeparators(QString somePath);
+ bool filesDiffer(const QString &file1, const QString &file2);
+
+ static bool findFile(const QString &fileName);
+ static bool findFileInPaths(const QString &fileName, const QStringList &paths);
+#if !defined(EVAL)
+ void reloadCmdLine();
+ void saveCmdLine();
+#endif
+
+ void desc(const char *description, int startingAt = 0, int wrapIndent = 0);
+ void desc(const char *option, const char *description, bool skipIndent = false, char fillChar = '.');
+ void desc(const char *mark_option, const char *mark, const char *option, const char *description, char fillChar = '.');
+ void applySpecSpecifics();
+ static QString locateFile(const QString &fileName);
+ static QString locateFileInPaths(const QString &fileName, const QStringList &paths);
+};
+
+class MakeItem
+{
+public:
+ MakeItem( const QString &d, const QString &p, const QString &t, Configure::ProjectType qt )
+ : directory( d ),
+ proFile( p ),
+ target( t ),
+ qmakeTemplate( qt )
+ { }
+
+ QString directory;
+ QString proFile;
+ QString target;
+ Configure::ProjectType qmakeTemplate;
+};
+
+
+QT_END_NAMESPACE
diff --git a/tools/configure/environment.cpp b/tools/configure/environment.cpp
new file mode 100644
index 0000000..589b954
--- /dev/null
+++ b/tools/configure/environment.cpp
@@ -0,0 +1,686 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "environment.h"
+
+#include <process.h>
+#include <iostream>
+#include <qdebug.h>
+#include <QDir>
+#include <QStringList>
+#include <QMap>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+
+//#define CONFIGURE_DEBUG_EXECUTE
+//#define CONFIGURE_DEBUG_CP_DIR
+
+using namespace std;
+
+#ifdef Q_OS_WIN32
+#include <qt_windows.h>
+#endif
+
+
+QT_BEGIN_NAMESPACE
+
+struct CompilerInfo{
+ Compiler compiler;
+ const char *compilerStr;
+ const char *regKey;
+ const char *executable;
+} compiler_info[] = {
+ // The compilers here are sorted in a reversed-preferred order
+ {CC_BORLAND, "Borland C++", 0, "bcc32.exe"},
+ {CC_MINGW, "MinGW (Minimalist GNU for Windows)", 0, "mingw32-gcc.exe"},
+ {CC_INTEL, "Intel(R) C++ Compiler for 32-bit applications", 0, "icl.exe"}, // xilink.exe, xilink5.exe, xilink6.exe, xilib.exe
+ {CC_MSVC6, "Microsoft (R) 32-bit C/C++ Optimizing Compiler (6.x)", "Software\\Microsoft\\VisualStudio\\6.0\\Setup\\Microsoft Visual C++\\ProductDir", "cl.exe"}, // link.exe, lib.exe
+ {CC_NET2002, "Microsoft (R) 32-bit C/C++ Optimizing Compiler.NET 2002 (7.0)", "Software\\Microsoft\\VisualStudio\\7.0\\Setup\\VC\\ProductDir", "cl.exe"}, // link.exe, lib.exe
+ {CC_NET2003, "Microsoft (R) 32-bit C/C++ Optimizing Compiler.NET 2003 (7.1)", "Software\\Microsoft\\VisualStudio\\7.1\\Setup\\VC\\ProductDir", "cl.exe"}, // link.exe, lib.exe
+ {CC_NET2005, "Microsoft (R) 32-bit C/C++ Optimizing Compiler.NET 2005 (8.0)", "Software\\Microsoft\\VisualStudio\\SxS\\VC7\\8.0", "cl.exe"}, // link.exe, lib.exe
+ {CC_NET2008, "Microsoft (R) 32-bit C/C++ Optimizing Compiler.NET 2008 (9.0)", "Software\\Microsoft\\VisualStudio\\SxS\\VC7\\9.0", "cl.exe"}, // link.exe, lib.exe
+ {CC_UNKNOWN, "Unknown", 0, 0},
+};
+
+
+// Initialize static variables
+Compiler Environment::detectedCompiler = CC_UNKNOWN;
+
+/*!
+ Returns the pointer to the CompilerInfo for a \a compiler.
+*/
+CompilerInfo *Environment::compilerInfo(Compiler compiler)
+{
+ int i = 0;
+ while(compiler_info[i].compiler != compiler && compiler_info[i].compiler != CC_UNKNOWN)
+ ++i;
+ return &(compiler_info[i]);
+}
+
+/*!
+ Returns the path part of a registry key.
+ Ei.
+ For a key
+ "Software\\Microsoft\\VisualStudio\\8.0\\Setup\\VC\\ProductDir"
+ it returns
+ "Software\\Microsoft\\VisualStudio\\8.0\\Setup\\VC\\"
+*/
+QString Environment::keyPath(const QString &rKey)
+{
+ int idx = rKey.lastIndexOf(QLatin1Char('\\'));
+ if (idx == -1)
+ return QString();
+ return rKey.left(idx + 1);
+}
+
+/*!
+ Returns the name part of a registry key.
+ Ei.
+ For a key
+ "Software\\Microsoft\\VisualStudio\\8.0\\Setup\\VC\\ProductDir"
+ it returns
+ "ProductDir"
+*/
+QString Environment::keyName(const QString &rKey)
+{
+ int idx = rKey.lastIndexOf(QLatin1Char('\\'));
+ if (idx == -1)
+ return rKey;
+
+ QString res(rKey.mid(idx + 1));
+ if (res == "Default" || res == ".")
+ res = "";
+ return res;
+}
+
+/*!
+ Returns a registry keys value in string form.
+ If the registry key does not exist, or cannot be accessed, a
+ QString() is returned.
+*/
+QString Environment::readRegistryKey(HKEY parentHandle, const QString &rSubkey)
+{
+#ifndef Q_OS_WIN32
+ return QString();
+#else
+ QString rSubkeyName = keyName(rSubkey);
+ QString rSubkeyPath = keyPath(rSubkey);
+
+ HKEY handle = 0;
+ LONG res;
+ QT_WA( {
+ res = RegOpenKeyExW(parentHandle, (WCHAR*)rSubkeyPath.utf16(),
+ 0, KEY_READ, &handle);
+ } , {
+ res = RegOpenKeyExA(parentHandle, rSubkeyPath.toLocal8Bit(),
+ 0, KEY_READ, &handle);
+ } );
+
+ if (res != ERROR_SUCCESS)
+ return QString();
+
+ // get the size and type of the value
+ DWORD dataType;
+ DWORD dataSize;
+ QT_WA( {
+ res = RegQueryValueExW(handle, (WCHAR*)rSubkeyName.utf16(), 0, &dataType, 0, &dataSize);
+ }, {
+ res = RegQueryValueExA(handle, rSubkeyName.toLocal8Bit(), 0, &dataType, 0, &dataSize);
+ } );
+ if (res != ERROR_SUCCESS) {
+ RegCloseKey(handle);
+ return QString();
+ }
+
+ // get the value
+ QByteArray data(dataSize, 0);
+ QT_WA( {
+ res = RegQueryValueExW(handle, (WCHAR*)rSubkeyName.utf16(), 0, 0,
+ reinterpret_cast<unsigned char*>(data.data()), &dataSize);
+ }, {
+ res = RegQueryValueExA(handle, rSubkeyName.toLocal8Bit(), 0, 0,
+ reinterpret_cast<unsigned char*>(data.data()), &dataSize);
+ } );
+ if (res != ERROR_SUCCESS) {
+ RegCloseKey(handle);
+ return QString();
+ }
+
+ QString result;
+ switch (dataType) {
+ case REG_EXPAND_SZ:
+ case REG_SZ: {
+ QT_WA( {
+ result = QString::fromUtf16(((const ushort*)data.constData()));
+ }, {
+ result = QString::fromLatin1(data.constData());
+ } );
+ break;
+ }
+
+ case REG_MULTI_SZ: {
+ QStringList l;
+ int i = 0;
+ for (;;) {
+ QString s;
+ QT_WA( {
+ s = QString::fromUtf16((const ushort*)data.constData() + i);
+ }, {
+ s = QString::fromLatin1(data.constData() + i);
+ } );
+ i += s.length() + 1;
+
+ if (s.isEmpty())
+ break;
+ l.append(s);
+ }
+ result = l.join(", ");
+ break;
+ }
+
+ case REG_NONE:
+ case REG_BINARY: {
+ QT_WA( {
+ result = QString::fromUtf16((const ushort*)data.constData(), data.size()/2);
+ }, {
+ result = QString::fromLatin1(data.constData(), data.size());
+ } );
+ break;
+ }
+
+ case REG_DWORD_BIG_ENDIAN:
+ case REG_DWORD: {
+ Q_ASSERT(data.size() == sizeof(int));
+ int i;
+ memcpy((char*)&i, data.constData(), sizeof(int));
+ result = QString::number(i);
+ break;
+ }
+
+ default:
+ qWarning("QSettings: unknown data %d type in windows registry", dataType);
+ break;
+ }
+
+ RegCloseKey(handle);
+ return result;
+#endif
+}
+
+/*!
+ Returns the qmakespec for the compiler detected on the system.
+*/
+QString Environment::detectQMakeSpec()
+{
+ QString spec;
+ switch (detectCompiler()) {
+ case CC_NET2008:
+ spec = "win32-msvc2008";
+ break;
+ case CC_NET2005:
+ spec = "win32-msvc2005";
+ break;
+ case CC_NET2003:
+ spec = "win32-msvc2003";
+ break;
+ case CC_NET2002:
+ spec = "win32-msvc2002";
+ break;
+ case CC_MSVC4:
+ case CC_MSVC5:
+ case CC_MSVC6:
+ spec = "win32-msvc";
+ break;
+ case CC_INTEL:
+ spec = "win32-icc";
+ break;
+ case CC_MINGW:
+ spec = "win32-g++";
+ break;
+ case CC_BORLAND:
+ spec = "win32-borland";
+ break;
+ default:
+ break;
+ }
+
+ return spec;
+}
+
+/*!
+ Returns the enum of the compiler which was detected on the system.
+ The compilers are detected in the order as entered into the
+ compiler_info list.
+
+ If more than one compiler is found, CC_UNKNOWN is returned.
+*/
+Compiler Environment::detectCompiler()
+{
+#ifndef Q_OS_WIN32
+ return MSVC6; // Always generate MSVC 6.0 versions on other platforms
+#else
+ if(detectedCompiler != CC_UNKNOWN)
+ return detectedCompiler;
+
+ int installed = 0;
+
+ // Check for compilers in registry first, to see which version is in PATH
+ QString paths = qgetenv("PATH");
+ QStringList pathlist = paths.toLower().split(";");
+ for(int i = 0; compiler_info[i].compiler; ++i) {
+ QString productPath = readRegistryKey(HKEY_LOCAL_MACHINE, compiler_info[i].regKey).toLower();
+ if (productPath.length()) {
+ QStringList::iterator it;
+ for(it = pathlist.begin(); it != pathlist.end(); ++it) {
+ if((*it).contains(productPath)) {
+ ++installed;
+ detectedCompiler = compiler_info[i].compiler;
+ break;
+ }
+ }
+ }
+ }
+
+ // Now just go looking for the executables, and accept any executable as the lowest version
+ if (!installed) {
+ for(int i = 0; compiler_info[i].compiler; ++i) {
+ QString executable = QString(compiler_info[i].executable).toLower();
+ if (executable.length() && Environment::detectExecutable(executable)) {
+ ++installed;
+ detectedCompiler = compiler_info[i].compiler;
+ break;
+ }
+ }
+ }
+
+ if (installed > 1) {
+ cout << "Found more than one known compiler! Using \"" << compilerInfo(detectedCompiler)->compilerStr << "\"" << endl;
+ detectedCompiler = CC_UNKNOWN;
+ }
+ return detectedCompiler;
+#endif
+};
+
+/*!
+ Returns true if the \a executable could be loaded, else false.
+ This means that the executable either is in the current directory
+ or in the PATH.
+*/
+bool Environment::detectExecutable(const QString &executable)
+{
+ PROCESS_INFORMATION procInfo;
+ memset(&procInfo, 0, sizeof(procInfo));
+
+ bool couldExecute;
+ QT_WA({
+ // Unicode version
+ STARTUPINFOW startInfo;
+ memset(&startInfo, 0, sizeof(startInfo));
+ startInfo.cb = sizeof(startInfo);
+
+ couldExecute = CreateProcessW(0, (WCHAR*)executable.utf16(),
+ 0, 0, false,
+ CREATE_NO_WINDOW | CREATE_SUSPENDED,
+ 0, 0, &startInfo, &procInfo);
+
+ }, {
+ // Ansi version
+ STARTUPINFOA startInfo;
+ memset(&startInfo, 0, sizeof(startInfo));
+ startInfo.cb = sizeof(startInfo);
+
+ couldExecute = CreateProcessA(0, executable.toLocal8Bit().data(),
+ 0, 0, false,
+ CREATE_NO_WINDOW | CREATE_SUSPENDED,
+ 0, 0, &startInfo, &procInfo);
+ })
+
+ if (couldExecute) {
+ CloseHandle(procInfo.hThread);
+ TerminateProcess(procInfo.hProcess, 0);
+ CloseHandle(procInfo.hProcess);
+ }
+ return couldExecute;
+}
+
+/*!
+ Creates a commandling from \a program and it \a arguments,
+ escaping characters that needs it.
+*/
+static QString qt_create_commandline(const QString &program, const QStringList &arguments)
+{
+ QString programName = program;
+ if (!programName.startsWith("\"") && !programName.endsWith("\"") && programName.contains(" "))
+ programName = "\"" + programName + "\"";
+ programName.replace("/", "\\");
+
+ QString args;
+ // add the prgram as the first arrg ... it works better
+ args = programName + " ";
+ for (int i=0; i<arguments.size(); ++i) {
+ QString tmp = arguments.at(i);
+ // in the case of \" already being in the string the \ must also be escaped
+ tmp.replace( "\\\"", "\\\\\"" );
+ // escape a single " because the arguments will be parsed
+ tmp.replace( "\"", "\\\"" );
+ if (tmp.isEmpty() || tmp.contains(' ') || tmp.contains('\t')) {
+ // The argument must not end with a \ since this would be interpreted
+ // as escaping the quote -- rather put the \ behind the quote: e.g.
+ // rather use "foo"\ than "foo\"
+ QString endQuote("\"");
+ int i = tmp.length();
+ while (i>0 && tmp.at(i-1) == '\\') {
+ --i;
+ endQuote += "\\";
+ }
+ args += QString(" \"") + tmp.left(i) + endQuote;
+ } else {
+ args += ' ' + tmp;
+ }
+ }
+ return args;
+}
+
+/*!
+ Creates a QByteArray of the \a environment in either UNICODE or
+ ansi representation.
+*/
+static QByteArray qt_create_environment(const QStringList &environment)
+{
+ QByteArray envlist;
+ if (!environment.isEmpty()) {
+ int pos = 0;
+ // add PATH if necessary (for DLL loading)
+ QByteArray path = qgetenv("PATH");
+ QT_WA({
+ if (environment.filter(QRegExp("^PATH=",Qt::CaseInsensitive)).isEmpty()
+ && !path.isNull()) {
+ QString tmp = QString(QLatin1String("PATH=%1")).arg(QString::fromLocal8Bit(path));
+ uint tmpSize = sizeof(TCHAR) * (tmp.length()+1);
+ envlist.resize(envlist.size() + tmpSize );
+ memcpy(envlist.data()+pos, tmp.utf16(), tmpSize);
+ pos += tmpSize;
+ }
+ // add the user environment
+ for (QStringList::ConstIterator it = environment.begin(); it != environment.end(); it++ ) {
+ QString tmp = *it;
+ uint tmpSize = sizeof(TCHAR) * (tmp.length()+1);
+ envlist.resize(envlist.size() + tmpSize);
+ memcpy(envlist.data()+pos, tmp.utf16(), tmpSize);
+ pos += tmpSize;
+ }
+ // add the 2 terminating 0 (actually 4, just to be on the safe side)
+ envlist.resize( envlist.size()+4 );
+ envlist[pos++] = 0;
+ envlist[pos++] = 0;
+ envlist[pos++] = 0;
+ envlist[pos++] = 0;
+ }, {
+ if (environment.filter(QRegExp("^PATH=",Qt::CaseInsensitive)).isEmpty() && !path.isNull()) {
+ QByteArray tmp = QString("PATH=%1").arg(QString::fromLocal8Bit(path)).toLocal8Bit();
+ uint tmpSize = tmp.length() + 1;
+ envlist.resize(envlist.size() + tmpSize);
+ memcpy(envlist.data()+pos, tmp.data(), tmpSize);
+ pos += tmpSize;
+ }
+ // add the user environment
+ for (QStringList::ConstIterator it = environment.begin(); it != environment.end(); it++) {
+ QByteArray tmp = (*it).toLocal8Bit();
+ uint tmpSize = tmp.length() + 1;
+ envlist.resize(envlist.size() + tmpSize);
+ memcpy(envlist.data()+pos, tmp.data(), tmpSize);
+ pos += tmpSize;
+ }
+ // add the terminating 0 (actually 2, just to be on the safe side)
+ envlist.resize(envlist.size()+2);
+ envlist[pos++] = 0;
+ envlist[pos++] = 0;
+ })
+ }
+
+ return envlist;
+}
+
+/*!
+ Executes the command described in \a arguments, in the
+ environment inherited from the parent process, with the
+ \a additionalEnv settings applied.
+ \a removeEnv removes the specified environment variables from
+ the environment of the executed process.
+
+ Returns the exit value of the process, or -1 if the command could
+ not be executed.
+
+ This function uses _(w)spawnvpe to spawn a process by searching
+ through the PATH environment variable.
+*/
+int Environment::execute(QStringList arguments, const QStringList &additionalEnv, const QStringList &removeEnv)
+{
+#ifdef CONFIGURE_DEBUG_EXECUTE
+ qDebug() << "About to Execute: " << arguments;
+ qDebug() << " " << QDir::currentPath();
+ qDebug() << " " << additionalEnv;
+ qDebug() << " " << removeEnv;
+#endif
+// GetEnvironmentStrings is defined to GetEnvironmentStringsW when
+// UNICODE is defined. We cannot use that, since we need to
+// destinguish between unicode and ansi versions of the functions.
+#if defined(UNICODE) && defined(GetEnvironmentStrings)
+#undef GetEnvironmentStrings
+#endif
+
+ // Create the full environment from the current environment and
+ // the additionalEnv strings, then remove all variables defined
+ // in removeEnv
+ QMap<QString, QString> fullEnvMap;
+ QT_WA({
+ LPWSTR envStrings = GetEnvironmentStringsW();
+ if (envStrings) {
+ int strLen = 0;
+ for (LPWSTR envString = envStrings; *(envString); envString += strLen + 1) {
+ strLen = wcslen(envString);
+ QString str = QString((const QChar*)envString, strLen);
+ if (!str.startsWith("=")) { // These are added by the system
+ int sepIndex = str.indexOf('=');
+ fullEnvMap.insert(str.left(sepIndex).toUpper(), str.mid(sepIndex +1));
+ }
+ }
+ }
+ FreeEnvironmentStringsW(envStrings);
+ }, {
+ LPSTR envStrings = GetEnvironmentStrings();
+ if (envStrings) {
+ int strLen = 0;
+ for (LPSTR envString = envStrings; *(envString); envString += strLen + 1) {
+ strLen = strlen(envString);
+ QString str = QLatin1String(envString);
+ if (!str.startsWith("=")) { // These are added by the system
+ int sepIndex = str.indexOf('=');
+ fullEnvMap.insert(str.left(sepIndex).toUpper(), str.mid(sepIndex +1));
+ }
+ }
+ }
+ FreeEnvironmentStringsA(envStrings);
+ })
+ // Add additionalEnv variables
+ for (int i = 0; i < additionalEnv.count(); ++i) {
+ const QString &str = additionalEnv.at(i);
+ int sepIndex = str.indexOf('=');
+ fullEnvMap.insert(str.left(sepIndex).toUpper(), str.mid(sepIndex +1));
+ }
+
+ // Remove removeEnv variables
+ for (int j = 0; j < removeEnv.count(); ++j)
+ fullEnvMap.remove(removeEnv.at(j).toUpper());
+
+ // Add all variables to a QStringList
+ QStringList fullEnv;
+ QMapIterator<QString, QString> it(fullEnvMap);
+ while (it.hasNext()) {
+ it.next();
+ fullEnv += QString(it.key() + "=" + it.value());
+ }
+
+ // ----------------------------
+ QString program = arguments.takeAt(0);
+ QString args = qt_create_commandline(program, arguments);
+ QByteArray envlist = qt_create_environment(fullEnv);
+
+ DWORD exitCode = -1;
+ PROCESS_INFORMATION procInfo;
+ memset(&procInfo, 0, sizeof(procInfo));
+
+ bool couldExecute;
+ QT_WA({
+ // Unicode version
+ STARTUPINFOW startInfo;
+ memset(&startInfo, 0, sizeof(startInfo));
+ startInfo.cb = sizeof(startInfo);
+
+ couldExecute = CreateProcessW(0, (WCHAR*)args.utf16(),
+ 0, 0, true, CREATE_UNICODE_ENVIRONMENT,
+ envlist.isEmpty() ? 0 : envlist.data(),
+ 0, &startInfo, &procInfo);
+ }, {
+ // Ansi version
+ STARTUPINFOA startInfo;
+ memset(&startInfo, 0, sizeof(startInfo));
+ startInfo.cb = sizeof(startInfo);
+
+ couldExecute = CreateProcessA(0, args.toLocal8Bit().data(),
+ 0, 0, true, 0,
+ envlist.isEmpty() ? 0 : envlist.data(),
+ 0, &startInfo, &procInfo);
+ })
+
+ if (couldExecute) {
+ WaitForSingleObject(procInfo.hProcess, INFINITE);
+ GetExitCodeProcess(procInfo.hProcess, &exitCode);
+ CloseHandle(procInfo.hThread);
+ CloseHandle(procInfo.hProcess);
+ }
+
+
+ if (exitCode == -1) {
+ switch(GetLastError()) {
+ case E2BIG:
+ cerr << "execute: Argument list exceeds 1024 bytes" << endl;
+ foreach(QString arg, arguments)
+ cerr << " (" << arg.toLocal8Bit().constData() << ")" << endl;
+ break;
+ case ENOENT:
+ cerr << "execute: File or path is not found (" << program.toLocal8Bit().constData() << ")" << endl;
+ break;
+ case ENOEXEC:
+ cerr << "execute: Specified file is not executable or has invalid executable-file format (" << program.toLocal8Bit().constData() << ")" << endl;
+ break;
+ case ENOMEM:
+ cerr << "execute: Not enough memory is available to execute new process." << endl;
+ break;
+ default:
+ cerr << "execute: Unknown error" << endl;
+ foreach(QString arg, arguments)
+ cerr << " (" << arg.toLocal8Bit().constData() << ")" << endl;
+ break;
+ }
+ }
+ return exitCode;
+}
+
+bool Environment::cpdir(const QString &srcDir, const QString &destDir)
+{
+ QString cleanSrcName = QDir::cleanPath(srcDir);
+ QString cleanDstName = QDir::cleanPath(destDir);
+#ifdef CONFIGURE_DEBUG_CP_DIR
+ qDebug() << "Attempt to cpdir " << cleanSrcName << "->" << cleanDstName;
+#endif
+ if(!QFile::exists(cleanDstName) && !QDir().mkpath(cleanDstName)) {
+ qDebug() << "cpdir: Failure to create " << cleanDstName;
+ return false;
+ }
+
+ bool result = true;
+ QDir dir = QDir(cleanSrcName);
+ QFileInfoList allEntries = dir.entryInfoList(QDir::AllDirs | QDir::Files | QDir::NoDotAndDotDot);
+ for (int i = 0; result && (i < allEntries.count()); ++i) {
+ QFileInfo entry = allEntries.at(i);
+ bool intermediate = true;
+ if (entry.isDir()) {
+ intermediate = cpdir(QString("%1/%2").arg(cleanSrcName).arg(entry.fileName()),
+ QString("%1/%2").arg(cleanDstName).arg(entry.fileName()));
+ } else {
+ QString destFile = QString("%1/%2").arg(cleanDstName).arg(entry.fileName());
+#ifdef CONFIGURE_DEBUG_CP_DIR
+ qDebug() << "About to cp (file)" << entry.absoluteFilePath() << "->" << destFile;
+#endif
+ QFile::remove(destFile);
+ intermediate = QFile::copy(entry.absoluteFilePath(), destFile);
+ SetFileAttributesA(destFile.toLocal8Bit(), FILE_ATTRIBUTE_NORMAL);
+ }
+ if(!intermediate) {
+ qDebug() << "cpdir: Failure for " << entry.fileName() << entry.isDir();
+ result = false;
+ }
+ }
+ return result;
+}
+
+bool Environment::rmdir(const QString &name)
+{
+ bool result = true;
+ QString cleanName = QDir::cleanPath(name);
+
+ QDir dir = QDir(cleanName);
+ QFileInfoList allEntries = dir.entryInfoList(QDir::AllDirs | QDir::Files | QDir::NoDotAndDotDot);
+ for (int i = 0; result && (i < allEntries.count()); ++i) {
+ QFileInfo entry = allEntries.at(i);
+ if (entry.isDir()) {
+ result &= rmdir(entry.absoluteFilePath());
+ } else {
+ result &= QFile::remove(entry.absoluteFilePath());
+ }
+ }
+ result &= dir.rmdir(cleanName);
+ return result;
+}
+
+QT_END_NAMESPACE
diff --git a/tools/configure/environment.h b/tools/configure/environment.h
new file mode 100644
index 0000000..08cff4c
--- /dev/null
+++ b/tools/configure/environment.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qstring.h>
+#include <qt_windows.h>
+
+QT_BEGIN_NAMESPACE
+
+
+enum Compiler {
+ CC_UNKNOWN = 0,
+ CC_BORLAND = 0x01,
+ CC_MINGW = 0x02,
+ CC_INTEL = 0x03,
+ CC_MSVC4 = 0x40,
+ CC_MSVC5 = 0x50,
+ CC_MSVC6 = 0x60,
+ CC_NET2002 = 0x70,
+ CC_NET2003 = 0x71,
+ CC_NET2005 = 0x80,
+ CC_NET2008 = 0x90
+};
+
+struct CompilerInfo;
+class Environment
+{
+public:
+ static Compiler detectCompiler();
+ static QString detectQMakeSpec();
+ static bool detectExecutable(const QString &executable);
+
+ static int execute(QStringList arguments, const QStringList &additionalEnv, const QStringList &removeEnv);
+ static bool cpdir(const QString &srcDir, const QString &destDir);
+ static bool rmdir(const QString &name);
+
+private:
+ static Compiler detectedCompiler;
+
+ static CompilerInfo *compilerInfo(Compiler compiler);
+ static QString keyPath(const QString &rKey);
+ static QString keyName(const QString &rKey);
+ static QString readRegistryKey(HKEY parentHandle, const QString &rSubkey);
+};
+
+
+QT_END_NAMESPACE
diff --git a/tools/configure/main.cpp b/tools/configure/main.cpp
new file mode 100644
index 0000000..d91e124
--- /dev/null
+++ b/tools/configure/main.cpp
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*
+** Configure tool
+**
+*/
+
+#include "configureapp.h"
+
+QT_BEGIN_NAMESPACE
+
+int runConfigure( int argc, char** argv )
+{
+ Configure app( argc, argv );
+ if (!app.isOk())
+ return 3;
+
+ app.parseCmdLine();
+#if !defined(EVAL)
+ app.validateArgs();
+#endif
+ if( app.displayHelp() )
+ return 1;
+
+ // Read license now, and exit if it doesn't pass.
+ // This lets the user see the command-line options of configure
+ // without having to load and parse the license file.
+ app.readLicense();
+ if (!app.isOk())
+ return 3;
+
+ // Auto-detect modules and settings.
+ app.autoDetection();
+
+ // After reading all command-line arguments, and doing all the
+ // auto-detection, it's time to do some last minute validation.
+ // If the validation fails, we cannot continue.
+ if (!app.verifyConfiguration())
+ return 3;
+
+ app.generateOutputVars();
+
+#if !defined(EVAL)
+ if( !app.isDone() )
+ app.generateCachefile();
+ if( !app.isDone() )
+ app.generateBuildKey();
+ if( !app.isDone() )
+ app.generateConfigfiles();
+ if( !app.isDone() )
+ app.displayConfig();
+ if( !app.isDone() )
+ app.generateHeaders();
+ if( !app.isDone() )
+ app.buildQmake();
+ if( !app.isOk() )
+ return 2;
+#endif
+ if( !app.isDone() )
+ app.generateMakefiles();
+ if( app.isOk() )
+ app.buildHostTools();
+ if( !app.isDone() )
+ app.showSummary();
+
+ return 0;
+}
+
+QT_END_NAMESPACE
+
+int main( int argc, char** argv )
+{
+ QT_USE_NAMESPACE
+ return runConfigure(argc, argv);
+}
diff --git a/tools/configure/tools.cpp b/tools/configure/tools.cpp
new file mode 100644
index 0000000..ae1ecda
--- /dev/null
+++ b/tools/configure/tools.cpp
@@ -0,0 +1,172 @@
+#include "tools.h"
+
+#include <QDir>
+#include <QFile>
+#include <QByteArray>
+
+
+// std stuff ------------------------------------
+#include <iostream>
+#include <windows.h>
+#include <conio.h>
+#define NUMBER_OF_PARTS 7
+
+std::ostream &operator<<(std::ostream &s, const QString &val); // defined in configureapp.cpp
+using namespace std;
+
+void Tools::checkLicense(QMap<QString,QString> &dictionary, QMap<QString,QString> &licenseInfo,
+ const QString &path)
+{
+ QString tpLicense = dictionary["QT_SOURCE_TREE"] + "/LICENSE.PREVIEW.OPENSOURCE";
+ if (QFile::exists(tpLicense)) {
+ dictionary["EDITION"] = "Preview";
+ dictionary["LICENSE FILE"] = tpLicense;
+ dictionary["QT_EDITION"] = "QT_EDITION_OPENSOURCE";
+ return; // No license key checking in Tech Preview
+ }
+ tpLicense = dictionary["QT_SOURCE_TREE"] + "/LICENSE.PREVIEW.COMMERCIAL";
+ if (QFile::exists(tpLicense)) {
+ dictionary["EDITION"] = "Preview";
+ dictionary["LICENSE FILE"] = tpLicense;
+ dictionary["QT_EDITION"] = "QT_EDITION_DESKTOP";
+ return; // No license key checking in Tech Preview
+ }
+
+ // Read in the license file
+ QFile licenseFile(path);
+ if( !path.isEmpty() && licenseFile.open( QFile::ReadOnly ) ) {
+ cout << "Reading license file in....." << qPrintable(path) << endl;
+
+ QString buffer = licenseFile.readLine(1024);
+ while (!buffer.isEmpty()) {
+ if( buffer[ 0 ] != '#' ) {
+ QStringList components = buffer.split( '=' );
+ if ( components.size() >= 2 ) {
+ QStringList::Iterator it = components.begin();
+ QString key = (*it++).trimmed().replace( "\"", QString() ).toUpper();
+ QString value = (*it++).trimmed().replace( "\"", QString() );
+ licenseInfo[ key ] = value;
+ }
+ }
+ // read next line
+ buffer = licenseFile.readLine(1024);
+ }
+ licenseFile.close();
+ } else {
+ cout << "License file not found in " << QDir::homePath() << endl;
+ cout << "Please put the Qt license file, '.qt-license' in your home "
+ << "directory and run configure again.";
+ dictionary["DONE"] = "error";
+ return;
+ }
+
+ // Verify license info...
+ QString licenseKey = licenseInfo["LICENSEKEYEXT"];
+ const char * clicenseKey = licenseKey.toLatin1();
+ //We check the licence
+#ifndef _WIN32_WCE
+ char *buffer = strdup(clicenseKey);
+#else
+ char *buffer = (char*) malloc(strlen(clicenseKey) + 1);
+ strcpy(buffer, clicenseKey);
+#endif
+ static const char * const SEP = "-";
+ char *licenseParts[NUMBER_OF_PARTS];
+ int partNumber = 0;
+ for (char *part = strtok(buffer, SEP); part != 0; part = strtok(0, SEP))
+ licenseParts[partNumber++] = part;
+ if (partNumber < (NUMBER_OF_PARTS-1)) {
+ dictionary["DONE"] = "error";
+ cout << "License file does not contain proper license key." <<partNumber<< endl;
+ free(buffer);
+ return;
+ }
+
+ char products = licenseParts[0][0];
+ char platforms = licenseParts[1][0];
+ char* licenseSchema = licenseParts[2];
+ char licenseFeatures = licenseParts[3][0];
+
+ // Determine edition ---------------------------------------------------------------------------
+ QString licenseType;
+ if (strcmp(licenseSchema,"F4M") == 0) {
+ licenseType = "Commercial";
+ if (products == 'F') {
+ dictionary["EDITION"] = "Universal";
+ dictionary["QT_EDITION"] = "QT_EDITION_UNIVERSAL";
+ } else if (products == 'B') {
+ dictionary["EDITION"] = "FullFramework";
+ dictionary["QT_EDITION"] = "QT_EDITION_DESKTOP";
+ } else {
+ dictionary["EDITION"] = "GUIFramework";
+ dictionary["QT_EDITION"] = "QT_EDITION_DESKTOPLIGHT";
+ }
+ } else if (strcmp(licenseSchema,"Z4M") == 0 || strcmp(licenseSchema,"R4M") == 0 || strcmp(licenseSchema,"Q4M") == 0) {
+ if (products == 'B') {
+ dictionary["EDITION"] = "Evaluation";
+ dictionary["QT_EDITION"] = "QT_EDITION_EVALUATION";
+ }
+ }
+
+ // Determine license extension -----------------------------------------------------------------
+ if (QFile::exists(dictionary["QT_SOURCE_TREE"] + "/.LICENSE")) {
+ // Generic, no-suffix license
+ dictionary["LICENSE_EXTENSION"] = QString();
+ } else if (platforms == 'X') {
+ dictionary["LICENSE_EXTENSION"] = "-ALLOS";
+ } else if (/*Windows CE */platforms == '6' || /*Embedded */ platforms == '8' || /*Embedded + Windows CE*/platforms == 'K' || /*Windows + Windows CE*/ platforms == 'H') {
+ dictionary["LICENSE_EXTENSION"] = "-EMBEDDED";
+ } else if (/*Windows*/ platforms == 'R' || /*Mac+X11+Windows*/ platforms == 'F') {
+ dictionary["LICENSE_EXTENSION"] = "-DESKTOP";
+ } else if (dictionary["EDITION"] == "Evaluation") {
+ dictionary["LICENSE_EXTENSION"] = "-EVALUATION";
+ }
+ if (licenseType.isEmpty()
+ || dictionary["EDITION"].isEmpty()
+ || dictionary["QT_EDITION"].isEmpty()) {
+ cout << "License file does not contain proper license key." << endl;
+ dictionary["DONE"] = "error";
+ return;
+ }
+
+ // verify that we are licensed to use Qt for Windows
+ if (dictionary["PLATFORM NAME"].contains("Windows CE")) {
+ // verify that we are licensed to use Qt for Windows AND Qt for Windows CE
+ if (platforms != 'H') {
+ cout << "You are not licensed for the " << dictionary["PLATFORM NAME"] << " platform." << endl << endl;
+ cout << "Please contact sales@trolltech.com to upgrade your license" << endl;
+ cout << "to include the " << dictionary["PLATFORM NAME"] << " platform, or install the" << endl;
+ cout << "Qt Open Source Edition if you intend to develop free software." << endl;
+ dictionary["DONE"] = "error";
+ return;
+ }
+ } else {
+ if (!( platforms == 'R' || ( platforms == '6' )|| platforms == '8' )) {
+ cout << "You are not licensed for the " << dictionary["PLATFORM NAME"] << " platform." << endl << endl;
+ cout << "Please contact sales@trolltech.com to upgrade your license" << endl;
+ cout << "to include the " << dictionary["PLATFORM NAME"] << " platform, or install the" << endl;
+ cout << "Qt Open Source Edition if you intend to develop free software." << endl;
+ dictionary["DONE"] = "error";
+ return;
+ }
+ }
+
+ // copy one of .LICENSE-*(-US) to LICENSE
+ QString toLicenseFile = dictionary["QT_SOURCE_TREE"] + "/LICENSE";
+ QString fromLicenseFile = dictionary["QT_SOURCE_TREE"] + "/.LICENSE" + dictionary["LICENSE_EXTENSION"];
+ if (licenseFeatures == 'G') //US
+ fromLicenseFile += "-US";
+
+ if (licenseFeatures == '5') //Floating
+ dictionary["METERED LICENSE"] = "true";
+
+ if (!CopyFileA(QDir::toNativeSeparators(fromLicenseFile).toLocal8Bit(),
+ QDir::toNativeSeparators(toLicenseFile).toLocal8Bit(), FALSE)) {
+ cout << "Failed to copy license file (" << fromLicenseFile << ")";
+ dictionary["DONE"] = "error";
+ return;
+ }
+ dictionary["LICENSE FILE"] = toLicenseFile;
+ free(buffer);
+}
+
diff --git a/tools/configure/tools.h b/tools/configure/tools.h
new file mode 100644
index 0000000..e95ff13
--- /dev/null
+++ b/tools/configure/tools.h
@@ -0,0 +1,17 @@
+#ifndef _TOOLS_H_
+#define _TOOLS_H_
+
+#include <QString>
+#include <QStringList>
+#include <QMap>
+
+
+class Tools
+{
+public:
+ static void checkLicense(QMap<QString,QString> &dictionary, QMap<QString,QString> &licenseInfo,
+ const QString &path);
+};
+
+#endif // _TOOLS_H_
+
generated by cgit v0.12 at 2024-12-04 05:29:20 (GMT)