Merge branch '4.7' of scm.dev.nokia.troll.no:qt/qt-s60-public

Conflicts:
	mkspecs/common/symbian/symbian.conf
	qmake/generators/makefile.h
	qmake/project.cpp
	src/3rdparty/webkit/WebCore/WebCore.pro
	src/src.pro

24 files changed, 271 insertions, 189 deletions

diff --git a/qmake/Makefile.win32-g++ b/qmake/Makefile.win32-g++
index c520c32515..ab7d558895 100644
--- a/qmake/Makefile.win32-g++
+++ b/qmake/Makefile.win32-g++
@@ -27,7 +27,7 @@ CFLAGS	    =	-c -o$@ -O \
 		-DQT_BUILD_QMAKE -DQT_NO_THREAD -DQT_NO_QOBJECT -DQT_NO_GEOM_VARIANT -DQT_NO_DATASTREAM \
 		-DQT_BOOTSTRAPPED
 CXXFLAGS    =   $(CFLAGS)
-LFLAGS	    =
+LFLAGS	    = -static-libgcc -s
 LIBS	    = -lole32 -luuid
 LINKQMAKE   =	g++ $(LFLAGS) -o qmake.exe $(OBJS) $(QTOBJS) $(LIBS)
 ADDCLEAN    =
diff --git a/qmake/Makefile.win32-g++-sh b/qmake/Makefile.win32-g++-sh
index 7a3edea2db..755d04675f 100644
--- a/qmake/Makefile.win32-g++-sh
+++ b/qmake/Makefile.win32-g++-sh
@@ -27,7 +27,7 @@ CFLAGS	    =	-c -o$@ -O \
 		-DQT_BUILD_QMAKE -DQT_NO_THREAD -DQT_NO_QOBJECT -DQT_NO_GEOM_VARIANT -DQT_NO_DATASTREAM \
 		-DQT_BOOTSTRAPPED
 CXXFLAGS    =   $(CFLAGS)
-LFLAGS	    =
+LFLAGS	    = -static-libgcc -s
 LIBS	    = -lole32 -luuid
 LINKQMAKE   =	g++ $(LFLAGS) -o qmake.exe $(OBJS) $(QTOBJS) $(LIBS)
 ADDCLEAN    =
diff --git a/qmake/generators/mac/pbuilder_pbx.cpp b/qmake/generators/mac/pbuilder_pbx.cpp
index ac9fa998d2..1a7391b5dd 100644
--- a/qmake/generators/mac/pbuilder_pbx.cpp
+++ b/qmake/generators/mac/pbuilder_pbx.cpp
@@ -523,9 +523,7 @@ ProjectBuilderMakefileGenerator::writeMakeParts(QTextStream &t)
             debug_msg(1, "pbuilder: Creating file: %s", mkfile.toLatin1().constData());
             QTextStream mkt(&mkf);
             writeHeader(mkt);
-            mkt << "QMAKE    = "        << (project->isEmpty("QMAKE_QMAKE") ?
-                                            QString((QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qmake")) :
-                                            var("QMAKE_QMAKE")) << endl;
+            mkt << "QMAKE    = " << var("QMAKE_QMAKE") << endl;
             writeMakeQmake(mkt);
             mkt.flush();
             mkf.close();
diff --git a/qmake/generators/makefile.cpp b/qmake/generators/makefile.cpp
index ec712a06c1..b9d2445982 100644
--- a/qmake/generators/makefile.cpp
+++ b/qmake/generators/makefile.cpp
@@ -806,9 +806,8 @@ MakefileGenerator::init()
     }
 
     // escape qmake command
-    if (!project->isEmpty("QMAKE_QMAKE")) {
-        project->values("QMAKE_QMAKE") = escapeFilePaths(project->values("QMAKE_QMAKE"));
-    }
+    QStringList &qmk = project->values("QMAKE_QMAKE");
+    qmk = escapeFilePaths(qmk);
 }
 
 bool
@@ -2097,7 +2096,7 @@ MakefileGenerator::writeExtraVariables(QTextStream &t)
 bool
 MakefileGenerator::writeStubMakefile(QTextStream &t)
 {
-    t << "QMAKE    = "        << (project->isEmpty("QMAKE_QMAKE") ? QString("qmake") : var("QMAKE_QMAKE")) << endl;
+    t << "QMAKE    = " << var("QMAKE_QMAKE") << endl;
     QStringList &qut = project->values("QMAKE_EXTRA_TARGETS");
     for(QStringList::ConstIterator it = qut.begin(); it != qut.end(); ++it)
         t << *it << " ";
@@ -2152,12 +2151,14 @@ QString MakefileGenerator::buildArgs(const QString &outdir)
         ret += " -nodependheuristics";
     if(!Option::mkfile::qmakespec_commandline.isEmpty())
         ret += " -spec " + specdir(outdir);
-    if(Option::target_mode == Option::TARG_MACX_MODE)
-        ret += " -macx";
-    else if(Option::target_mode == Option::TARG_UNIX_MODE)
-        ret += " -unix";
-    else if(Option::target_mode == Option::TARG_WIN_MODE)
-        ret += " -win32";
+    if (Option::target_mode_overridden) {
+        if (Option::target_mode == Option::TARG_MACX_MODE)
+            ret += " -macx";
+        else if (Option::target_mode == Option::TARG_UNIX_MODE)
+            ret += " -unix";
+        else if (Option::target_mode == Option::TARG_WIN_MODE)
+            ret += " -win32";
+    }
 
     //configs
     for(QStringList::Iterator it = Option::user_configs.begin();
@@ -2210,8 +2211,7 @@ MakefileGenerator::writeHeader(QTextStream &t)
     t << "# Project:  " << fileFixify(project->projectFile()) << endl;
     t << "# Template: " << var("TEMPLATE") << endl;
     if(!project->isActiveConfig("build_pass"))
-        t << "# Command: " << build_args().replace("$(QMAKE)",
-                      (project->isEmpty("QMAKE_QMAKE") ? QString("qmake") : var("QMAKE_QMAKE"))) << endl;
+        t << "# Command: " << build_args().replace("$(QMAKE)", var("QMAKE_QMAKE")) << endl;
     t << "#############################################################################" << endl;
     t << endl;
 }
@@ -2344,7 +2344,7 @@ MakefileGenerator::writeSubTargets(QTextStream &t, QList<MakefileGenerator::SubT
         t << "MAKEFILE      = " << ofile << endl;
         /* Calling Option::fixPathToTargetOS() is necessary for MinGW/MSYS, which requires
          * back-slashes to be turned into slashes. */
-        t << "QMAKE         = " << Option::fixPathToTargetOS(var("QMAKE_QMAKE")) << endl;
+        t << "QMAKE         = " << var("QMAKE_QMAKE") << endl;
         t << "DEL_FILE      = " << var("QMAKE_DEL_FILE") << endl;
         t << "CHK_DIR_EXISTS= " << var("QMAKE_CHK_DIR_EXISTS") << endl;
         t << "MKDIR         = " << var("QMAKE_MKDIR") << endl;
diff --git a/qmake/generators/makefile.h b/qmake/generators/makefile.h
index 85510ea9e8..4c3be3daf1 100644
--- a/qmake/generators/makefile.h
+++ b/qmake/generators/makefile.h
@@ -247,7 +247,8 @@ public:
     virtual bool supportsMergedBuilds() { return false; }
     virtual bool mergeBuildProject(MakefileGenerator * /*other*/) { return false; }
     virtual bool openOutput(QFile &, const QString &build) const;
-    virtual bool isWindowsShell() const { return Option::target_mode == Option::TARG_WIN_MODE; }
+    virtual bool isWindowsShell() const { return Option::host_mode == Option::HOST_WIN_MODE; }
+    virtual bool isForSymbianSbsv2() const { return false; } // FIXME: killme - i'm ugly!
 
     /* The next one is to avoid having SymbianCommonGenerator as a virtually
        inherited class of this class. Instead it is without a base class
diff --git a/qmake/generators/metamakefile.cpp b/qmake/generators/metamakefile.cpp
index dc3bbc7670..e76e596941 100644
--- a/qmake/generators/metamakefile.cpp
+++ b/qmake/generators/metamakefile.cpp
@@ -293,7 +293,15 @@ SubdirsMetaMakefileGenerator::init()
     init_flag = true;
     bool hasError = false;
 
-    if(Option::recursive) {
+    // It might make sense to bequeath the CONFIG option to the recursed
+    // projects. OTOH, one would most likely have it in all projects anyway -
+    // either through a qmakespec, a .qmake.cache or explicitly - as otherwise
+    // running qmake in a subdirectory would have a different auto-recurse
+    // setting than in parent directories.
+    bool recurse = Option::recursive == Option::QMAKE_RECURSIVE_YES
+                   || (Option::recursive == Option::QMAKE_RECURSIVE_DEFAULT
+                       && project->isRecursive());
+    if(recurse) {
         QString old_output_dir = Option::output_dir;
 	QString old_output = Option::output.fileName();
         QString oldpwd = qmake_getpwd();
@@ -375,7 +383,7 @@ SubdirsMetaMakefileGenerator::init()
     Subdir *self = new Subdir;
     self->input_dir = qmake_getpwd();
     self->output_dir = Option::output_dir;
-    if(!Option::recursive || (!Option::output.fileName().endsWith(Option::dir_sep) && !QFileInfo(Option::output).isDir()))
+    if(!recurse || (!Option::output.fileName().endsWith(Option::dir_sep) && !QFileInfo(Option::output).isDir()))
 	self->output_file = Option::output.fileName();
     self->makefile = new BuildsMetaMakefileGenerator(project, name, false);
     self->makefile->init();
@@ -459,7 +467,7 @@ MetaMakefileGenerator::createMakefileGenerator(QMakeProject *proj, bool noIO)
     } else if(gen == "PROJECTBUILDER" || gen == "XCODE") {
         mkfile = new ProjectBuilderMakefileGenerator;
     } else if(gen == "MSVC.NET") {
-        if(proj->first("TEMPLATE").indexOf(QRegExp("^vc.*")) != -1)
+        if (proj->first("TEMPLATE").startsWith("vc"))
             mkfile = new VcprojGenerator;
         else
             mkfile = new NmakeMakefileGenerator;
@@ -481,6 +489,40 @@ MetaMakefileGenerator::createMakefileGenerator(QMakeProject *proj, bool noIO)
     return mkfile;
 }
 
+bool
+MetaMakefileGenerator::modesForGenerator(const QString &gen,
+        Option::HOST_MODE *host_mode, Option::TARG_MODE *target_mode)
+{
+    if (gen == "UNIX") {
+#ifdef Q_OS_MAC
+        *host_mode = Option::HOST_MACX_MODE;
+        *target_mode = Option::TARG_MACX_MODE;
+#else
+        *host_mode = Option::HOST_UNIX_MODE;
+        *target_mode = Option::TARG_UNIX_MODE;
+#endif
+    } else if (gen == "MSVC.NET" || gen == "MINGW" || gen == "BMAKE") {
+        *host_mode = Option::HOST_WIN_MODE;
+        *target_mode = Option::TARG_WIN_MODE;
+    } else if (gen == "PROJECTBUILDER" || gen == "XCODE") {
+        *host_mode = Option::HOST_MACX_MODE;
+        *target_mode = Option::TARG_MACX_MODE;
+    } else if (gen == "SYMBIAN_ABLD" || gen == "SYMBIAN_SBSV2" || gen == "SYMBIAN_UNIX") {
+#if defined(Q_OS_MAC)
+        *host_mode = Option::HOST_MACX_MODE;
+#elif defined(Q_OS_UNIX)
+        *host_mode = Option::HOST_UNIX_MODE;
+#else
+        *host_mode = Option::HOST_WIN_MODE;
+#endif
+        *target_mode = Option::TARG_SYMBIAN_MODE;
+    } else {
+        fprintf(stderr, "Unknown generator specified: %s\n", gen.toLatin1().constData());
+        return false;
+    }
+    return true;
+}
+
 MetaMakefileGenerator *
 MetaMakefileGenerator::createMetaGenerator(QMakeProject *proj, const QString &name, bool op, bool *success)
 {
diff --git a/qmake/generators/metamakefile.h b/qmake/generators/metamakefile.h
index 867511589b..e559c8e863 100644
--- a/qmake/generators/metamakefile.h
+++ b/qmake/generators/metamakefile.h
@@ -42,6 +42,8 @@
 #ifndef METAMAKEFILE_H
 #define METAMAKEFILE_H
 
+#include <option.h>
+
 #include <qlist.h>
 #include <qstring.h>
 
@@ -65,6 +67,9 @@ public:
     static MetaMakefileGenerator *createMetaGenerator(QMakeProject *proj, const QString &name, bool op=true, bool *success = 0);
     static MakefileGenerator *createMakefileGenerator(QMakeProject *proj, bool noIO = false);
 
+    static bool modesForGenerator(const QString &generator,
+                                  Option::HOST_MODE *host_mode, Option::TARG_MODE *target_mode);
+
     inline QMakeProject *projectFile() const { return project; }
 
     virtual bool init() = 0;
diff --git a/qmake/generators/projectgenerator.cpp b/qmake/generators/projectgenerator.cpp
index 8622cd9fd4..d2256359db 100644
--- a/qmake/generators/projectgenerator.cpp
+++ b/qmake/generators/projectgenerator.cpp
@@ -111,7 +111,7 @@ ProjectGenerator::init()
                     add_depend = true;
                     if(dir.right(1) != Option::dir_sep)
                         dir += Option::dir_sep;
-                    if(Option::recursive) {
+                    if(Option::recursive == Option::QMAKE_RECURSIVE_YES) {
                         QStringList files = QDir(dir).entryList(QDir::Files);
                         for(int i = 0; i < (int)files.count(); i++) {
                             if(files[i] != "." && files[i] != "..")
@@ -138,7 +138,7 @@ ProjectGenerator::init()
                     dir = regex.left(s+1);
                     regex = regex.right(regex.length() - (s+1));
                 }
-                if(Option::recursive) {
+                if(Option::recursive == Option::QMAKE_RECURSIVE_YES) {
                     QStringList entries = QDir(dir).entryList(QDir::Dirs);
                     for(int i = 0; i < (int)entries.count(); i++) {
                         if(entries[i] != "." && entries[i] != "..") {
@@ -193,7 +193,7 @@ ProjectGenerator::init()
                                 subdirs.append(nd);
                         }
                     }
-                    if(Option::recursive) {
+                    if(Option::recursive == Option::QMAKE_RECURSIVE_YES) {
                         QStringList dirs = QDir(newdir).entryList(QDir::Dirs);
                         for(int i = 0; i < (int)dirs.count(); i++) {
                             QString nd = fileFixify(newdir + QDir::separator() + dirs[i]);
@@ -230,7 +230,8 @@ ProjectGenerator::init()
                                 }
                             }
                         }
-                        if(Option::recursive && !knownDirs.contains(newdir, Qt::CaseInsensitive))
+                        if(Option::recursive == Option::QMAKE_RECURSIVE_YES
+                           && !knownDirs.contains(newdir, Qt::CaseInsensitive))
                             knownDirs.append(newdir);
                     }
                 }
diff --git a/qmake/generators/symbian/symmake.cpp b/qmake/generators/symbian/symmake.cpp
index a812e5f90c..393e56b7b3 100644
--- a/qmake/generators/symbian/symmake.cpp
+++ b/qmake/generators/symbian/symmake.cpp
@@ -1001,6 +1001,10 @@ void SymbianMakefileGenerator::writeBldInfContent(QTextStream &t, bool addDeploy
             fixedItem = item;
         }
 
+        QString condition;
+        if (!project->isEmpty(item + ".condition"))
+            condition = project->first(item + ".condition");
+
         QFileInfo subdir(fileInfo(fixedItem));
         QString relativePath = directory.relativeFilePath(fixedItem);
         QString subdirFileName = subdir.completeBaseName();
@@ -1029,9 +1033,16 @@ void SymbianMakefileGenerator::writeBldInfContent(QTextStream &t, bool addDeploy
         bldinfDefine = bldinfDefine.toUpper();
         removeEpocSpecialCharacters(bldinfDefine);
 
+        if (!condition.isEmpty())
+            t << "#if defined(" << condition << ")" << endl;
+
         t << "#ifndef " << bldinfDefine << endl;
         t << "\t#include \"" << bldinfFilename << "\"" << endl;
-        t << "#endif // " << bldinfDefine << endl;
+        t << "#endif" << endl;
+
+        if (!condition.isEmpty())
+            t << "#endif" << endl;
+
     }
 
     // Add supported project platforms
diff --git a/qmake/generators/symbian/symmake_abld.cpp b/qmake/generators/symbian/symmake_abld.cpp
index 1fc87aae80..f05e7ff8f4 100644
--- a/qmake/generators/symbian/symmake_abld.cpp
+++ b/qmake/generators/symbian/symmake_abld.cpp
@@ -200,7 +200,7 @@ void SymbianAbldMakefileGenerator::writeWrapperMakefile(QFile& wrapperFile, bool
     t << endl;
 
     t << "MAKEFILE          = " << wrapperFile.fileName() << endl;
-    t << "QMAKE             = " << Option::fixPathToTargetOS(var("QMAKE_QMAKE")) << endl;
+    t << "QMAKE             = " << var("QMAKE_QMAKE") << endl;
     t << "DEL_FILE          = " << var("QMAKE_DEL_FILE") << endl;
     t << "DEL_DIR           = " << var("QMAKE_DEL_DIR") << endl;
     t << "MOVE              = " << var("QMAKE_MOVE") << endl;
diff --git a/qmake/generators/symbian/symmake_sbsv2.cpp b/qmake/generators/symbian/symmake_sbsv2.cpp
index 8c7eabf3ad..d1d0104bcd 100644
--- a/qmake/generators/symbian/symmake_sbsv2.cpp
+++ b/qmake/generators/symbian/symmake_sbsv2.cpp
@@ -144,7 +144,7 @@ void SymbianSbsv2MakefileGenerator::writeWrapperMakefile(QFile& wrapperFile, boo
     t << "# ==============================================================================" << "\n" << endl;
     t << endl;
     t << "MAKEFILE          = " << wrapperFile.fileName() << endl;
-    t << "QMAKE             = " << Option::fixPathToTargetOS(var("QMAKE_QMAKE")) << endl;
+    t << "QMAKE             = " << var("QMAKE_QMAKE") << endl;
     t << "DEL_FILE          = " << var("QMAKE_DEL_FILE") << endl;
     t << "DEL_DIR           = " << var("QMAKE_DEL_DIR") << endl;
     t << "MOVE              = " << var("QMAKE_MOVE") << endl;
diff --git a/qmake/generators/symbian/symmake_sbsv2.h b/qmake/generators/symbian/symmake_sbsv2.h
index b8ccdbec98..286c91ca6a 100644
--- a/qmake/generators/symbian/symmake_sbsv2.h
+++ b/qmake/generators/symbian/symmake_sbsv2.h
@@ -56,6 +56,7 @@ protected:
     virtual void writeMkFile(const QString& wrapperFileName, bool deploymentOnly);
     virtual void writeWrapperMakefile(QFile& wrapperFile, bool isPrimaryMakefile);
     virtual void appendAbldTempDirs(QStringList& sysincspaths, QString includepath);
+    virtual bool isForSymbianSbsv2() const { return true; } // FIXME: killme - i'm ugly!
 
 public:
 
diff --git a/qmake/generators/unix/unixmake.cpp b/qmake/generators/unix/unixmake.cpp
index 030983d07c..db5b957da9 100644
--- a/qmake/generators/unix/unixmake.cpp
+++ b/qmake/generators/unix/unixmake.cpp
@@ -103,8 +103,6 @@ UnixMakefileGenerator::init()
         MakefileGenerator::init();
         if(project->isEmpty("MAKEFILE"))
             project->values("MAKEFILE").append("Makefile");
-        if(project->isEmpty("QMAKE_QMAKE"))
-            project->values("QMAKE_QMAKE").append("qmake");
         if(project->values("QMAKE_INTERNAL_QMAKE_DEPS").indexOf("qmake_all") == -1)
             project->values("QMAKE_INTERNAL_QMAKE_DEPS").append("qmake_all");
         return; /* subdirs is done */
diff --git a/qmake/generators/unix/unixmake2.cpp b/qmake/generators/unix/unixmake2.cpp
index b9e0ec840a..3e731a190f 100644
--- a/qmake/generators/unix/unixmake2.cpp
+++ b/qmake/generators/unix/unixmake2.cpp
@@ -81,7 +81,7 @@ UnixMakefileGenerator::writeMakefile(QTextStream &t)
 
     writeHeader(t);
     if(!project->values("QMAKE_FAILED_REQUIREMENTS").isEmpty()) {
-        t << "QMAKE    = "        << (project->isEmpty("QMAKE_QMAKE") ? QString("qmake") : var("QMAKE_QMAKE")) << endl;
+        t << "QMAKE    = " << var("QMAKE_QMAKE") << endl;
         QStringList &qut = project->values("QMAKE_EXTRA_TARGETS");
         for(QStringList::ConstIterator it = qut.begin(); it != qut.end(); ++it)
             t << *it << " ";
@@ -154,7 +154,7 @@ UnixMakefileGenerator::writeMakeParts(QTextStream &t)
 
     t << "AR            = " << var("QMAKE_AR") << endl;
     t << "RANLIB        = " << var("QMAKE_RANLIB") << endl;
-    t << "QMAKE         = " << (project->isEmpty("QMAKE_QMAKE") ? QString("qmake") : var("QMAKE_QMAKE")) << endl;
+    t << "QMAKE         = " << var("QMAKE_QMAKE") << endl;
     t << "TAR           = " << var("QMAKE_TAR") << endl;
     t << "COMPRESS      = " << var("QMAKE_GZIP") << endl;
     if(project->isActiveConfig("compile_libtool"))
diff --git a/qmake/generators/win32/borland_bmake.cpp b/qmake/generators/win32/borland_bmake.cpp
index 9208e1d2b6..b5c33c432c 100644
--- a/qmake/generators/win32/borland_bmake.cpp
+++ b/qmake/generators/win32/borland_bmake.cpp
@@ -115,8 +115,6 @@ BorlandMakefileGenerator::init()
             project->values("QMAKE_INSTALL_DIR").append("$(COPY_DIR)");
         if(project->values("MAKEFILE").isEmpty())
             project->values("MAKEFILE").append("Makefile");
-        if(project->values("QMAKE_QMAKE").isEmpty())
-            project->values("QMAKE_QMAKE").append("qmake");
         return;
     }
 
diff --git a/qmake/generators/win32/mingw_make.cpp b/qmake/generators/win32/mingw_make.cpp
index e1f502f68e..fd431459c5 100644
--- a/qmake/generators/win32/mingw_make.cpp
+++ b/qmake/generators/win32/mingw_make.cpp
@@ -143,7 +143,7 @@ bool MingwMakefileGenerator::writeMakefile(QTextStream &t)
     if(project->first("TEMPLATE") == "app" ||
        project->first("TEMPLATE") == "lib") {
         if(Option::mkfile::do_stub_makefile) {
-            t << "QMAKE    = "        << (project->isEmpty("QMAKE_QMAKE") ? QString("qmake") : var("QMAKE_QMAKE")) << endl;
+            t << "QMAKE    = " << var("QMAKE_QMAKE") << endl;
             QStringList &qut = project->values("QMAKE_EXTRA_TARGETS");
             for(QStringList::ConstIterator it = qut.begin(); it != qut.end(); ++it)
                 t << *it << " ";
@@ -248,8 +248,6 @@ void MingwMakefileGenerator::init()
             project->values("QMAKE_INSTALL_DIR").append("$(COPY_DIR)");
         if(project->values("MAKEFILE").isEmpty())
             project->values("MAKEFILE").append("Makefile");
-        if(project->values("QMAKE_QMAKE").isEmpty())
-            project->values("QMAKE_QMAKE").append("qmake");
         return;
     }
 
diff --git a/qmake/generators/win32/msvc_nmake.cpp b/qmake/generators/win32/msvc_nmake.cpp
index 7566b23845..92e8aeba7f 100644
--- a/qmake/generators/win32/msvc_nmake.cpp
+++ b/qmake/generators/win32/msvc_nmake.cpp
@@ -156,8 +156,6 @@ void NmakeMakefileGenerator::init()
         MakefileGenerator::init();
         if(project->values("MAKEFILE").isEmpty())
             project->values("MAKEFILE").append("Makefile");
-        if(project->values("QMAKE_QMAKE").isEmpty())
-            project->values("QMAKE_QMAKE").append("qmake");
         if(project->isEmpty("QMAKE_COPY_FILE"))
             project->values("QMAKE_COPY_FILE").append("$(COPY)");
         if(project->isEmpty("QMAKE_COPY_DIR"))
diff --git a/qmake/generators/win32/winmakefile.cpp b/qmake/generators/win32/winmakefile.cpp
index 9d3b4c62c6..64aaf34294 100644
--- a/qmake/generators/win32/winmakefile.cpp
+++ b/qmake/generators/win32/winmakefile.cpp
@@ -150,6 +150,10 @@ Win32MakefileGenerator::findLibraries(const QString &where)
                     if(QMakeMetaInfo::libExists((*it).local() + Option::dir_sep + lib) ||
                        exists((*it).local() + Option::dir_sep + lib + extension)) {
                         out = (*it).real() + Option::dir_sep + lib + extension;
+                        if (out.contains(QLatin1Char(' '))) {
+                            out.prepend(QLatin1Char('\"'));
+                            out.append(QLatin1Char('\"'));
+                        }
                         break;
                     }
                 }
@@ -591,8 +595,7 @@ void Win32MakefileGenerator::writeStandardParts(QTextStream &t)
     writeIncPart(t);
     writeLibsPart(t);
 
-    t << "QMAKE         = " << (project->isEmpty("QMAKE_QMAKE") ? QString("qmake") :
-                              Option::fixPathToTargetOS(var("QMAKE_QMAKE"), false)) << endl;
+    t << "QMAKE         = " << var("QMAKE_QMAKE") << endl;
     t << "IDC           = " << (project->isEmpty("QMAKE_IDC") ? QString("idc") :
                               Option::fixPathToTargetOS(var("QMAKE_IDC"), false)) << endl;
     t << "IDL           = " << (project->isEmpty("QMAKE_IDL") ? QString("midl") :
@@ -764,6 +767,11 @@ QString Win32MakefileGenerator::getLibTarget()
     return QString(project->first("TARGET") + project->first("TARGET_VERSION_EXT") + ".lib");
 }
 
+QString Win32MakefileGenerator::getPdbTarget()
+{
+    return QString(project->first("TARGET") + project->first("TARGET_VERSION_EXT") + ".pdb");
+}
+
 QString Win32MakefileGenerator::defaultInstall(const QString &t)
 {
     if((t != "target" && t != "dlltarget") ||
@@ -804,6 +812,18 @@ QString Win32MakefileGenerator::defaultInstall(const QString &t)
                 uninst.append("\n\t");
             uninst.append("-$(DEL_FILE) \"" + dst_targ + "\"");
         }
+        if(project->isActiveConfig("shared") && project->isActiveConfig("debug")) {
+            QString pdb_target = getPdbTarget();
+            pdb_target.remove('"');
+            QString src_targ = (project->isEmpty("DESTDIR") ? QString("$(DESTDIR)") : project->first("DESTDIR")) + pdb_target;
+            QString dst_targ = filePrefixRoot(root, fileFixify(targetdir + pdb_target, FileFixifyAbsolute));
+            if(!ret.isEmpty())
+                ret += "\n\t";
+            ret += QString("-$(INSTALL_FILE)") + " \"" + src_targ + "\" \"" + dst_targ + "\"";
+            if(!uninst.isEmpty())
+                uninst.append("\n\t");
+            uninst.append("-$(DEL_FILE) \"" + dst_targ + "\"");
+        }
     }
 
     if(t == "dlltarget" || project->values(t + ".CONFIG").indexOf("no_dll") == -1) {
diff --git a/qmake/generators/win32/winmakefile.h b/qmake/generators/win32/winmakefile.h
index 5437524495..3a2e3a1ee8 100644
--- a/qmake/generators/win32/winmakefile.h
+++ b/qmake/generators/win32/winmakefile.h
@@ -83,6 +83,7 @@ protected:
     virtual void processRcFileVar();
     virtual void processFileTagsVar();
     virtual QString getLibTarget();
+    virtual QString getPdbTarget();
 };
 
 inline Win32MakefileGenerator::~Win32MakefileGenerator()
diff --git a/qmake/main.cpp b/qmake/main.cpp
index 50f9272e22..42679a2e93 100644
--- a/qmake/main.cpp
+++ b/qmake/main.cpp
@@ -149,7 +149,7 @@ int runQMake(int argc, char **argv)
             //setup pwd properly
             debug_msg(1, "Resetting dir to: %s", oldpwd.toLatin1().constData());
             qmake_setpwd(oldpwd); //reset the old pwd
-            int di = fn.lastIndexOf(Option::dir_sep);
+            int di = fn.lastIndexOf(QDir::separator());
             if(di != -1) {
                 debug_msg(1, "Changing dir to: %s", fn.left(di).toLatin1().constData());
                 if(!qmake_setpwd(fn.left(di)))
diff --git a/qmake/option.cpp b/qmake/option.cpp
index f77561742d..d7c5397c7e 100644
--- a/qmake/option.cpp
+++ b/qmake/option.cpp
@@ -88,7 +88,7 @@ int Option::warn_level = WarnLogic;
 int Option::debug_level = 0;
 QFile Option::output;
 QString Option::output_dir;
-bool Option::recursive = false;
+Option::QMAKE_RECURSIVE Option::recursive = Option::QMAKE_RECURSIVE_DEFAULT;
 QStringList Option::before_user_vars;
 QStringList Option::after_user_vars;
 QStringList Option::user_configs;
@@ -96,13 +96,9 @@ QStringList Option::after_user_configs;
 QString Option::user_template;
 QString Option::user_template_prefix;
 QStringList Option::shellPath;
-#if defined(Q_OS_WIN32)
-Option::TARG_MODE Option::target_mode = Option::TARG_WIN_MODE;
-#elif defined(Q_OS_MAC)
-Option::TARG_MODE Option::target_mode = Option::TARG_MACX_MODE;
-#else
-Option::TARG_MODE Option::target_mode = Option::TARG_UNIX_MODE;
-#endif
+Option::HOST_MODE Option::host_mode = Option::HOST_UNKNOWN_MODE;
+Option::TARG_MODE Option::target_mode = Option::TARG_UNKNOWN_MODE;
+bool Option::target_mode_overridden = false;
 
 //QMAKE_*_PROPERTY stuff
 QStringList Option::prop::properties;
@@ -126,7 +122,7 @@ QString Option::mkfile::qmakespec_commandline;
 
 static Option::QMAKE_MODE default_mode(QString progname)
 {
-    int s = progname.lastIndexOf(Option::dir_sep);
+    int s = progname.lastIndexOf(QDir::separator());
     if(s != -1)
         progname = progname.right(progname.length() - (s + 1));
     if(progname == "qmakegen")
@@ -184,9 +180,6 @@ bool usage(const char *a0)
             "   * processed as if it was in [files]. These assignments will be parsed *\n"
             "   * before [files].                                                     *\n"
             "  -o file        Write output to file\n"
-            "  -unix          Run in unix mode\n"
-            "  -win32         Run in win32 mode\n"
-            "  -macx          Run in Mac OS X mode\n"
             "  -d             Increase debug level\n"
             "  -t templ       Overrides TEMPLATE as templ\n"
             "  -tp prefix     Overrides TEMPLATE so that prefix is prefixed into the value\n"
@@ -223,7 +216,7 @@ Option::parseCommandLine(int argc, char **argv, int skip)
             if(x == 1) {
                 bool specified = true;
                 if(opt == "project") {
-                    Option::recursive = true;
+                    Option::recursive = Option::QMAKE_RECURSIVE_YES;
                     Option::qmake_mode = Option::QMAKE_GENERATE_PROJECT;
                 } else if(opt == "prl") {
                     Option::mkfile::do_deps = false;
@@ -251,11 +244,20 @@ Option::parseCommandLine(int argc, char **argv, int skip)
             } else if(opt == "tp" || opt == "template_prefix") {
                 Option::user_template_prefix = argv[++x];
             } else if(opt == "macx") {
+                fprintf(stderr, "-macx is deprecated.\n");
+                Option::host_mode = HOST_MACX_MODE;
                 Option::target_mode = TARG_MACX_MODE;
+                Option::target_mode_overridden = true;
             } else if(opt == "unix") {
+                fprintf(stderr, "-unix is deprecated.\n");
+                Option::host_mode = HOST_UNIX_MODE;
                 Option::target_mode = TARG_UNIX_MODE;
+                Option::target_mode_overridden = true;
             } else if(opt == "win32") {
+                fprintf(stderr, "-win32 is deprecated.\n");
+                Option::host_mode = HOST_WIN_MODE;
                 Option::target_mode = TARG_WIN_MODE;
+                Option::target_mode_overridden = true;
             } else if(opt == "d") {
                 Option::debug_level++;
             } else if(opt == "version" || opt == "v" || opt == "-version") {
@@ -279,9 +281,9 @@ Option::parseCommandLine(int argc, char **argv, int skip)
             } else if(opt == "Wnone") {
                 Option::warn_level = WarnNone;
             } else if(opt == "r" || opt == "recursive") {
-                Option::recursive = true;
-            } else if(opt == "norecursive") {
-                Option::recursive = false;
+                Option::recursive = Option::QMAKE_RECURSIVE_YES;
+            } else if(opt == "nr" || opt == "norecursive") {
+                Option::recursive = Option::QMAKE_RECURSIVE_NO;
             } else if(opt == "config") {
                 Option::user_configs += argv[++x];
             } else {
@@ -405,6 +407,7 @@ Option::init(int argc, char **argv)
 #ifdef Q_OS_WIN
     Option::dirlist_sep = ";";
     Option::shellPath = detectShellPath();
+    Option::res_ext = ".res";
 #else
     Option::dirlist_sep = ":";
     Option::shellPath = QStringList("sh");
@@ -523,21 +526,37 @@ Option::init(int argc, char **argv)
             }
 #endif
         }
+    } else if (Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT) {
+#if defined(Q_OS_MAC)
+        Option::host_mode = Option::HOST_MACX_MODE;
+        Option::target_mode = Option::TARG_MACX_MODE;
+#elif defined(Q_OS_UNIX)
+        Option::host_mode = Option::HOST_UNIX_MODE;
+        Option::target_mode = Option::TARG_UNIX_MODE;
+#else
+        Option::host_mode = Option::HOST_WIN_MODE;
+        Option::target_mode = Option::TARG_WIN_MODE;
+#endif
     }
 
     //defaults for globals
-    if(Option::target_mode == Option::TARG_WIN_MODE) {
-        Option::dir_sep = "\\";
-        Option::obj_ext = ".obj";
-        Option::res_ext = ".res";
-    } else {
-        Option::dir_sep = "/";
-        Option::obj_ext = ".o";
-    }
-    Option::qmake_abslocation = Option::fixPathToTargetOS(Option::qmake_abslocation);
+    if (Option::host_mode != Option::HOST_UNKNOWN_MODE)
+        applyHostMode();
     return QMAKE_CMDLINE_SUCCESS;
 }
 
+void Option::applyHostMode()
+{
+   if (Option::host_mode == Option::HOST_WIN_MODE) {
+       Option::dir_sep = "\\";
+       Option::obj_ext = ".obj";
+   } else {
+       Option::dir_sep = "/";
+       Option::obj_ext = ".o";
+   }
+   Option::qmake_abslocation = Option::fixPathToTargetOS(Option::qmake_abslocation);
+}
+
 bool Option::postProcessProject(QMakeProject *project)
 {
     Option::cpp_ext = project->variables()["QMAKE_EXT_CPP"];
diff --git a/qmake/option.h b/qmake/option.h
index a2ca676d4a..9bfdaede88 100644
--- a/qmake/option.h
+++ b/qmake/option.h
@@ -106,6 +106,7 @@ struct Option
 
     //both of these must be called..
     static int init(int argc=0, char **argv=0); //parse cmdline
+    static void applyHostMode();
     static bool postProcessProject(QMakeProject *);
 
     enum StringFixFlags {
@@ -148,10 +149,15 @@ struct Option
     static QString output_dir;
     static int debug_level;
     static int warn_level;
-    static bool recursive;
+    enum QMAKE_RECURSIVE { QMAKE_RECURSIVE_DEFAULT, QMAKE_RECURSIVE_YES, QMAKE_RECURSIVE_NO };
+    static QMAKE_RECURSIVE recursive;
     static QStringList before_user_vars, after_user_vars, user_configs, after_user_configs;
-    enum TARG_MODE { TARG_UNIX_MODE, TARG_WIN_MODE, TARG_MACX_MODE };
+    enum HOST_MODE { HOST_UNKNOWN_MODE, HOST_UNIX_MODE, HOST_WIN_MODE, HOST_MACX_MODE };
+    static HOST_MODE host_mode;
+    enum TARG_MODE { TARG_UNKNOWN_MODE, TARG_UNIX_MODE, TARG_WIN_MODE, TARG_MACX_MODE,
+                     TARG_SYMBIAN_MODE };
     static TARG_MODE target_mode;
+    static bool target_mode_overridden;
     static QString user_template, user_template_prefix;
     static QStringList shellPath;
 
diff --git a/qmake/project.cpp b/qmake/project.cpp
index e1f2030eac..9e6db108ea 100644
--- a/qmake/project.cpp
+++ b/qmake/project.cpp
@@ -43,6 +43,7 @@
 #include "property.h"
 #include "option.h"
 #include "cachekeys.h"
+#include "generators/metamakefile.h"
 
 #include <qdatetime.h>
 #include <qfile.h>
@@ -121,7 +122,7 @@ enum TestFunc { T_REQUIRES=1, T_GREATERTHAN, T_LESSTHAN, T_EQUALS,
                 T_EXISTS, T_EXPORT, T_CLEAR, T_UNSET, T_EVAL, T_CONFIG, T_SYSTEM,
                 T_RETURN, T_BREAK, T_NEXT, T_DEFINED, T_CONTAINS, T_INFILE,
                 T_COUNT, T_ISEMPTY, T_INCLUDE, T_LOAD, T_DEBUG, T_ERROR,
-                T_MESSAGE, T_WARNING, T_IF };
+                T_MESSAGE, T_WARNING, T_IF, T_OPTION };
 QMap<QString, TestFunc> qmake_testFunctions()
 {
     static QMap<QString, TestFunc> *qmake_test_functions = 0;
@@ -155,6 +156,7 @@ QMap<QString, TestFunc> qmake_testFunctions()
         qmake_test_functions->insert("error", T_ERROR);
         qmake_test_functions->insert("message", T_MESSAGE);
         qmake_test_functions->insert("warning", T_WARNING);
+        qmake_test_functions->insert("option", T_OPTION);
     }
     return *qmake_test_functions;
 }
@@ -507,76 +509,6 @@ static void qmake_error_msg(const QString &msg)
             msg.toLatin1().constData());
 }
 
-enum isForSymbian_enum {
-    isForSymbian_NOT_SET = -1,
-    isForSymbian_FALSE = 0,
-    isForSymbian_ABLD = 1,
-    isForSymbian_SBSV2 = 2,
-    isForSymbian_MAKEFILE = 3,
-};
-
-static isForSymbian_enum isForSymbian_value = isForSymbian_NOT_SET;
-
-// Checking for symbian build is primarily determined from the qmake spec,
-// but if that is not specified, detect if symbian is the default spec
-// by checking the MAKEFILE_GENERATOR variable value.
-static void init_symbian(const QMap<QString, QStringList>& vars)
-{
-    if (isForSymbian_value != isForSymbian_NOT_SET)
-        return;
-
-    QString spec = QDir::fromNativeSeparators(QFileInfo(Option::mkfile::qmakespec).canonicalFilePath());
-    int pos = spec.lastIndexOf('/');
-    pos = spec.lastIndexOf('/', pos - 1);
-    spec = spec.mid(pos + 1);
-    if (spec.endsWith("symbian-abld", Qt::CaseInsensitive)) {
-        isForSymbian_value = isForSymbian_ABLD;
-    } else if (spec.endsWith("symbian-sbsv2", Qt::CaseInsensitive)) {
-        isForSymbian_value = isForSymbian_SBSV2;
-    } else if (spec.startsWith("symbian/", Qt::CaseInsensitive)) {
-        isForSymbian_value = isForSymbian_MAKEFILE;
-    } else {
-        QStringList generatorList = vars["MAKEFILE_GENERATOR"];
-
-        if (!generatorList.isEmpty()) {
-            QString generator = generatorList.first();
-            if (generator.startsWith("SYMBIAN_ABLD"))
-                isForSymbian_value = isForSymbian_ABLD;
-            else if (generator.startsWith("SYMBIAN_SBSV2"))
-                isForSymbian_value = isForSymbian_SBSV2;
-            else
-                isForSymbian_value = isForSymbian_FALSE;
-        } else {
-            isForSymbian_value = isForSymbian_FALSE;
-        }
-    }
-
-    // Force recursive on Symbian native build system, as non-recursive is not really
-    // a viable option there
-    if (isForSymbian_value != isForSymbian_FALSE && isForSymbian_value != isForSymbian_MAKEFILE)
-        Option::recursive = true;
-}
-
-bool isForSymbian()
-{
-    // If isForSymbian_value has not been initialized explicitly yet,
-    // call initializer with dummy map to check qmake spec.
-    if (isForSymbian_value == isForSymbian_NOT_SET)
-        init_symbian(QMap<QString, QStringList>());
-
-    return (isForSymbian_value != isForSymbian_NOT_SET && isForSymbian_value != isForSymbian_FALSE);
-}
-
-bool isForSymbianSbsv2()
-{
-    // If isForSymbian_value has not been initialized explicitly yet,
-    // call initializer with dummy map to check qmake spec.
-    if (isForSymbian_value == isForSymbian_NOT_SET)
-        init_symbian(QMap<QString, QStringList>());
-
-    return (isForSymbian_value == isForSymbian_SBSV2);
-}
-
 /*
    1) environment variable QMAKEFEATURES (as separated by colons)
    2) property variable QMAKEFEATURES (as separated by colons)
@@ -602,22 +534,16 @@ QStringList qmake_feature_paths(QMakeProperty *prop=0)
             concat << base_concat + QDir::separator() + "macx";
             concat << base_concat + QDir::separator() + "unix";
             break;
+        default: // Can't happen, just make the compiler shut up
         case Option::TARG_UNIX_MODE:
-            {
-                if (isForSymbian())
-                    concat << base_concat + QDir::separator() + "symbian";
-                else
-                    concat << base_concat + QDir::separator() + "unix";
-                break;
-            }
+            concat << base_concat + QDir::separator() + "unix";
+            break;
         case Option::TARG_WIN_MODE:
-            {
-                if (isForSymbian())
-                    concat << base_concat + QDir::separator() + "symbian";
-                else
-                    concat << base_concat + QDir::separator() + "win32";
-                break;
-            }
+            concat << base_concat + QDir::separator() + "win32";
+            break;
+        case Option::TARG_SYMBIAN_MODE:
+            concat << base_concat + QDir::separator() + "symbian";
+            break;
         }
         concat << base_concat;
     }
@@ -630,7 +556,7 @@ QStringList qmake_feature_paths(QMakeProperty *prop=0)
         feature_roots += splitPathList(prop->value("QMAKEFEATURES"));
     if(!Option::mkfile::cachefile.isEmpty()) {
         QString path;
-        int last_slash = Option::mkfile::cachefile.lastIndexOf(Option::dir_sep);
+        int last_slash = Option::mkfile::cachefile.lastIndexOf(QDir::separator());
         if(last_slash != -1)
             path = Option::fixPathToLocalOS(Option::mkfile::cachefile.left(last_slash));
         for(QStringList::Iterator concat_it = concat.begin();
@@ -773,6 +699,7 @@ QMakeProject::reset()
     scope_blocks.push(ScopeBlock());
     iterator = 0;
     function = 0;
+    recursive = false;
 }
 
 bool
@@ -1363,16 +1290,7 @@ bool
 QMakeProject::read(uchar cmd)
 {
     if(cfile.isEmpty()) {
-        //find out where qmake (myself) lives
-        if (!base_vars.contains("QMAKE_QMAKE")) {
-            if (!Option::qmake_abslocation.isNull())
-                base_vars["QMAKE_QMAKE"] = QStringList(Option::qmake_abslocation);
-            else
-                base_vars["QMAKE_QMAKE"] = QStringList("qmake");
-        }
-
         // hack to get the Option stuff in there
-        base_vars["QMAKE_EXT_OBJ"] = QStringList(Option::obj_ext);
         base_vars["QMAKE_EXT_CPP"] = Option::cpp_ext;
         base_vars["QMAKE_EXT_C"] = Option::c_ext;
         base_vars["QMAKE_EXT_H"] = Option::h_ext;
@@ -1463,8 +1381,7 @@ QMakeProject::read(uchar cmd)
                 fprintf(stderr, "Failure to read QMAKESPEC conf file %s.\n", spec.toLatin1().constData());
                 return false;
             }
-
-            init_symbian(base_vars);
+            validateModes();
 
             if(Option::mkfile::do_cache && !Option::mkfile::cachefile.isEmpty()) {
                 debug_msg(1, "QMAKECACHE file: reading %s", Option::mkfile::cachefile.toLatin1().constData());
@@ -1588,6 +1505,46 @@ QMakeProject::read(uchar cmd)
     return true;
 }
 
+void QMakeProject::validateModes()
+{
+    if (Option::host_mode == Option::HOST_UNKNOWN_MODE
+        || Option::target_mode == Option::TARG_UNKNOWN_MODE) {
+        Option::HOST_MODE host_mode;
+        Option::TARG_MODE target_mode;
+        const QStringList &gen = base_vars.value("MAKEFILE_GENERATOR");
+        if (gen.isEmpty()) {
+            fprintf(stderr, "%s:%d: Using OS scope before setting MAKEFILE_GENERATOR\n",
+                            parser.file.toLatin1().constData(), parser.line_no);
+        } else if (MetaMakefileGenerator::modesForGenerator(gen.first(),
+                                                            &host_mode, &target_mode)) {
+            if (Option::host_mode == Option::HOST_UNKNOWN_MODE) {
+                Option::host_mode = host_mode;
+                Option::applyHostMode();
+            }
+
+            if (Option::target_mode == Option::TARG_UNKNOWN_MODE) {
+                const QStringList &tgt = base_vars.value("TARGET_PLATFORM");
+                if (!tgt.isEmpty()) {
+                    const QString &os = tgt.first();
+                    if (os == "unix")
+                        Option::target_mode = Option::TARG_UNIX_MODE;
+                    else if (os == "macx")
+                        Option::target_mode = Option::TARG_MACX_MODE;
+                    else if (os == "symbian")
+                        Option::target_mode = Option::TARG_SYMBIAN_MODE;
+                    else if (os == "win32")
+                        Option::target_mode = Option::TARG_WIN_MODE;
+                    else
+                        fprintf(stderr, "Unknown target platform specified: %s\n",
+                                os.toLatin1().constData());
+                } else {
+                    Option::target_mode = target_mode;
+                }
+            }
+        }
+    }
+}
+
 bool
 QMakeProject::isActiveConfig(const QString &x, bool regex, QMap<QString, QStringList> *place)
 {
@@ -1600,26 +1557,26 @@ QMakeProject::isActiveConfig(const QString &x, bool regex, QMap<QString, QString
     else if(x == "false")
         return false;
 
+    if (x == "unix") {
+        validateModes();
+        return Option::target_mode == Option::TARG_UNIX_MODE
+               || Option::target_mode == Option::TARG_MACX_MODE
+               || Option::target_mode == Option::TARG_SYMBIAN_MODE;
+    } else if (x == "macx" || x == "mac") {
+        validateModes();
+        return Option::target_mode == Option::TARG_MACX_MODE;
+    } else if (x == "symbian") {
+        validateModes();
+        return Option::target_mode == Option::TARG_SYMBIAN_MODE;
+    } else if (x == "win32") {
+        validateModes();
+        return Option::target_mode == Option::TARG_WIN_MODE;
+    }
+
+    //mkspecs
     static QString spec;
     if(spec.isEmpty())
         spec = QFileInfo(Option::mkfile::qmakespec).fileName();
-
-    // Symbian is an exception to how scopes are resolved. Since we do not
-    // have a separate target mode for Symbian, but we expect the scope to resolve
-    // on other platforms we base it entirely on the mkspec. This means that
-    // using a mkspec starting with 'symbian*' will resolve both the 'symbian'
-    // and the 'unix' (because of Open C) scopes to true.
-    if(isForSymbian() && (x == "symbian" || x == "unix"))
-        return true;
-
-    //mkspecs
-    if((Option::target_mode == Option::TARG_MACX_MODE ||
-        Option::target_mode == Option::TARG_UNIX_MODE) && x == "unix")
-        return !isForSymbian();
-    else if(Option::target_mode == Option::TARG_MACX_MODE && (x == "macx" || x == "mac"))
-        return !isForSymbian();
-    else if(Option::target_mode == Option::TARG_WIN_MODE && x == "win32")
-        return !isForSymbian();
     QRegExp re(x, Qt::CaseSensitive, QRegExp::Wildcard);
     if((regex && re.exactMatch(spec)) || (!regex && spec == x))
         return true;
@@ -1711,7 +1668,7 @@ QMakeProject::doProjectInclude(QString file, uchar flags, QMap<QString, QStringL
         if(file.indexOf(Option::dir_sep) == -1 || !QFile::exists(file)) {
             static QStringList *feature_roots = 0;
             if(!feature_roots) {
-                init_symbian(base_vars);
+                validateModes();
                 feature_roots = new QStringList(qmake_feature_paths(prop));
                 qmakeAddCacheClear(qmakeDeleteCacheClear_QStringList, (void**)&feature_roots);
             }
@@ -2775,6 +2732,21 @@ QMakeProject::doProjectTest(QString func, QList<QStringList> args_list, QMap<QSt
             exit(2);
 #endif
         return true; }
+    case T_OPTION:
+        if (args.count() != 1) {
+            fprintf(stderr, "%s:%d: option() requires one argument.\n",
+                    parser.file.toLatin1().constData(), parser.line_no);
+            return false;
+        }
+        if (args.first() == "recursive") {
+            recursive = true;
+        } else {
+            fprintf(stderr, "%s:%d: unrecognized option() argument '%s'.\n",
+                    parser.file.toLatin1().constData(), parser.line_no,
+                    args.first().toLatin1().constData());
+            return false;
+        }
+        return true;
     default:
         fprintf(stderr, "%s:%d: Unknown test function: %s\n", parser.file.toLatin1().constData(), parser.line_no,
                 func.toLatin1().constData());
@@ -3157,6 +3129,19 @@ QStringList &QMakeProject::values(const QString &_var, QMap<QString, QStringList
     } else if (var == QLatin1String("QMAKE_DIR_SEP")) {
         if (place[var].isEmpty())
             return values("DIR_SEPARATOR", place);
+    } else if (var == QLatin1String("QMAKE_EXT_OBJ")) {
+        if (place[var].isEmpty()) {
+            var = ".BUILTIN." + var;
+            place[var] = QStringList(Option::obj_ext);
+        }
+    } else if (var == QLatin1String("QMAKE_QMAKE")) {
+        if (place[var].isEmpty()) {
+            if (!Option::qmake_abslocation.isNull())
+                place[var] = QStringList(Option::qmake_abslocation);
+            else
+                place[var] = QStringList(Option::fixPathToTargetOS(
+                        QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qmake", false));
+        }
     } else if (var == QLatin1String("EPOCROOT")) {
         if (place[var].isEmpty())
             place[var] = QStringList(epocRoot());
diff --git a/qmake/project.h b/qmake/project.h
index 1f53bf22ab..bfebed0be2 100644
--- a/qmake/project.h
+++ b/qmake/project.h
@@ -78,6 +78,7 @@ class QMakeProject
     FunctionBlock *function;
     QMap<QString, FunctionBlock*> testFunctions, replaceFunctions;
 
+    bool recursive;
     bool own_prop;
     QString pfile, cfile;
     QMakeProperty *prop;
@@ -105,6 +106,7 @@ class QMakeProject
     QStringList doVariableReplaceExpand(const QString &str, QMap<QString, QStringList> &place, bool *ok=0);
     void init(QMakeProperty *, const QMap<QString, QStringList> *);
     QStringList &values(const QString &v, QMap<QString, QStringList> &place);
+    void validateModes();
 
 public:
     QMakeProject() { init(0, 0); }
@@ -154,6 +156,8 @@ public:
     QString first(const QString &v);
     QMap<QString, QStringList> &variables();
 
+    bool isRecursive() const { return recursive; }
+
 protected:
     friend class MakefileGenerator;
     bool read(const QString &file, QMap<QString, QStringList> &place);
@@ -192,10 +196,6 @@ inline QString QMakeProject::first(const QString &v)
 inline QMap<QString, QStringList> &QMakeProject::variables()
 { return vars; }
 
-// Helper functions needed for Symbian
-bool isForSymbian();
-bool isForSymbianSbsv2();
-
 QT_END_NAMESPACE
 
 #endif // PROJECT_H