59 #include <windows.h>

    59 #include <windows.h>

    60 #include <conio.h>

    60 #include <conio.h>

    61 

    61 

    62 QT_BEGIN_NAMESPACE

    62 QT_BEGIN_NAMESPACE

    63 

    63 

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

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

    66     return s;

    66     return s;

    67 }

    67 }

    68 

    68 

    69 

    69 

    87     }

    87     }

    88     file.write(symFile);

    88     file.write(symFile);

    89     return true;

    89     return true;

    90 }

    90 }

    91 

    91 

    93 {

    93 {

    94     useUnixSeparators = false;

    94     useUnixSeparators = false;

    95     // Default values for indentation

    95     // Default values for indentation

    96     optionIndent = 4;

    96     optionIndent = 4;

    97     descIndent   = 25;

    97     descIndent   = 25;

   109     /*

   109     /*

   110     ** Set up the initial state, the default

   110     ** Set up the initial state, the default

   111     */

   111     */

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

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

   113 

   113 

   115         configCmdLine += argv[ i ];

   115         configCmdLine += argv[ i ];

   116 

   116 

   117 

   117 

   118     // Get the path to the executable

   118     // Get the path to the executable

   119     wchar_t module_name[MAX_PATH];

   119     wchar_t module_name[MAX_PATH];

   125 #if 0

   125 #if 0

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

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

   127 #else

   127 #else

   128     const QString installPath = buildPath;

   128     const QString installPath = buildPath;

   129 #endif

   129 #endif

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

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

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

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

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

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

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

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

   135         }

   135         }

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

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

   139 

   139 

   140         { //duplicate qmake

   140         { //duplicate qmake

   141             QStack<QString> qmake_dirs;

   141             QStack<QString> qmake_dirs;

   142             qmake_dirs.push("qmake");

   142             qmake_dirs.push("qmake");

   144                 QString dir = qmake_dirs.pop();

   144                 QString dir = qmake_dirs.pop();

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

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

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

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

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

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

   149                     QFileInfo fi(entries.at(i));

   149                     QFileInfo fi(entries.at(i));

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

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

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

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

   153                     } else {

   153                     } else {

   155                         bool justCopy = true;

   155                         bool justCopy = true;

   156                         const QString fname = fi.fileName();

   156                         const QString fname = fi.fileName();

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

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

   160                             QTemporaryFile tmpFile;

   160                             QTemporaryFile tmpFile;

   162                                 QTextStream stream(&tmpFile);

   162                                 QTextStream stream(&tmpFile);

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

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

   164                                 justCopy = false;

   164                                 justCopy = false;

   165                                 stream.flush();

   165                                 stream.flush();

   166                                 tmpFile.flush();

   166                                 tmpFile.flush();

   168                                     QFile::remove(outFile);

   168                                     QFile::remove(outFile);

   169                                     tmpFile.copy(outFile);

   169                                     tmpFile.copy(outFile);

   170                                 }

   170                                 }

   171                             }

   171                             }

   172                         }

   172                         }

   174                             QFile::copy(inFile, outFile);

   174                             QFile::copy(inFile, outFile);

   175                     }

   175                     }

   176                 }

   176                 }

   177             }

   177             }

   178         }

   178         }

   179 

   179 

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

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

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

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

   183                 QTextStream stream(&syncqt);

   183                 QTextStream stream(&syncqt);

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

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

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

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

   186             }

   186             }

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

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

   189                 QTextStream stream(&syncqt_bat);

   189                 QTextStream stream(&syncqt_bat);

   190                 stream << "@echo off" << endl

   190                 stream << "@echo off" << endl

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

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

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

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

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

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

   195             }

   195             }

   196         }

   196         }

   197 

   197 

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

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

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

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

   201             QTextStream stream(&patch_capabilities);

   201             QTextStream stream(&patch_capabilities);

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

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

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

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

   204         }

   204         }

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

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

   207             QTextStream stream(&patch_capabilities_bat);

   207             QTextStream stream(&patch_capabilities_bat);

   208             stream << "@echo off" << endl

   208             stream << "@echo off" << endl

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

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

   210             patch_capabilities_bat.close();

   210             patch_capabilities_bat.close();

   211         }

   211         }

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

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

   214             QTextStream stream(&createpackage);

   214             QTextStream stream(&createpackage);

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

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

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

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

   217         }

   217         }

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

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

   220             QTextStream stream(&createpackage_bat);

   220             QTextStream stream(&createpackage_bat);

   221             stream << "@echo off" << endl

   221             stream << "@echo off" << endl

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

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

   223             createpackage_bat.close();

   223             createpackage_bat.close();

   224         }

   224         }

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

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

   227         // build directory.

   227         // build directory.

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

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

   229         //copy the mkspecs

   229         //copy the mkspecs

   230         buildDir.mkpath("mkspecs");

   230         buildDir.mkpath("mkspecs");

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

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

   233             dictionary["DONE"] = "error";

   233             dictionary["DONE"] = "error";

   234             return;

   234             return;

   235         }

   235         }

   236     }

   236     }

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

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

   303 

   303 

   304     dictionary[ "VERSION" ]         = version;

   304     dictionary[ "VERSION" ]         = version;

   305     {

   305     {

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

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

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

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

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

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

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

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

   311         }

   311         }

   312     }

   312     }

   370     dictionary[ "SQL_IBASE" ]       = "no";

   370     dictionary[ "SQL_IBASE" ]       = "no";

   371     dictionary[ "GRAPHICS_SYSTEM" ] = "raster";

   371     dictionary[ "GRAPHICS_SYSTEM" ] = "raster";

   372 

   372 

   373     QString tmp = dictionary[ "QMAKESPEC" ];

   373     QString tmp = dictionary[ "QMAKESPEC" ];

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

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

   376     } else {

   376     } else {

   378     }

   378     }

   379     dictionary[ "QMAKESPEC" ] = tmp;

   379     dictionary[ "QMAKESPEC" ] = tmp;

   380 

   380 

   381     dictionary[ "INCREDIBUILD_XGE" ] = "auto";

   381     dictionary[ "INCREDIBUILD_XGE" ] = "auto";

   382     dictionary[ "LTCG" ]            = "no";

   382     dictionary[ "LTCG" ]            = "no";

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

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

   391             delete items[j];

   391             delete items[j];

   392     }

   392     }

   393 }

   393 }

   394 

   394 

   400 }

   408 }

   401 

   409 

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

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

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

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

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

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

   429     int i = 0;

   437     int i = 0;

   430 

   438 

   431 #if !defined(EVAL)

   439 #if !defined(EVAL)

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

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

   433         ;

   441         ;

   435         dictionary[ "REDO" ] = "yes";

   443         dictionary[ "REDO" ] = "yes";

   436         configCmdLine.clear();

   444         configCmdLine.clear();

   437         reloadCmdLine();

   445         reloadCmdLine();

   438     }

   446     }

   440         ++i;

   448         ++i;

   441         if (i != argCount) {

   449         if (i != argCount) {

   442             dictionary[ "REDO" ] = "yes";

   450             dictionary[ "REDO" ] = "yes";

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

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

   444             configCmdLine.clear();

   452             configCmdLine.clear();

   450     }

   458     }

   451     argCount = configCmdLine.size();

   459     argCount = configCmdLine.size();

   452 #endif

   460 #endif

   453 

   461 

   454     // Look first for XQMAKESPEC

   462     // Look first for XQMAKESPEC

   456     {

   464     {

   458             ++j;

   466             ++j;

   459             if (j == argCount)

   467             if (j == argCount)

   460                 break;

   468                 break;

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

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

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

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

   463                 applySpecSpecifics();

   471                 applySpecSpecifics();

   464         }

   472         }

   465     }

   473     }

   466 

   474 

   468         bool continueElse[] = {false, false};

   476         bool continueElse[] = {false, false};

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

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

   472             dictionary[ "HELP" ] = "yes";

   480             dictionary[ "HELP" ] = "yes";

   473 

   481 

   474 #if !defined(EVAL)

   482 #if !defined(EVAL)

   476             ++i;

   484             ++i;

   478                 break;

   486                 break;

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

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

   480         }

   488         }

   481 

   489 

   483             ++i;

   491             ++i;

   485                 break;

   493                 break;

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

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

   487         }

   495         }

   488 

   496 

   490             dictionary[ "BUILD" ] = "release";

   498             dictionary[ "BUILD" ] = "release";

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

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

   492                 dictionary[ "BUILDALL" ] = "no";

   500                 dictionary[ "BUILDALL" ] = "no";

   494             dictionary[ "BUILD" ] = "debug";

   502             dictionary[ "BUILD" ] = "debug";

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

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

   496                 dictionary[ "BUILDALL" ] = "no";

   504                 dictionary[ "BUILDALL" ] = "no";

   498             dictionary[ "BUILDALL" ] = "yes";

   506             dictionary[ "BUILDALL" ] = "yes";

   499 

   507 

   501             dictionary[ "SHARED" ] = "yes";

   509             dictionary[ "SHARED" ] = "yes";

   503             dictionary[ "SHARED" ] = "no";

   511             dictionary[ "SHARED" ] = "no";

   505             dictionary[ "BUILDDEV" ] = "yes";

   513             dictionary[ "BUILDDEV" ] = "yes";

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

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

   508             cout << "Nokia employees and agents are allowed to use this software under" << endl;

   516             cout << "Nokia employees and agents are allowed to use this software under" << endl;

   509             cout << "the authority of Nokia Corporation and/or its subsidiary(-ies)" << endl;

   517             cout << "the authority of Nokia Corporation and/or its subsidiary(-ies)" << endl;

   510             dictionary[ "BUILDNOKIA" ] = "yes";

   518             dictionary[ "BUILDNOKIA" ] = "yes";

   511             dictionary[ "BUILDDEV" ] = "yes";

   519             dictionary[ "BUILDDEV" ] = "yes";

   512             dictionary["LICENSE_CONFIRMED"] = "yes";

   520             dictionary["LICENSE_CONFIRMED"] = "yes";

   513             if (dictionary.contains("XQMAKESPEC") && dictionary["XQMAKESPEC"].startsWith("symbian")) {

   521             if (dictionary.contains("XQMAKESPEC") && dictionary["XQMAKESPEC"].startsWith("symbian")) {

   514                 dictionary[ "SYMBIAN_DEFFILES" ] = "no";

   522                 dictionary[ "SYMBIAN_DEFFILES" ] = "no";

   515             }

   523             }

   516         }

   524         }

   518             dictionary[ "BUILDTYPE" ] = "opensource";

   526             dictionary[ "BUILDTYPE" ] = "opensource";

   519         }

   527         }

   521             dictionary[ "BUILDTYPE" ] = "commercial";

   529             dictionary[ "BUILDTYPE" ] = "commercial";

   522         }

   530         }

   524             dictionary[ "LTCG" ] = "yes";

   532             dictionary[ "LTCG" ] = "yes";

   525         }

   533         }

   527             dictionary[ "LTCG" ] = "no";

   535             dictionary[ "LTCG" ] = "no";

   528         }

   536         }

   529 #endif

   537 #endif

   530 

   538 

   532             ++i;

   540             ++i;

   534                 break;

   542                 break;

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

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

   536         dictionary[ "QMAKESPEC_FROM" ] = "commandline";

   544         dictionary[ "QMAKESPEC_FROM" ] = "commandline";

   538             ++i;

   546             ++i;

   540                 break;

   548                 break;

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

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

   542             if (configCmdLine.at(i) == "boundschecker") {

   550             if (configCmdLine.at(i) == "boundschecker") {

   543                 dictionary[ "ARCHITECTURE" ] = "generic";   // Boundschecker uses the generic arch,

   551                 dictionary[ "ARCHITECTURE" ] = "generic";   // Boundschecker uses the generic arch,

   544                 qtConfig += "boundschecker";                // but also needs this CONFIG option

   552                 qtConfig += "boundschecker";                // but also needs this CONFIG option

   545             }

   553             }

   547             dictionary[ "EMBEDDED" ] = "yes";

   555             dictionary[ "EMBEDDED" ] = "yes";

   549             ++i;

   557             ++i;

   550             // do nothing

   558             // do nothing

   551         }

   559         }

   552 

   560 

   553 

   561 

   554 #if !defined(EVAL)

   562 #if !defined(EVAL)

   556             // No longer supported since Qt 4.4.0

   564             // No longer supported since Qt 4.4.0

   557             // But save the information for later so that we can print a warning

   565             // But save the information for later so that we can print a warning

   558             //

   566             //

   559             // If you REALLY really need no zlib support, you can still disable

   567             // If you REALLY really need no zlib support, you can still disable

   560             // it by doing the following:

   568             // it by doing the following:

   562             //   #define QT_NO_COMPRESS (probably by adding to src/corelib/global/qconfig.h)

   570             //   #define QT_NO_COMPRESS (probably by adding to src/corelib/global/qconfig.h)

   563             //

   571             //

   564             // There's no guarantee that Qt will build under those conditions

   572             // There's no guarantee that Qt will build under those conditions

   565 

   573 

   566             dictionary[ "ZLIB_FORCED" ] = "yes";

   574             dictionary[ "ZLIB_FORCED" ] = "yes";

   568             dictionary[ "ZLIB" ] = "qt";

   576             dictionary[ "ZLIB" ] = "qt";

   570             dictionary[ "ZLIB" ] = "system";

   578             dictionary[ "ZLIB" ] = "system";

   571         }

   579         }

   572 

   580 

   573         // Image formats --------------------------------------------

   581         // Image formats --------------------------------------------

   575             dictionary[ "GIF" ] = "no";

   583             dictionary[ "GIF" ] = "no";

   584             dictionary[ "LIBTIFF" ] = "qt";

   591             dictionary[ "LIBTIFF" ] = "qt";

   591             dictionary[ "JPEG" ] = "no";

   597             dictionary[ "JPEG" ] = "no";

   592             dictionary[ "LIBJPEG" ] = "no";

   598             dictionary[ "LIBJPEG" ] = "no";

   595             dictionary[ "LIBJPEG" ] = "qt";

   600             dictionary[ "LIBJPEG" ] = "qt";

   598             dictionary[ "LIBJPEG" ] = "system";

   602             dictionary[ "LIBJPEG" ] = "system";

   599         }

   603         }

   600 

   604 

   602             dictionary[ "PNG" ] = "no";

   606             dictionary[ "PNG" ] = "no";

   603             dictionary[ "LIBPNG" ] = "no";

   607             dictionary[ "LIBPNG" ] = "no";

   606             dictionary[ "LIBPNG" ] = "qt";

   609             dictionary[ "LIBPNG" ] = "qt";

   609             dictionary[ "LIBPNG" ] = "system";

   611             dictionary[ "LIBPNG" ] = "system";

   610         }

   612         }

   611 

   613 

   613             dictionary[ "MNG" ] = "no";

   615             dictionary[ "MNG" ] = "no";

   614             dictionary[ "LIBMNG" ] = "no";

   616             dictionary[ "LIBMNG" ] = "no";

   617             dictionary[ "LIBMNG" ] = "qt";

   618             dictionary[ "LIBMNG" ] = "qt";

   620             dictionary[ "LIBMNG" ] = "system";

   620             dictionary[ "LIBMNG" ] = "system";

   621         }

   621         }

   622 

   622 

   623         // Text Rendering --------------------------------------------

   623         // Text Rendering --------------------------------------------

   625             dictionary[ "FREETYPE" ] = "no";

   625             dictionary[ "FREETYPE" ] = "no";

   627             dictionary[ "FREETYPE" ] = "yes";

   627             dictionary[ "FREETYPE" ] = "yes";

   628 

   628 

   629         // CE- C runtime --------------------------------------------

   629         // CE- C runtime --------------------------------------------

   631             ++i;

   631             ++i;

   633                 break;

   633                 break;

   634             QDir cDir(configCmdLine.at(i));

   634             QDir cDir(configCmdLine.at(i));

   635             if (!cDir.exists())

   635             if (!cDir.exists())

   636                 cout << "WARNING: Could not find directory (" << qPrintable(configCmdLine.at(i)) << ")for C runtime deployment" << endl;

   636                 cout << "WARNING: Could not find directory (" << qPrintable(configCmdLine.at(i)) << ")for C runtime deployment" << endl;

   637             else

   637             else

   651             // we need for crosscompilation; but remember if we asked

   651             // we need for crosscompilation; but remember if we asked

   652             // for it.

   652             // for it.

   653             dictionary[ "CETEST_REQUESTED" ] = "yes";

   653             dictionary[ "CETEST_REQUESTED" ] = "yes";

   654         }

   654         }

   655         // Qt/CE - signing tool -------------------------------------

   655         // Qt/CE - signing tool -------------------------------------

   657             ++i;

   657             ++i;

   659                 break;

   659                 break;

   660             QFileInfo info(configCmdLine.at(i));

   660             QFileInfo info(configCmdLine.at(i));

   661             if (!info.exists())

   661             if (!info.exists())

   662                 cout << "WARNING: Could not find signature file (" << qPrintable(configCmdLine.at(i)) << ")" << endl;

   662                 cout << "WARNING: Could not find signature file (" << qPrintable(configCmdLine.at(i)) << ")" << endl;

   663             else

   663             else

   664                 dictionary[ "CE_SIGNATURE" ] = QDir::toNativeSeparators(info.absoluteFilePath());

   664                 dictionary[ "CE_SIGNATURE" ] = QDir::toNativeSeparators(info.absoluteFilePath());

   665         }

   665         }

   666         // Styles ---------------------------------------------------

   666         // Styles ---------------------------------------------------

   668             dictionary[ "STYLE_WINDOWS" ] = "yes";

   668             dictionary[ "STYLE_WINDOWS" ] = "yes";

   670             dictionary[ "STYLE_WINDOWS" ] = "no";

   670             dictionary[ "STYLE_WINDOWS" ] = "no";

   671 

   671 

   673             dictionary[ "STYLE_WINDOWSCE" ] = "yes";

   673             dictionary[ "STYLE_WINDOWSCE" ] = "yes";

   675             dictionary[ "STYLE_WINDOWSCE" ] = "no";

   675             dictionary[ "STYLE_WINDOWSCE" ] = "no";

   677             dictionary[ "STYLE_WINDOWSMOBILE" ] = "yes";

   677             dictionary[ "STYLE_WINDOWSMOBILE" ] = "yes";

   679             dictionary[ "STYLE_WINDOWSMOBILE" ] = "no";

   679             dictionary[ "STYLE_WINDOWSMOBILE" ] = "no";

   680 

   680 

   682             dictionary[ "STYLE_WINDOWSXP" ] = "yes";

   682             dictionary[ "STYLE_WINDOWSXP" ] = "yes";

   684             dictionary[ "STYLE_WINDOWSXP" ] = "no";

   684             dictionary[ "STYLE_WINDOWSXP" ] = "no";

   685 

   685 

   687             dictionary[ "STYLE_WINDOWSVISTA" ] = "yes";

   687             dictionary[ "STYLE_WINDOWSVISTA" ] = "yes";

   689             dictionary[ "STYLE_WINDOWSVISTA" ] = "no";

   689             dictionary[ "STYLE_WINDOWSVISTA" ] = "no";

   690 

   690 

   692             dictionary[ "STYLE_PLASTIQUE" ] = "yes";

   692             dictionary[ "STYLE_PLASTIQUE" ] = "yes";

   694             dictionary[ "STYLE_PLASTIQUE" ] = "no";

   694             dictionary[ "STYLE_PLASTIQUE" ] = "no";

   695 

   695 

   697             dictionary[ "STYLE_CLEANLOOKS" ] = "yes";

   697             dictionary[ "STYLE_CLEANLOOKS" ] = "yes";

   699             dictionary[ "STYLE_CLEANLOOKS" ] = "no";

   699             dictionary[ "STYLE_CLEANLOOKS" ] = "no";

   700 

   700 

   702             dictionary[ "STYLE_MOTIF" ] = "yes";

   702             dictionary[ "STYLE_MOTIF" ] = "yes";

   704             dictionary[ "STYLE_MOTIF" ] = "no";

   704             dictionary[ "STYLE_MOTIF" ] = "no";

   705 

   705 

   707             dictionary[ "STYLE_CDE" ] = "yes";

   707             dictionary[ "STYLE_CDE" ] = "yes";

   709             dictionary[ "STYLE_CDE" ] = "no";

   709             dictionary[ "STYLE_CDE" ] = "no";

   710 

   710 

   712             dictionary[ "STYLE_S60" ] = "yes";

   712             dictionary[ "STYLE_S60" ] = "yes";

   714             dictionary[ "STYLE_S60" ] = "no";

   714             dictionary[ "STYLE_S60" ] = "no";

   715 

   715 

   716         // Qt 3 Support ---------------------------------------------

   716         // Qt 3 Support ---------------------------------------------

   718             dictionary[ "QT3SUPPORT" ] = "no";

   718             dictionary[ "QT3SUPPORT" ] = "no";

   719 

   719 

   720         // Work around compiler nesting limitation

   720         // Work around compiler nesting limitation

   721         else

   721         else

   722             continueElse[1] = true;

   722             continueElse[1] = true;

   723         if (!continueElse[1]) {

   723         if (!continueElse[1]) {

   724         }

   724         }

   725 

   725 

   726         // OpenGL Support -------------------------------------------

   726         // OpenGL Support -------------------------------------------

   728             dictionary[ "OPENGL" ]    = "no";

   728             dictionary[ "OPENGL" ]    = "no";

   730             dictionary[ "OPENGL" ]          = "yes";

   730             dictionary[ "OPENGL" ]          = "yes";

   731             dictionary[ "OPENGL_ES_CM" ]    = "yes";

   731             dictionary[ "OPENGL_ES_CM" ]    = "yes";

   733             dictionary[ "OPENGL" ]          = "yes";

   733             dictionary[ "OPENGL" ]          = "yes";

   734             dictionary[ "OPENGL_ES_2" ]     = "yes";

   734             dictionary[ "OPENGL_ES_2" ]     = "yes";

   735         }

   735         }

   736 

   736 

   737         // OpenVG Support -------------------------------------------

   737         // OpenVG Support -------------------------------------------

   739             dictionary[ "OPENVG" ]    = "yes";

   739             dictionary[ "OPENVG" ]    = "yes";

   741             dictionary[ "OPENVG" ]    = "no";

   741             dictionary[ "OPENVG" ]    = "no";

   742         }

   742         }

   743 

   743 

   744         // Databases ------------------------------------------------

   744         // Databases ------------------------------------------------

   746             dictionary[ "SQL_MYSQL" ] = "yes";

   746             dictionary[ "SQL_MYSQL" ] = "yes";

   748             dictionary[ "SQL_MYSQL" ] = "plugin";

   748             dictionary[ "SQL_MYSQL" ] = "plugin";

   750             dictionary[ "SQL_MYSQL" ] = "no";

   750             dictionary[ "SQL_MYSQL" ] = "no";

   751 

   751 

   753             dictionary[ "SQL_ODBC" ] = "yes";

   753             dictionary[ "SQL_ODBC" ] = "yes";

   755             dictionary[ "SQL_ODBC" ] = "plugin";

   755             dictionary[ "SQL_ODBC" ] = "plugin";

   757             dictionary[ "SQL_ODBC" ] = "no";

   757             dictionary[ "SQL_ODBC" ] = "no";

   758 

   758 

   760             dictionary[ "SQL_OCI" ] = "yes";

   760             dictionary[ "SQL_OCI" ] = "yes";

   762             dictionary[ "SQL_OCI" ] = "plugin";

   762             dictionary[ "SQL_OCI" ] = "plugin";

   764             dictionary[ "SQL_OCI" ] = "no";

   764             dictionary[ "SQL_OCI" ] = "no";

   765 

   765 

   767             dictionary[ "SQL_PSQL" ] = "yes";

   767             dictionary[ "SQL_PSQL" ] = "yes";

   769             dictionary[ "SQL_PSQL" ] = "plugin";

   769             dictionary[ "SQL_PSQL" ] = "plugin";

   771             dictionary[ "SQL_PSQL" ] = "no";

   771             dictionary[ "SQL_PSQL" ] = "no";

   772 

   772 

   774             dictionary[ "SQL_TDS" ] = "yes";

   774             dictionary[ "SQL_TDS" ] = "yes";

   776             dictionary[ "SQL_TDS" ] = "plugin";

   776             dictionary[ "SQL_TDS" ] = "plugin";

   778             dictionary[ "SQL_TDS" ] = "no";

   778             dictionary[ "SQL_TDS" ] = "no";

   779 

   779 

   781             dictionary[ "SQL_DB2" ] = "yes";

   781             dictionary[ "SQL_DB2" ] = "yes";

   783             dictionary[ "SQL_DB2" ] = "plugin";

   783             dictionary[ "SQL_DB2" ] = "plugin";

   785             dictionary[ "SQL_DB2" ] = "no";

   785             dictionary[ "SQL_DB2" ] = "no";

   786 

   786 

   788             dictionary[ "SQL_SQLITE" ] = "yes";

   788             dictionary[ "SQL_SQLITE" ] = "yes";

   790             dictionary[ "SQL_SQLITE" ] = "plugin";

   790             dictionary[ "SQL_SQLITE" ] = "plugin";

   792             dictionary[ "SQL_SQLITE" ] = "no";

   792             dictionary[ "SQL_SQLITE" ] = "no";

   794             dictionary[ "SQL_SQLITE_LIB" ] = "system";

   794             dictionary[ "SQL_SQLITE_LIB" ] = "system";

   796             dictionary[ "SQL_SQLITE2" ] = "yes";

   796             dictionary[ "SQL_SQLITE2" ] = "yes";

   798             dictionary[ "SQL_SQLITE2" ] = "plugin";

   798             dictionary[ "SQL_SQLITE2" ] = "plugin";

   800             dictionary[ "SQL_SQLITE2" ] = "no";

   800             dictionary[ "SQL_SQLITE2" ] = "no";

   801 

   801 

   803             dictionary[ "SQL_IBASE" ] = "yes";

   803             dictionary[ "SQL_IBASE" ] = "yes";

   805             dictionary[ "SQL_IBASE" ] = "plugin";

   805             dictionary[ "SQL_IBASE" ] = "plugin";

   807             dictionary[ "SQL_IBASE" ] = "no";

   807             dictionary[ "SQL_IBASE" ] = "no";

   808 #endif

   808 #endif

   809         // IDE project generation -----------------------------------

   809         // IDE project generation -----------------------------------

   811             dictionary[ "DSPFILES" ] = "no";

   811             dictionary[ "DSPFILES" ] = "no";

   813             dictionary[ "DSPFILES" ] = "yes";

   813             dictionary[ "DSPFILES" ] = "yes";

   814 

   814 

   816             dictionary[ "VCPFILES" ] = "no";

   816             dictionary[ "VCPFILES" ] = "no";

   818             dictionary[ "VCPFILES" ] = "yes";

   818             dictionary[ "VCPFILES" ] = "yes";

   819 

   819 

   821             dictionary[ "VCPROJFILES" ] = "no";

   821             dictionary[ "VCPROJFILES" ] = "no";

   823             dictionary[ "VCPROJFILES" ] = "yes";

   823             dictionary[ "VCPROJFILES" ] = "yes";

   824 

   824 

   826             dictionary[ "INCREDIBUILD_XGE" ] = "no";

   826             dictionary[ "INCREDIBUILD_XGE" ] = "no";

   828             dictionary[ "INCREDIBUILD_XGE" ] = "yes";

   828             dictionary[ "INCREDIBUILD_XGE" ] = "yes";

   830             dictionary[ "NATIVE_GESTURES" ] = "yes";

   830             dictionary[ "NATIVE_GESTURES" ] = "yes";

   832             dictionary[ "NATIVE_GESTURES" ] = "no";

   832             dictionary[ "NATIVE_GESTURES" ] = "no";

   833 #if !defined(EVAL)

   833 #if !defined(EVAL)

   834         // Symbian Support -------------------------------------------

   834         // Symbian Support -------------------------------------------

   836         {

   836         {

   837             ++i;

   837             ++i;

   839                 break;

   839                 break;

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

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

   841         }

   841         }

   842 

   842 

   844             dictionary[ "S60" ]    = "yes";

   844             dictionary[ "S60" ]    = "yes";

   846             dictionary[ "S60" ]    = "no";

   846             dictionary[ "S60" ]    = "no";

   847 

   847 

   849             dictionary[ "SYMBIAN_DEFFILES" ] = "yes";

   849             dictionary[ "SYMBIAN_DEFFILES" ] = "yes";

   851             dictionary[ "SYMBIAN_DEFFILES" ] = "no";

   851             dictionary[ "SYMBIAN_DEFFILES" ] = "no";

   852 

   852 

   853         // Others ---------------------------------------------------

   853         // Others ---------------------------------------------------

   855             dictionary[ "FAST" ] = "yes";

   855             dictionary[ "FAST" ] = "yes";

   857             dictionary[ "FAST" ] = "no";

   857             dictionary[ "FAST" ] = "no";

   858 

   858 

   860             dictionary[ "STL" ] = "yes";

   860             dictionary[ "STL" ] = "yes";

   862             dictionary[ "STL" ] = "no";

   862             dictionary[ "STL" ] = "no";

   863 

   863 

   865             dictionary[ "EXCEPTIONS" ] = "yes";

   865             dictionary[ "EXCEPTIONS" ] = "yes";

   867             dictionary[ "EXCEPTIONS" ] = "no";

   867             dictionary[ "EXCEPTIONS" ] = "no";

   868 

   868 

   870             dictionary[ "RTTI" ] = "yes";

   870             dictionary[ "RTTI" ] = "yes";

   872             dictionary[ "RTTI" ] = "no";

   872             dictionary[ "RTTI" ] = "no";

   873 

   873 

   875             dictionary[ "ACCESSIBILITY" ] = "yes";

   875             dictionary[ "ACCESSIBILITY" ] = "yes";

   877             dictionary[ "ACCESSIBILITY" ] = "no";

   877             dictionary[ "ACCESSIBILITY" ] = "no";

   878             cout << "Setting accessibility to NO" << endl;

   878             cout << "Setting accessibility to NO" << endl;

   879         }

   879         }

   880 

   880 

   881         else if (configCmdLine.at(i) == "-no-mmx")

   881         else if (configCmdLine.at(i) == "-no-mmx")

   897         else if (configCmdLine.at(i) == "-no-iwmmxt")

   897         else if (configCmdLine.at(i) == "-no-iwmmxt")

   898             dictionary[ "IWMMXT" ] = "no";

   898             dictionary[ "IWMMXT" ] = "no";

   899         else if (configCmdLine.at(i) == "-iwmmxt")

   899         else if (configCmdLine.at(i) == "-iwmmxt")

   900             dictionary[ "IWMMXT" ] = "yes";

   900             dictionary[ "IWMMXT" ] = "yes";

   901 

   901 

   903               dictionary[ "OPENSSL"] = "no";

   903               dictionary[ "OPENSSL"] = "no";

   905               dictionary[ "OPENSSL" ] = "yes";

   905               dictionary[ "OPENSSL" ] = "yes";

   907               dictionary[ "OPENSSL" ] = "linked";

   907               dictionary[ "OPENSSL" ] = "linked";

   909             dictionary[ "DBUS" ] = "no";

   909             dictionary[ "DBUS" ] = "no";

   911             dictionary[ "DBUS" ] = "yes";

   911             dictionary[ "DBUS" ] = "yes";

   913             dictionary[ "DBUS" ] = "no";

   913             dictionary[ "DBUS" ] = "no";

   915             dictionary[ "DBUS" ] = "yes";

   915             dictionary[ "DBUS" ] = "yes";

   917             dictionary[ "DBUS" ] = "linked";

   917             dictionary[ "DBUS" ] = "linked";

   919             dictionary[ "SCRIPT" ] = "no";

   919             dictionary[ "SCRIPT" ] = "no";

   921             dictionary[ "SCRIPT" ] = "yes";

   921             dictionary[ "SCRIPT" ] = "yes";

   923             dictionary[ "SCRIPTTOOLS" ] = "no";

   923             dictionary[ "SCRIPTTOOLS" ] = "no";

   925             dictionary[ "SCRIPTTOOLS" ] = "yes";

   925             dictionary[ "SCRIPTTOOLS" ] = "yes";

   927             dictionary[ "XMLPATTERNS" ] = "no";

   927             dictionary[ "XMLPATTERNS" ] = "no";

   929             dictionary[ "XMLPATTERNS" ] = "yes";

   929             dictionary[ "XMLPATTERNS" ] = "yes";

   931             dictionary[ "MULTIMEDIA" ] = "no";

   931             dictionary[ "MULTIMEDIA" ] = "no";

   933             dictionary[ "MULTIMEDIA" ] = "yes";

   933             dictionary[ "MULTIMEDIA" ] = "yes";

   935             dictionary[ "AUDIO_BACKEND" ] = "yes";

   935             dictionary[ "AUDIO_BACKEND" ] = "yes";

   937             dictionary[ "AUDIO_BACKEND" ] = "no";

   937             dictionary[ "AUDIO_BACKEND" ] = "no";

   939             dictionary[ "PHONON" ] = "no";

   939             dictionary[ "PHONON" ] = "no";

   941             dictionary[ "PHONON" ] = "yes";

   941             dictionary[ "PHONON" ] = "yes";

   943             dictionary[ "PHONON_BACKEND" ] = "no";

   943             dictionary[ "PHONON_BACKEND" ] = "no";

   945             dictionary[ "PHONON_BACKEND" ] = "yes";

   945             dictionary[ "PHONON_BACKEND" ] = "yes";

   947             dictionary[ "DIRECTSHOW" ] = "yes";

   947             dictionary[ "DIRECTSHOW" ] = "yes";

   949             dictionary[ "WEBKIT" ] = "no";

   949             dictionary[ "WEBKIT" ] = "no";

   951             dictionary[ "WEBKIT" ] = "yes";

   951             dictionary[ "WEBKIT" ] = "yes";

   953             dictionary[ "DECLARATIVE" ] = "no";

   953             dictionary[ "DECLARATIVE" ] = "no";

   955             dictionary[ "DECLARATIVE" ] = "yes";

   955             dictionary[ "DECLARATIVE" ] = "yes";

   957             dictionary[ "PLUGIN_MANIFESTS" ] = "no";

   957             dictionary[ "PLUGIN_MANIFESTS" ] = "no";

   959             dictionary[ "PLUGIN_MANIFESTS" ] = "yes";

   959             dictionary[ "PLUGIN_MANIFESTS" ] = "yes";

   960         }

   960         }

   961 

   961 

   962         // Work around compiler nesting limitation

   962         // Work around compiler nesting limitation

   963         else

   963         else

   964             continueElse[0] = true;

   964             continueElse[0] = true;

   965         if (!continueElse[0]) {

   965         if (!continueElse[0]) {

   966         }

   966         }

   967 

   967 

   969             dictionary[ "QMAKE_INTERNAL" ] = "yes";

   969             dictionary[ "QMAKE_INTERNAL" ] = "yes";

   970 

   970 

   972             dictionary[ "BUILD_QMAKE" ] = "no";

   972             dictionary[ "BUILD_QMAKE" ] = "no";

   974             dictionary[ "BUILD_QMAKE" ] = "yes";

   974             dictionary[ "BUILD_QMAKE" ] = "yes";

   975 

   975 

   977             dictionary[ "NOPROCESS" ] = "yes";

   977             dictionary[ "NOPROCESS" ] = "yes";

   979             dictionary[ "NOPROCESS" ] = "no";

   979             dictionary[ "NOPROCESS" ] = "no";

   980 

   980 

   982             dictionary[ "DEPENDENCIES" ] = "no";

   982             dictionary[ "DEPENDENCIES" ] = "no";

   984             dictionary[ "DEPENDENCIES" ] = "yes";

   984             dictionary[ "DEPENDENCIES" ] = "yes";

   985 

   985 

   986 

   986 

   988             ++i;

   988             ++i;

   990                 break;

   990                 break;

   991             qmakeDefines += "QT_NAMESPACE="+configCmdLine.at(i);

   991             qmakeDefines += "QT_NAMESPACE="+configCmdLine.at(i);

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

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

   994             ++i;

   994             ++i;

   996                 break;

   996                 break;

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

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

   998             if (dictionary.contains("XQMAKESPEC") && dictionary["XQMAKESPEC"].startsWith("symbian")) {

   998             if (dictionary.contains("XQMAKESPEC") && dictionary["XQMAKESPEC"].startsWith("symbian")) {

   999                 dictionary[ "QT_INSTALL_PLUGINS" ] =

   999                 dictionary[ "QT_INSTALL_PLUGINS" ] =

  1000                     QString("\\resource\\qt%1\\plugins").arg(dictionary[ "QT_LIBINFIX" ]);

  1000                     QString("\\resource\\qt%1\\plugins").arg(dictionary[ "QT_LIBINFIX" ]);

  1001             }

  1001             }

  1003             ++i;

  1003             ++i;

  1005                 break;

  1005                 break;

  1006             qmakeDefines += configCmdLine.at(i);

  1006             qmakeDefines += configCmdLine.at(i);

  1008             ++i;

  1008             ++i;

  1010                 break;

  1010                 break;

  1011             qmakeIncludes += configCmdLine.at(i);

  1011             qmakeIncludes += configCmdLine.at(i);

  1013             ++i;

  1013             ++i;

  1015                 break;

  1015                 break;

  1016             QFileInfo check(configCmdLine.at(i));

  1016             QFileInfo check(configCmdLine.at(i));

  1017             if (!check.isDir()) {

  1017             if (!check.isDir()) {

  1018                 cout << "Argument passed to -L option is not a directory path. Did you mean the -l option?" << endl;

  1018                 cout << "Argument passed to -L option is not a directory path. Did you mean the -l option?" << endl;

  1019                 dictionary[ "DONE" ] = "error";

  1019                 dictionary[ "DONE" ] = "error";

  1020                 break;

  1020                 break;

  1021             }

  1021             }

  1022             qmakeLibs += QString("-L" + configCmdLine.at(i));

  1022             qmakeLibs += QString("-L" + configCmdLine.at(i));

  1024             ++i;

  1024             ++i;

  1026                 break;

  1026                 break;

  1027             qmakeLibs += QString("-l" + configCmdLine.at(i));

  1027             qmakeLibs += QString("-l" + configCmdLine.at(i));

  1028         } else if (configCmdLine.at(i).startsWith("OPENSSL_LIBS=")) {

  1028         } else if (configCmdLine.at(i).startsWith("OPENSSL_LIBS=")) {

  1029             opensslLibs = configCmdLine.at(i);

  1029             opensslLibs = configCmdLine.at(i);

  1033             ++i;

  1035             ++i;

  1035                 break;

  1037                 break;

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

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

  1037         }

  1039         }

  1038 

  1040 

  1040             ++i;

  1042             ++i;

  1042                 break;

  1044                 break;

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

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

  1044         }

  1046         }

  1045 

  1047 

  1046         else if (configCmdLine.at(i) == "-confirm-license") {

  1048         else if (configCmdLine.at(i) == "-confirm-license") {

  1047             dictionary["LICENSE_CONFIRMED"] = "yes";

  1049             dictionary["LICENSE_CONFIRMED"] = "yes";

  1048         }

  1050         }

  1049 

  1051 

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

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

  1051             ++i;

  1053             ++i;

  1053                 break;

  1055                 break;

  1054             disabledBuildParts += configCmdLine.at(i);

  1056             disabledBuildParts += configCmdLine.at(i);

  1055         }

  1057         }

  1056 

  1058 

  1057         // Directories ----------------------------------------------

  1059         // Directories ----------------------------------------------

  1059             ++i;

  1061             ++i;

  1061                 break;

  1063                 break;

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

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

  1063         }

  1065         }

  1064 

  1066 

  1066             ++i;

  1068             ++i;

  1068                 break;

  1070                 break;

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

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

  1070         }

  1072         }

  1071 

  1073 

  1073             ++i;

  1075             ++i;

  1075                 break;

  1077                 break;

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

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

  1077         }

  1079         }

  1078 

  1080 

  1080             ++i;

  1082             ++i;

  1082                 break;

  1084                 break;

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

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

  1084         }

  1086         }

  1085 

  1087 

  1087             ++i;

  1089             ++i;

  1089                 break;

  1091                 break;

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

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

  1091         }

  1093         }

  1092 

  1094 

  1094             ++i;

  1096             ++i;

  1096                 break;

  1098                 break;

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

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

  1098         }

  1100         }

  1099 

  1101 

  1101             ++i;

  1103             ++i;

  1103                 break;

  1105                 break;

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

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

  1105         }

  1107         }

  1107             ++i;

  1109             ++i;

  1109                 break;

  1111                 break;

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

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

  1111         }

  1113         }

  1112 

  1114 

  1114             ++i;

  1116             ++i;

  1116                 break;

  1118                 break;

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

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

  1118         }

  1120         }

  1119 

  1121 

  1121             ++i;

  1123             ++i;

  1123                 break;

  1125                 break;

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

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

  1125         }

  1127         }

  1126 

  1128 

  1128             ++i;

  1130             ++i;

  1130                 break;

  1132                 break;

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

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

  1132         }

  1134         }

  1133 

  1135 

  1135             ++i;

  1137             ++i;

  1137                 break;

  1139                 break;

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

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

  1139         }

  1141         }

  1140 

  1142 

  1142             ++i;

  1144             ++i;

  1144                 break;

  1146                 break;

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

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

  1146         }

  1148         }

  1147 

  1149 

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

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

  1150             if (i == argCount)

  1152             if (i == argCount)

  1151                 break;

  1153                 break;

  1152             QString system = configCmdLine.at(i);

  1154             QString system = configCmdLine.at(i);

  1153             if (system == QLatin1String("raster")

  1155             if (system == QLatin1String("raster")

  1154                 || system == QLatin1String("opengl")

  1156                 || system == QLatin1String("opengl")

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

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

  1157         }

  1160         }

  1158 

  1161 

  1160             // Scan to see if any specific modules and drivers are enabled or disabled

  1163             // Scan to see if any specific modules and drivers are enabled or disabled

  1163                     enabledModules += (*module);

  1166                     enabledModules += (*module);

  1164                     break;

  1167                     break;

  1165                 }

  1168                 }

  1167                     disabledModules += (*module);

  1170                     disabledModules += (*module);

  1168                     break;

  1171                     break;

  1169                 }

  1172                 }

  1170             }

  1173             }

  1171         }

  1174         }

  1195             cout << "Unable to detect the platform from environment. Use -platform command line"

  1198             cout << "Unable to detect the platform from environment. Use -platform command line"

  1196                     "argument or set the QMAKESPEC environment variable and run configure again" << endl;

  1199                     "argument or set the QMAKESPEC environment variable and run configure again" << endl;

  1197         }

  1200         }

  1198         cout << "See the README file for a list of supported operating systems and compilers." << endl;

  1201         cout << "See the README file for a list of supported operating systems and compilers." << endl;

  1199     } else {

  1202     } else {

  1209             dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32";

  1212             dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32";

  1212             if (Environment::detectExecutable("sh.exe")) {

  1215             if (Environment::detectExecutable("sh.exe")) {

  1213                 dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32-g++-sh";

  1216                 dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32-g++-sh";

  1214             } else {

  1217             } else {

  1215                 dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32-g++";

  1218                 dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32-g++";

  1216             }

  1219             }

  1217         } else if ( dictionary[ "QMAKESPEC" ] == QString( "win32-g++-symbian" ) ) {

  1220         } else if ( dictionary[ "QMAKESPEC" ] == QString( "win32-g++-symbian" ) ) {

  1218                 dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32-g++-symbian";

  1221                 dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32-g++-symbian";

  1219                 dictionary[ "MAKE" ] = "make";

  1222                 dictionary[ "MAKE" ] = "make";

  1220         } else {

  1223         } else {

  1222             dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32";

  1225             dictionary[ "QMAKEMAKEFILE" ] = "Makefile.win32";

  1223         }

  1226         }

  1224     }

  1227     }

  1225 

  1228 

  1226     // Tell the user how to proceed building Qt after configure finished its job

  1229     // Tell the user how to proceed building Qt after configure finished its job

  1272     if (dictionary["BUILDDEV"] == "yes")

  1275     if (dictionary["BUILDDEV"] == "yes")

  1273         qtConfig += "private_tests";

  1276         qtConfig += "private_tests";

  1274 

  1277 

  1275 

  1278 

  1276 #if !defined(EVAL)

  1279 #if !defined(EVAL)

  1282             modules += (*ena);

  1285             modules += (*ena);

  1283     }

  1286     }

  1284     qtConfig += modules;

  1287     qtConfig += modules;

  1285 

  1288 

  1287         qtConfig.removeAll(*it);

  1290         qtConfig.removeAll(*it);

  1288 

  1291 

  1290         saveCmdLine();

  1293         saveCmdLine();

  1291 #endif

  1294 #endif

  1292 }

  1295 }

  1293 

  1296 

  1294 #if !defined(EVAL)

  1297 #if !defined(EVAL)

  1304     dir.setPath(sourcePath + "/src/corelib/global/");

  1307     dir.setPath(sourcePath + "/src/corelib/global/");

  1305 

  1308 

  1306     QStringList stringList =  dir.entryList();

  1309     QStringList stringList =  dir.entryList();

  1307 

  1310 

  1308     QStringList::Iterator it;

  1311     QStringList::Iterator it;

  1310         allConfigs << it->remove("qconfig-").remove(".h");

  1313         allConfigs << it->remove("qconfig-").remove(".h");

  1311     allConfigs << "full";

  1314     allConfigs << "full";

  1312 

  1315 

  1313     // Try internal configurations first.

  1316     // Try internal configurations first.

  1314     QStringList possible_configs = QStringList()

  1317     QStringList possible_configs = QStringList()

  1325         return;

  1328         return;

  1326     }

  1329     }

  1327 

  1330 

  1328     // If the internal configurations failed, try others.

  1331     // If the internal configurations failed, try others.

  1329     QStringList::Iterator config;

  1332     QStringList::Iterator config;

  1332             break;

  1335             break;

  1333     }

  1336     }

  1335         dictionary[ "HELP" ] = "yes";

  1338         dictionary[ "HELP" ] = "yes";

  1336         cout << "No such configuration \"" << qPrintable(dictionary[ "QCONFIG" ]) << "\"" << endl ;

  1339         cout << "No such configuration \"" << qPrintable(dictionary[ "QCONFIG" ]) << "\"" << endl ;

  1337     }

  1340     }

  1338     else

  1341     else

  1339         qmakeConfig += (*config) + "-config";

  1342         qmakeConfig += (*config) + "-config";

  1482             dictionary[ "DIRECTSHOW" ] = "yes";

  1485             dictionary[ "DIRECTSHOW" ] = "yes";

  1483         }

  1486         }

  1484         dictionary[ "QT_HOST_PREFIX" ]      = dictionary[ "QT_INSTALL_PREFIX" ];

  1487         dictionary[ "QT_HOST_PREFIX" ]      = dictionary[ "QT_INSTALL_PREFIX" ];

  1485         dictionary[ "QT_INSTALL_PREFIX" ]   = "";

  1488         dictionary[ "QT_INSTALL_PREFIX" ]   = "";

  1486 

  1489 

  1488         dictionary[ "ACCESSIBILITY" ]       = "no";

  1491         dictionary[ "ACCESSIBILITY" ]       = "no";

  1489         dictionary[ "STYLE_WINDOWSXP" ]     = "no";

  1492         dictionary[ "STYLE_WINDOWSXP" ]     = "no";

  1490         dictionary[ "STYLE_WINDOWSVISTA" ]  = "no";

  1493         dictionary[ "STYLE_WINDOWSVISTA" ]  = "no";

  1491         dictionary[ "STYLE_PLASTIQUE" ]     = "no";

  1494         dictionary[ "STYLE_PLASTIQUE" ]     = "no";

  1492         dictionary[ "STYLE_CLEANLOOKS" ]    = "no";

  1495         dictionary[ "STYLE_CLEANLOOKS" ]    = "no";

  1531         dictionary[ "SQL_SQLITE_LIB" ]      = "system";

  1534         dictionary[ "SQL_SQLITE_LIB" ]      = "system";

  1532 

  1535 

  1533         // Disable building docs and translations for now

  1536         // Disable building docs and translations for now

  1534         disabledBuildParts << "docs" << "translations";

  1537         disabledBuildParts << "docs" << "translations";

  1535 

  1538 

  1537       //TODO

  1540       //TODO

  1538         dictionary[ "STYLE_WINDOWSXP" ]     = "no";

  1541         dictionary[ "STYLE_WINDOWSXP" ]     = "no";

  1539         dictionary[ "STYLE_WINDOWSVISTA" ]  = "no";

  1542         dictionary[ "STYLE_WINDOWSVISTA" ]  = "no";

  1540         dictionary[ "KBD_DRIVERS" ]         = "tty";

  1543         dictionary[ "KBD_DRIVERS" ]         = "tty";

  1541         dictionary[ "GFX_DRIVERS" ]         = "linuxfb vnc";

  1544         dictionary[ "GFX_DRIVERS" ]         = "linuxfb vnc";

  1557 }

  1560 }

  1558 

  1561 

  1559 QString Configure::locateFileInPaths(const QString &fileName, const QStringList &paths)

  1562 QString Configure::locateFileInPaths(const QString &fileName, const QStringList &paths)

  1560 {

  1563 {

  1561     QDir d;

  1564     QDir d;

  1563         // Remove any leading or trailing ", this is commonly used in the environment

  1566         // Remove any leading or trailing ", this is commonly used in the environment

  1564         // variables

  1567         // variables

  1565         QString path = (*it);

  1568         QString path = (*it);

  1571             return (path);

  1574             return (path);

  1572         }

  1575         }

  1573     }

  1576     }

  1574     return QString();

  1577     return QString();

  1575 }

  1578 }

  1576 

  1579 

  1578 {

  1581 {

  1579     QString file = fileName.toLower();

  1582     QString file = fileName.toLower();

  1580     QStringList paths;

  1583     QStringList paths;

  1581 #if defined(Q_OS_WIN32)

  1584 #if defined(Q_OS_WIN32)

  1582     QRegExp splitReg("[;,]");

  1585     QRegExp splitReg("[;,]");

  1583 #else

  1586 #else

  1584     QRegExp splitReg("[:]");

  1587     QRegExp splitReg("[:]");

  1585 #endif

  1588 #endif

  1586     if (file.endsWith(".h"))

  1589     if (file.endsWith(".h"))

  1587         paths = QString::fromLocal8Bit(getenv("INCLUDE")).split(splitReg, QString::SkipEmptyParts);

  1590         paths = QString::fromLocal8Bit(getenv("INCLUDE")).split(splitReg, QString::SkipEmptyParts);

  1589         paths = QString::fromLocal8Bit(getenv("LIB")).split(splitReg, QString::SkipEmptyParts);

  1592         paths = QString::fromLocal8Bit(getenv("LIB")).split(splitReg, QString::SkipEmptyParts);

  1590     else

  1593     else

  1591         paths = QString::fromLocal8Bit(getenv("PATH")).split(splitReg, QString::SkipEmptyParts);

  1594         paths = QString::fromLocal8Bit(getenv("PATH")).split(splitReg, QString::SkipEmptyParts);

  1592     return locateFileInPaths(file, paths);

  1595     return locateFileInPaths(file, paths);

  1593 }

  1596 }

  1595 // Output helper functions ---------------------------------[ Stop ]-

  1598 // Output helper functions ---------------------------------[ Stop ]-

  1596 

  1599 

  1597 

  1600 

  1598 bool Configure::displayHelp()

  1601 bool Configure::displayHelp()

  1599 {

  1602 {

  1601         desc("Usage: configure [-buildkey <key>]\n"

  1604         desc("Usage: configure [-buildkey <key>]\n"

  1602 //      desc("Usage: configure [-prefix dir] [-bindir <dir>] [-libdir <dir>]\n"

  1605 //      desc("Usage: configure [-prefix dir] [-bindir <dir>] [-libdir <dir>]\n"

  1603 //                  "[-docdir <dir>] [-headerdir <dir>] [-plugindir <dir>]\n"

  1606 //                  "[-docdir <dir>] [-headerdir <dir>] [-plugindir <dir>]\n"

  1604 //                  "[-importdir <dir>] [-datadir <dir>] [-translationdir <dir>]\n"

  1607 //                  "[-importdir <dir>] [-datadir <dir>] [-translationdir <dir>]\n"

  1605 //                  "[-examplesdir <dir>] [-demosdir <dir>][-buildkey <key>]\n"

  1608 //                  "[-examplesdir <dir>] [-demosdir <dir>][-buildkey <key>]\n"

  1622                     "[-no-openssl] [-no-dbus] [-dbus] [-dbus-linked] [-platform <spec>]\n"

  1625                     "[-no-openssl] [-no-dbus] [-dbus] [-dbus-linked] [-platform <spec>]\n"

  1623                     "[-qtnamespace <namespace>] [-qtlibinfix <infix>] [-no-phonon]\n"

  1626                     "[-qtnamespace <namespace>] [-qtlibinfix <infix>] [-no-phonon]\n"

  1624                     "[-phonon] [-no-phonon-backend] [-phonon-backend]\n"

  1627                     "[-phonon] [-no-phonon-backend] [-phonon-backend]\n"

  1625                     "[-no-multimedia] [-multimedia] [-no-audio-backend] [-audio-backend]\n"

  1628                     "[-no-multimedia] [-multimedia] [-no-audio-backend] [-audio-backend]\n"

  1626                     "[-no-script] [-script] [-no-scripttools] [-scripttools]\n"

  1629                     "[-no-script] [-script] [-no-scripttools] [-scripttools]\n"

  1628 

  1631 

  1629         desc("Installation options:\n\n");

  1632         desc("Installation options:\n\n");

  1630 

  1633 

  1631 #if !defined(EVAL)

  1634 #if !defined(EVAL)

  1632 /*

  1635 /*

  1725         desc(                   "-L <librarypath>",     "Add an explicit library path.");

  1728         desc(                   "-L <librarypath>",     "Add an explicit library path.");

  1726         desc(                   "-l <libraryname>",     "Add an explicit library name, residing in a librarypath.\n");

  1729         desc(                   "-l <libraryname>",     "Add an explicit library name, residing in a librarypath.\n");

  1727 #endif

  1730 #endif

  1728         desc(                   "-graphicssystem <sys>",   "Specify which graphicssystem should be used.\n"

  1731         desc(                   "-graphicssystem <sys>",   "Specify which graphicssystem should be used.\n"

  1729                                 "Available values for <sys>:");

  1732                                 "Available values for <sys>:");

  1733 

  1737 

  1734 

  1738 

  1735         desc(                   "-help, -h, -?",        "Display this information.\n");

  1739         desc(                   "-help, -h, -?",        "Display this information.\n");

  1736 

  1740 

  1737 #if !defined(EVAL)

  1741 #if !defined(EVAL)

  1739         desc("Third Party Libraries:\n\n");

  1743         desc("Third Party Libraries:\n\n");

  1740 

  1744 

  1741         desc("ZLIB", "qt",      "-qt-zlib",             "Use the zlib bundled with Qt.");

  1745         desc("ZLIB", "qt",      "-qt-zlib",             "Use the zlib bundled with Qt.");

  1742         desc("ZLIB", "system",  "-system-zlib",         "Use zlib from the operating system.\nSee http://www.gzip.org/zlib\n");

  1746         desc("ZLIB", "system",  "-system-zlib",         "Use zlib from the operating system.\nSee http://www.gzip.org/zlib\n");

  1743 

  1747 

  1748         desc("LIBPNG", "qt",    "-qt-libpng",           "Use the libpng bundled with Qt.");

  1752         desc("LIBPNG", "qt",    "-qt-libpng",           "Use the libpng bundled with Qt.");

  1749         desc("LIBPNG", "system","-system-libpng",       "Use libpng from the operating system.\nSee http://www.libpng.org/pub/png\n");

  1753         desc("LIBPNG", "system","-system-libpng",       "Use libpng from the operating system.\nSee http://www.libpng.org/pub/png\n");

  1750 

  1754 

  1752         desc("LIBMNG", "qt",    "-qt-libmng",           "Use the libmng bundled with Qt.");

  1756         desc("LIBMNG", "qt",    "-qt-libmng",           "Use the libmng bundled with Qt.");

  1753         desc("LIBMNG", "system","-system-libmng",       "Use libmng from the operating system.\nSee See http://www.libmng.com\n");

  1757         desc("LIBMNG", "system","-system-libmng",       "Use libmng from the operating system.\nSee See http://www.libmng.com\n");

  1754 

  1758 

  1756         desc("LIBTIFF", "qt",    "-qt-libtiff",         "Use the libtiff bundled with Qt.");

  1760         desc("LIBTIFF", "qt",    "-qt-libtiff",         "Use the libtiff bundled with Qt.");

  1757         desc("LIBTIFF", "system","-system-libtiff",     "Use libtiff from the operating system.\nSee http://www.libtiff.org\n");

  1761         desc("LIBTIFF", "system","-system-libtiff",     "Use libtiff from the operating system.\nSee http://www.libtiff.org\n");

  1758 

  1762 

  1760         desc("LIBJPEG", "qt",    "-qt-libjpeg",         "Use the libjpeg bundled with Qt.");

  1764         desc("LIBJPEG", "qt",    "-qt-libjpeg",         "Use the libjpeg bundled with Qt.");

  1761         desc("LIBJPEG", "system","-system-libjpeg",     "Use libjpeg from the operating system.\nSee http://www.ijg.org\n");

  1765         desc("LIBJPEG", "system","-system-libjpeg",     "Use libjpeg from the operating system.\nSee http://www.ijg.org\n");

  1762 

  1766 

  1763 #endif

  1767 #endif

  1764         // Qt\Windows only options go below here --------------------------------------------------------------------------------

  1768         // Qt\Windows only options go below here --------------------------------------------------------------------------------

  1887 #else

  1891 #else

  1888     QRegExp splitReg("[:]");

  1892     QRegExp splitReg("[:]");

  1889 #endif

  1893 #endif

  1890     QStringList pathList = paths.split(splitReg, QString::SkipEmptyParts);

  1894     QStringList pathList = paths.split(splitReg, QString::SkipEmptyParts);

  1891     QDir d;

  1895     QDir d;

  1893         // Remove any leading or trailing ", this is commonly used in the environment

  1897         // Remove any leading or trailing ", this is commonly used in the environment

  1894         // variables

  1898         // variables

  1895         QString path = (*it);

  1899         QString path = (*it);

  1901             return path;

  1905             return path;

  1902     }

  1906     }

  1903     return QString();

  1907     return QString();

  1904 }

  1908 }

  1905 

  1909 

  1907 {

  1911 {

  1908     const QString file = fileName.toLower();

  1912     const QString file = fileName.toLower();

  1909     const QString pathEnvVar = QString::fromLocal8Bit(getenv("PATH"));

  1913     const QString pathEnvVar = QString::fromLocal8Bit(getenv("PATH"));

  1910     const QString mingwPath = dictionary["QMAKESPEC"].endsWith("-g++") ?

  1914     const QString mingwPath = dictionary["QMAKESPEC"].endsWith("-g++") ?

  1911         findFileInPaths("g++.exe", pathEnvVar) : QString();

  1915         findFileInPaths("g++.exe", pathEnvVar) : QString();

  1912 

  1916 

  1913     QString paths;

  1917     QString paths;

  1914     if (file.endsWith(".h")) {

  1918     if (file.endsWith(".h")) {

  1915         if (!mingwPath.isNull()) {

  1919         if (!mingwPath.isNull()) {