11 files changed, 437 insertions, 116 deletions

diff --git a/qmake/library/ioutils.cpp b/qmake/library/ioutils.cpp
index 3c2801594a..cc19aa5c42 100644
--- a/qmake/library/ioutils.cpp
+++ b/qmake/library/ioutils.cpp
@@ -88,6 +88,11 @@ bool IoUtils::isRelativePath(const QString &path)
     return true;
 }
 
+QStringRef IoUtils::pathName(const QString &fileName)
+{
+    return fileName.leftRef(fileName.lastIndexOf(QLatin1Char('/')) + 1);
+}
+
 QStringRef IoUtils::fileName(const QString &fileName)
 {
     return fileName.midRef(fileName.lastIndexOf(QLatin1Char('/')) + 1);
diff --git a/qmake/library/ioutils.h b/qmake/library/ioutils.h
index 160e879fce..d69725fa27 100644
--- a/qmake/library/ioutils.h
+++ b/qmake/library/ioutils.h
@@ -64,6 +64,7 @@ public:
     static bool exists(const QString &fileName) { return fileType(fileName) != FileNotFound; }
     static bool isRelativePath(const QString &fileName);
     static bool isAbsolutePath(const QString &fileName) { return !isRelativePath(fileName); }
+    static QStringRef pathName(const QString &fileName); // Requires normalized path
     static QStringRef fileName(const QString &fileName); // Requires normalized path
     static QString resolvePath(const QString &baseDir, const QString &fileName);
     static QString shellQuoteUnix(const QString &arg);
diff --git a/qmake/library/qmake_global.h b/qmake/library/qmake_global.h
index 7e2247e8c6..acb95e7ab3 100644
--- a/qmake/library/qmake_global.h
+++ b/qmake/library/qmake_global.h
@@ -64,4 +64,8 @@
 # define ALWAYS_INLINE inline
 #endif
 
+#ifdef PROEVALUATOR_FULL
+#  define PROEVALUATOR_DEBUG
+#endif
+
 #endif
diff --git a/qmake/library/qmakebuiltins.cpp b/qmake/library/qmakebuiltins.cpp
index be0d8ea172..c0f1724563 100644
--- a/qmake/library/qmakebuiltins.cpp
+++ b/qmake/library/qmakebuiltins.cpp
@@ -44,6 +44,7 @@
 #include "qmakeevaluator_p.h"
 #include "qmakeglobals.h"
 #include "qmakeparser.h"
+#include "qmakevfs.h"
 #include "ioutils.h"
 
 #include <qbytearray.h>
@@ -281,46 +282,17 @@ quoteValue(const ProString &val)
     return ret;
 }
 
-static bool
-doWriteFile(const QString &name, QIODevice::OpenMode mode, const QString &contents, QString *errStr)
-{
-    QByteArray bytes = contents.toLocal8Bit();
-    QFile cfile(name);
-    if (!(mode & QIODevice::Append) && cfile.open(QIODevice::ReadOnly | QIODevice::Text)) {
-        if (cfile.readAll() == bytes)
-            return true;
-        cfile.close();
-    }
-    if (!cfile.open(mode | QIODevice::WriteOnly | QIODevice::Text)) {
-        *errStr = cfile.errorString();
-        return false;
-    }
-    cfile.write(bytes);
-    cfile.close();
-    if (cfile.error() != QFile::NoError) {
-        *errStr = cfile.errorString();
-        return false;
-    }
-    return true;
-}
-
 QMakeEvaluator::VisitReturn
 QMakeEvaluator::writeFile(const QString &ctx, const QString &fn, QIODevice::OpenMode mode,
                           const QString &contents)
 {
-    QFileInfo qfi(fn);
-    if (!QDir::current().mkpath(qfi.path())) {
-        evalError(fL1S("Cannot create %1directory %2.")
-                  .arg(ctx, QDir::toNativeSeparators(qfi.path())));
-        return ReturnFalse;
-    }
     QString errStr;
-    if (!doWriteFile(qfi.filePath(), mode, contents, &errStr)) {
+    if (!m_vfs->writeFile(fn, mode, contents, &errStr)) {
         evalError(fL1S("Cannot write %1file %2: %3.")
-                  .arg(ctx, QDir::toNativeSeparators(qfi.filePath()), errStr));
+                  .arg(ctx, QDir::toNativeSeparators(fn), errStr));
         return ReturnFalse;
     }
-    m_parser->discardFileFromCache(qfi.filePath());
+    m_parser->discardFileFromCache(fn);
     return ReturnTrue;
 }
 
@@ -1118,11 +1090,11 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
             }
         }
         return ReturnFalse;
-#ifdef PROEVALUATOR_FULL
     case T_REQUIRES:
+#ifdef PROEVALUATOR_FULL
         checkRequirements(args);
-        return ReturnFalse; // Another qmake breakage
 #endif
+        return ReturnFalse; // Another qmake breakage
     case T_EVAL: {
             VisitReturn ret = ReturnFalse;
             ProFile *pro = m_parser->parsedProBlock(args.join(statics.field_sep),
@@ -1389,14 +1361,14 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
         }
         return (func_t == T_ERROR && !m_cumulative) ? ReturnError : ReturnTrue;
     }
-#ifdef PROEVALUATOR_FULL
     case T_SYSTEM: {
-        if (m_cumulative) // Anything else would be insanity
-            return ReturnFalse;
         if (args.count() != 1) {
             evalError(fL1S("system(exec) requires one argument."));
             return ReturnFalse;
         }
+#ifdef PROEVALUATOR_FULL
+        if (m_cumulative) // Anything else would be insanity
+            return ReturnFalse;
 #ifndef QT_BOOTSTRAPPED
         QProcess proc;
         proc.setProcessChannelMode(QProcess::ForwardedChannels);
@@ -1407,8 +1379,10 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
                                   + IoUtils::shellQuote(QDir::toNativeSeparators(currentDirectory()))
                                   + QLatin1String(" && ") + args.at(0)).toLocal8Bit().constData()) == 0);
 #endif
-    }
+#else
+        return ReturnTrue;
 #endif
+    }
     case T_ISEMPTY: {
         if (args.count() != 1) {
             evalError(fL1S("isEmpty(var) requires one argument."));
@@ -1423,6 +1397,9 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
         }
         const QString &file = resolvePath(m_option->expandEnvVars(args.at(0).toQString(m_tmp1)));
 
+        // Don't use VFS here:
+        // - it supports neither listing nor even directories
+        // - it's unlikely that somebody would test for files they created themselves
         if (IoUtils::exists(file))
             return ReturnTrue;
         int slsh = file.lastIndexOf(QLatin1Char('/'));
@@ -1435,17 +1412,18 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
 
         return ReturnFalse;
     }
-#ifdef PROEVALUATOR_FULL
     case T_MKPATH: {
         if (args.count() != 1) {
             evalError(fL1S("mkpath(file) requires one argument."));
             return ReturnFalse;
         }
+#ifdef PROEVALUATOR_FULL
         const QString &fn = resolvePath(args.at(0).toQString(m_tmp1));
         if (!QDir::current().mkpath(fn)) {
             evalError(fL1S("Cannot create directory %1.").arg(QDir::toNativeSeparators(fn)));
             return ReturnFalse;
         }
+#endif
         return ReturnTrue;
     }
     case T_WRITE_FILE: {
@@ -1470,6 +1448,7 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
             evalError(fL1S("touch(file, reffile) requires two arguments."));
             return ReturnFalse;
         }
+#ifdef PROEVALUATOR_FULL
         const QString &tfn = resolvePath(args.at(0).toQString(m_tmp1));
         const QString &rfn = resolvePath(args.at(1).toQString(m_tmp2));
 #ifdef Q_OS_UNIX
@@ -1506,6 +1485,7 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
         SetFileTime(wHand, 0, 0, &ft);
         CloseHandle(wHand);
 #endif
+#endif
         return ReturnTrue;
     }
     case T_CACHE: {
@@ -1639,7 +1619,6 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
         }
         return writeFile(fL1S("cache "), fn, QIODevice::Append, varstr);
     }
-#endif
     default:
         evalError(fL1S("Function '%1' is not implemented.").arg(function.toQString(m_tmp1)));
         return ReturnFalse;
diff --git a/qmake/library/qmakeevaluator.cpp b/qmake/library/qmakeevaluator.cpp
index 09ea231684..7c20bb8492 100644
--- a/qmake/library/qmakeevaluator.cpp
+++ b/qmake/library/qmakeevaluator.cpp
@@ -44,6 +44,7 @@
 
 #include "qmakeglobals.h"
 #include "qmakeparser.h"
+#include "qmakevfs.h"
 #include "ioutils.h"
 
 #include <qbytearray.h>
@@ -174,13 +175,13 @@ const ProKey &QMakeEvaluator::map(const ProKey &var)
 }
 
 
-QMakeEvaluator::QMakeEvaluator(QMakeGlobals *option,
-                               QMakeParser *parser, QMakeHandler *handler)
+QMakeEvaluator::QMakeEvaluator(QMakeGlobals *option, QMakeParser *parser, QMakeVfs *vfs,
+                               QMakeHandler *handler)
   :
 #ifdef PROEVALUATOR_DEBUG
     m_debugLevel(option->debugLevel),
 #endif
-    m_option(option), m_parser(parser), m_handler(handler)
+    m_option(option), m_parser(parser), m_handler(handler), m_vfs(vfs)
 {
     // So that single-threaded apps don't have to call initialize() for now.
     initStatics();
@@ -936,7 +937,7 @@ void QMakeEvaluator::visitProVariable(
     if (varName == statics.strTEMPLATE)
         setTemplate();
     else if (varName == statics.strQMAKE_PLATFORM)
-        updateFeaturePaths();
+        m_featureRoots = 0;
 #ifdef PROEVALUATOR_FULL
     else if (varName == statics.strREQUIRES)
         checkRequirements(values(varName));
@@ -1064,7 +1065,7 @@ bool QMakeEvaluator::prepareProject(const QString &inDir)
             superdir = m_outputDir;
             forever {
                 QString superfile = superdir + QLatin1String("/.qmake.super");
-                if (IoUtils::exists(superfile)) {
+                if (m_vfs->exists(superfile)) {
                     m_superfile = QDir::cleanPath(superfile);
                     break;
                 }
@@ -1079,10 +1080,10 @@ bool QMakeEvaluator::prepareProject(const QString &inDir)
             QString dir = m_outputDir;
             forever {
                 conffile = sdir + QLatin1String("/.qmake.conf");
-                if (!IoUtils::exists(conffile))
+                if (!m_vfs->exists(conffile))
                     conffile.clear();
                 cachefile = dir + QLatin1String("/.qmake.cache");
-                if (!IoUtils::exists(cachefile))
+                if (!m_vfs->exists(cachefile))
                     cachefile.clear();
                 if (!conffile.isEmpty() || !cachefile.isEmpty()) {
                     if (dir != sdir)
@@ -1160,6 +1161,7 @@ bool QMakeEvaluator::loadSpecInternal()
 #endif
     valuesRef(ProKey("QMAKESPEC")) << ProString(m_qmakespec);
     m_qmakespecName = IoUtils::fileName(m_qmakespec).toString();
+    // This also ensures that m_featureRoots is valid.
     if (evaluateFeatureFile(QLatin1String("spec_post.prf")) != ReturnTrue)
         return false;
     // The MinGW and x-build specs may change the separator; $$shell_{path,quote}() need it
@@ -1173,7 +1175,9 @@ bool QMakeEvaluator::loadSpec()
                 m_hostBuild ? m_option->qmakespec : m_option->xqmakespec);
 
     {
-        QMakeEvaluator evaluator(m_option, m_parser, m_handler);
+        QMakeEvaluator evaluator(m_option, m_parser, m_vfs, m_handler);
+        evaluator.m_sourceRoot = m_sourceRoot;
+        evaluator.m_buildRoot = m_buildRoot;
         if (!m_superfile.isEmpty()) {
             valuesRef(ProKey("_QMAKE_SUPER_CACHE_")) << ProString(m_superfile);
             if (evaluator.evaluateFile(
@@ -1330,7 +1334,7 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::visitProFile(
                 locker.unlock();
 #endif
 
-                QMakeEvaluator *baseEval = new QMakeEvaluator(m_option, m_parser, m_handler);
+                QMakeEvaluator *baseEval = new QMakeEvaluator(m_option, m_parser, m_vfs, m_handler);
                 baseEnv->evaluator = baseEval;
                 baseEval->m_superfile = m_superfile;
                 baseEval->m_conffile = m_conffile;
@@ -1429,6 +1433,7 @@ void QMakeEvaluator::updateMkspecPaths()
         ret << m_sourceRoot + concat;
 
     ret << m_option->propertyValue(ProKey("QT_HOST_DATA/get")) + concat;
+    ret << m_option->propertyValue(ProKey("QT_HOST_DATA/src")) + concat;
 
     ret.removeDuplicates();
     m_mkspecPaths = ret;
@@ -1450,10 +1455,14 @@ void QMakeEvaluator::updateFeaturePaths()
             m_option->dirlist_sep, QString::SkipEmptyParts);
 
     QStringList feature_bases;
-    if (!m_buildRoot.isEmpty())
+    if (!m_buildRoot.isEmpty()) {
+        feature_bases << m_buildRoot + mkspecs_concat;
         feature_bases << m_buildRoot;
-    if (!m_sourceRoot.isEmpty())
+    }
+    if (!m_sourceRoot.isEmpty()) {
+        feature_bases << m_sourceRoot + mkspecs_concat;
         feature_bases << m_sourceRoot;
+    }
 
     foreach (const QString &item, m_option->getPathListEnv(QLatin1String("QMAKEPATH")))
         feature_bases << (item + mkspecs_concat);
@@ -1477,8 +1486,8 @@ void QMakeEvaluator::updateFeaturePaths()
         }
     }
 
-    feature_bases << (m_option->propertyValue(ProKey("QT_HOST_DATA/get")).toQString(m_mtmp)
-                      + mkspecs_concat);
+    feature_bases << (m_option->propertyValue(ProKey("QT_HOST_DATA/get")) + mkspecs_concat);
+    feature_bases << (m_option->propertyValue(ProKey("QT_HOST_DATA/src")) + mkspecs_concat);
 
     foreach (const QString &fb, feature_bases) {
         foreach (const ProString &sfx, values(ProKey("QMAKE_PLATFORM")))
@@ -1496,7 +1505,7 @@ void QMakeEvaluator::updateFeaturePaths()
     foreach (const QString &root, feature_roots)
         if (IoUtils::exists(root))
             ret << root;
-    m_featureRoots = ret;
+    m_featureRoots = new QMakeFeatureRoots(ret);
 }
 
 ProString QMakeEvaluator::propertyValue(const ProKey &name) const
@@ -1825,7 +1834,7 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFile(
 #endif
         return ok;
     } else {
-        if (!(flags & LoadSilent) && !IoUtils::exists(fileName))
+        if (!(flags & LoadSilent) && !m_vfs->exists(fileName))
             evalError(fL1S("WARNING: Include file %1 not found").arg(fileName));
         return ReturnFalse;
     }
@@ -1854,34 +1863,55 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFeatureFile(
     if (!fn.endsWith(QLatin1String(".prf")))
         fn += QLatin1String(".prf");
 
-    if (m_featureRoots.isEmpty())
+    if (!m_featureRoots)
         updateFeaturePaths();
-    int start_root = 0;
+#ifdef PROEVALUATOR_THREAD_SAFE
+    m_featureRoots->mutex.lock();
+#endif
     QString currFn = currentFileName();
-    if (IoUtils::fileName(currFn) == IoUtils::fileName(fn)) {
-        for (int root = 0; root < m_featureRoots.size(); ++root)
-            if (currFn == m_featureRoots.at(root) + fn) {
-                start_root = root + 1;
-                break;
+    if (IoUtils::fileName(currFn) != IoUtils::fileName(fn))
+        currFn.clear();
+    // Null values cannot regularly exist in the hash, so they indicate that the value still
+    // needs to be determined. Failed lookups are represented via non-null empty strings.
+    QString *fnp = &m_featureRoots->cache[qMakePair(fn, currFn)];
+    if (fnp->isNull()) {
+        int start_root = 0;
+        const QStringList &paths = m_featureRoots->paths;
+        if (!currFn.isEmpty()) {
+            QStringRef currPath = IoUtils::pathName(currFn);
+            for (int root = 0; root < paths.size(); ++root)
+                if (currPath == paths.at(root)) {
+                    start_root = root + 1;
+                    break;
+                }
+        }
+        for (int root = start_root; root < paths.size(); ++root) {
+            QString fname = paths.at(root) + fn;
+            if (IoUtils::exists(fname)) {
+                fn = fname;
+                goto cool;
             }
-    }
-    for (int root = start_root; root < m_featureRoots.size(); ++root) {
-        QString fname = m_featureRoots.at(root) + fn;
-        if (IoUtils::exists(fname)) {
-            fn = fname;
-            goto cool;
         }
-    }
 #ifdef QMAKE_BUILTIN_PRFS
-    fn.prepend(QLatin1String(":/qmake/features/"));
-    if (QFileInfo(fn).exists())
-        goto cool;
+        fn.prepend(QLatin1String(":/qmake/features/"));
+        if (QFileInfo(fn).exists())
+            goto cool;
 #endif
-    if (!silent)
-        evalError(fL1S("Cannot find feature %1").arg(fileName));
-    return ReturnFalse;
+        fn = QLatin1String(""); // Indicate failed lookup. See comment above.
 
-  cool:
+      cool:
+        *fnp = fn;
+    } else {
+        fn = *fnp;
+    }
+#ifdef PROEVALUATOR_THREAD_SAFE
+    m_featureRoots->mutex.unlock();
+#endif
+    if (fn.isEmpty()) {
+        if (!silent)
+            evalError(fL1S("Cannot find feature %1").arg(fileName));
+        return ReturnFalse;
+    }
     ProStringList &already = valuesRef(ProKey("QMAKE_INTERNAL_INCLUDED_FEATURES"));
     ProString afn(fn);
     if (already.contains(afn)) {
@@ -1908,7 +1938,7 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFeatureFile(
 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFileInto(
         const QString &fileName, ProValueMap *values, LoadFlags flags)
 {
-    QMakeEvaluator visitor(m_option, m_parser, m_handler);
+    QMakeEvaluator visitor(m_option, m_parser, m_vfs, m_handler);
     visitor.m_caller = this;
     visitor.m_outputDir = m_outputDir;
     visitor.m_featureRoots = m_featureRoots;
diff --git a/qmake/library/qmakeevaluator.h b/qmake/library/qmakeevaluator.h
index 09617ba019..8ca2b182c7 100644
--- a/qmake/library/qmakeevaluator.h
+++ b/qmake/library/qmakeevaluator.h
@@ -55,9 +55,13 @@
 #include <qstack.h>
 #include <qstring.h>
 #include <qstringlist.h>
+#include <qshareddata.h>
 #ifndef QT_BOOTSTRAPPED
 # include <qprocess.h>
 #endif
+#ifdef PROEVALUATOR_THREAD_SAFE
+# include <qmutex.h>
+#endif
 
 QT_BEGIN_NAMESPACE
 
@@ -83,6 +87,20 @@ public:
     virtual void doneWithEval(ProFile *parent) = 0;
 };
 
+typedef QPair<QString, QString> QMakeFeatureKey; // key, parent
+typedef QHash<QMakeFeatureKey, QString> QMakeFeatureHash;
+
+class QMAKE_EXPORT QMakeFeatureRoots : public QSharedData
+{
+public:
+    QMakeFeatureRoots(const QStringList &_paths) : paths(_paths) {}
+    const QStringList paths;
+    mutable QMakeFeatureHash cache;
+#ifdef PROEVALUATOR_THREAD_SAFE
+    mutable QMutex mutex;
+#endif
+};
+
 // We use a QLinkedList based stack instead of a QVector based one (QStack), so that
 // the addresses of value maps stay constant. The qmake generators rely on that.
 class QMAKE_EXPORT ProValueMapStack : public QLinkedList<ProValueMap>
@@ -109,7 +127,7 @@ public:
 
     static void initStatics();
     static void initFunctionStatics();
-    QMakeEvaluator(QMakeGlobals *option, QMakeParser *parser,
+    QMakeEvaluator(QMakeGlobals *option, QMakeParser *parser, QMakeVfs *vfs,
                    QMakeHandler *handler);
     ~QMakeEvaluator();
 
@@ -284,7 +302,7 @@ public:
     QStringList m_qmakepath;
     QStringList m_qmakefeatures;
     QStringList m_mkspecPaths;
-    QStringList m_featureRoots;
+    QExplicitlySharedDataPointer<QMakeFeatureRoots> m_featureRoots;
     ProString m_dirSep;
     ProFunctionDefs m_functionDefs;
     ProStringList m_returnValue;
@@ -295,6 +313,7 @@ public:
     QMakeGlobals *m_option;
     QMakeParser *m_parser;
     QMakeHandler *m_handler;
+    QMakeVfs *m_vfs;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QMakeEvaluator::LoadFlags)
diff --git a/qmake/library/qmakeglobals.cpp b/qmake/library/qmakeglobals.cpp
index 3570aa70b7..bf37d51c40 100644
--- a/qmake/library/qmakeglobals.cpp
+++ b/qmake/library/qmakeglobals.cpp
@@ -324,34 +324,46 @@ bool QMakeGlobals::initProperties()
         QT_PCLOSE(proc);
     }
 #endif
-    foreach (QByteArray line, data.split('\n'))
-        if (!line.startsWith("QMAKE_")) {
-            int off = line.indexOf(':');
-            if (off < 0) // huh?
-                continue;
-            if (line.endsWith('\r'))
-                line.chop(1);
-            QString name = QString::fromLatin1(line.left(off));
-            ProString value = ProString(QDir::fromNativeSeparators(
-                        QString::fromLocal8Bit(line.mid(off + 1))));
-            properties.insert(ProKey(name), value);
-            if (name.startsWith(QLatin1String("QT_")) && !name.contains(QLatin1Char('/'))) {
-                if (name.startsWith(QLatin1String("QT_INSTALL_"))) {
+    foreach (QByteArray line, data.split('\n')) {
+        int off = line.indexOf(':');
+        if (off < 0) // huh?
+            continue;
+        if (line.endsWith('\r'))
+            line.chop(1);
+        QString name = QString::fromLatin1(line.left(off));
+        ProString value = ProString(QDir::fromNativeSeparators(
+                    QString::fromLocal8Bit(line.mid(off + 1))));
+        properties.insert(ProKey(name), value);
+        if (name.startsWith(QLatin1String("QT_"))) {
+            bool plain = !name.contains(QLatin1Char('/'));
+            if (!plain) {
+                if (!name.endsWith(QLatin1String("/get")))
+                    continue;
+                name.chop(4);
+            }
+            if (name.startsWith(QLatin1String("QT_INSTALL_"))) {
+                if (plain) {
                     properties.insert(ProKey(name + QLatin1String("/raw")), value);
                     properties.insert(ProKey(name + QLatin1String("/get")), value);
-                    if (name == QLatin1String("QT_INSTALL_PREFIX")
-                        || name == QLatin1String("QT_INSTALL_DATA")
-                        || name == QLatin1String("QT_INSTALL_BINS")) {
-                        name.replace(3, 7, QLatin1String("HOST"));
+                }
+                properties.insert(ProKey(name + QLatin1String("/src")), value);
+                if (name == QLatin1String("QT_INSTALL_PREFIX")
+                    || name == QLatin1String("QT_INSTALL_DATA")
+                    || name == QLatin1String("QT_INSTALL_BINS")) {
+                    name.replace(3, 7, QLatin1String("HOST"));
+                    if (plain) {
                         properties.insert(ProKey(name), value);
                         properties.insert(ProKey(name + QLatin1String("/get")), value);
                     }
-                } else if (name.startsWith(QLatin1String("QT_HOST_"))) {
-                    properties.insert(ProKey(name + QLatin1String("/get")), value);
+                    properties.insert(ProKey(name + QLatin1String("/src")), value);
                 }
+            } else if (name.startsWith(QLatin1String("QT_HOST_"))) {
+                if (plain)
+                    properties.insert(ProKey(name + QLatin1String("/get")), value);
+                properties.insert(ProKey(name + QLatin1String("/src")), value);
             }
         }
-    properties.insert(ProKey("QMAKE_VERSION"), ProString("2.01a"));
+    }
     return true;
 }
 #else
diff --git a/qmake/library/qmakeparser.cpp b/qmake/library/qmakeparser.cpp
index 49b5429130..35533864eb 100644
--- a/qmake/library/qmakeparser.cpp
+++ b/qmake/library/qmakeparser.cpp
@@ -41,6 +41,7 @@
 
 #include "qmakeparser.h"
 
+#include "qmakevfs.h"
 #include "ioutils.h"
 using namespace QMakeInternal;
 
@@ -142,9 +143,10 @@ void QMakeParser::initialize()
     statics.strLITERAL_WHITESPACE = QLatin1String("LITERAL_WHITESPACE");
 }
 
-QMakeParser::QMakeParser(ProFileCache *cache, QMakeParserHandler *handler)
+QMakeParser::QMakeParser(ProFileCache *cache, QMakeVfs *vfs, QMakeParserHandler *handler)
     : m_cache(cache)
     , m_handler(handler)
+    , m_vfs(vfs)
 {
     // So that single-threaded apps don't have to call initialize() for now.
     initialize();
@@ -230,24 +232,14 @@ void QMakeParser::discardFileFromCache(const QString &fileName)
 
 bool QMakeParser::read(ProFile *pro)
 {
-    QFile file(pro->fileName());
-    if (!file.open(QIODevice::ReadOnly)) {
-        if (m_handler && IoUtils::exists(pro->fileName()))
+    QString content;
+    QString errStr;
+    if (!m_vfs->readFile(pro->fileName(), &content, &errStr)) {
+        if (m_handler && m_vfs->exists(pro->fileName()))
             m_handler->message(QMakeParserHandler::ParserIoError,
-                               fL1S("Cannot read %1: %2").arg(pro->fileName(), file.errorString()));
+                               fL1S("Cannot read %1: %2").arg(pro->fileName(), errStr));
         return false;
     }
-
-    QByteArray bcont = file.readAll();
-    if (bcont.startsWith("\xef\xbb\xbf")) {
-        // UTF-8 BOM will cause subtle errors
-        m_handler->message(QMakeParserHandler::ParserIoError,
-                           fL1S("Unexpected UTF-8 BOM in %1").arg(pro->fileName()));
-        return false;
-    }
-    QString content(QString::fromLocal8Bit(bcont));
-    bcont.clear();
-    file.close();
     return read(pro, content, 1, FullGrammar);
 }
 
diff --git a/qmake/library/qmakeparser.h b/qmake/library/qmakeparser.h
index 732e6a05e6..e3da05cc9e 100644
--- a/qmake/library/qmakeparser.h
+++ b/qmake/library/qmakeparser.h
@@ -79,6 +79,7 @@ public:
 };
 
 class ProFileCache;
+class QMakeVfs;
 
 class QMAKE_EXPORT QMakeParser
 {
@@ -86,7 +87,7 @@ public:
     // Call this from a concurrency-free context
     static void initialize();
 
-    QMakeParser(ProFileCache *cache, QMakeParserHandler *handler);
+    QMakeParser(ProFileCache *cache, QMakeVfs *vfs, QMakeParserHandler *handler);
 
     enum SubGrammar { FullGrammar, TestGrammar, ValueGrammar };
     // fileName is expected to be absolute and cleanPath()ed.
@@ -175,6 +176,7 @@ private:
 
     ProFileCache *m_cache;
     QMakeParserHandler *m_handler;
+    QMakeVfs *m_vfs;
 
     // This doesn't help gcc 3.3 ...
     template<typename T> friend class QTypeInfo;
diff --git a/qmake/library/qmakevfs.cpp b/qmake/library/qmakevfs.cpp
new file mode 100644
index 0000000000..2039387a0f
--- /dev/null
+++ b/qmake/library/qmakevfs.cpp
@@ -0,0 +1,192 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the qmake application of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmakevfs.h"
+
+#include "ioutils.h"
+using namespace QMakeInternal;
+
+#include <qdir.h>
+#include <qfile.h>
+#include <qfileinfo.h>
+
+#define fL1S(s) QString::fromLatin1(s)
+
+QT_BEGIN_NAMESPACE
+
+QMakeVfs::QMakeVfs()
+#ifndef PROEVALUATOR_FULL
+    : m_magicMissing(fL1S("missing"))
+    , m_magicExisting(fL1S("existing"))
+#endif
+{
+}
+
+bool QMakeVfs::writeFile(const QString &fn, QIODevice::OpenMode mode, const QString &contents,
+                         QString *errStr)
+{
+#ifndef PROEVALUATOR_FULL
+# ifdef PROEVALUATOR_THREAD_SAFE
+    QMutexLocker locker(&m_mutex);
+# endif
+    QString *cont = &m_files[fn];
+    if (mode & QIODevice::Append)
+        *cont += contents;
+    else
+        *cont = contents;
+    Q_UNUSED(errStr)
+    return true;
+#else
+    QFileInfo qfi(fn);
+    if (!QDir::current().mkpath(qfi.path())) {
+        *errStr = fL1S("Cannot create parent directory");
+        return false;
+    }
+    QByteArray bytes = contents.toLocal8Bit();
+    QFile cfile(fn);
+    if (!(mode & QIODevice::Append) && cfile.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        if (cfile.readAll() == bytes)
+            return true;
+        cfile.close();
+    }
+    if (!cfile.open(mode | QIODevice::WriteOnly | QIODevice::Text)) {
+        *errStr = cfile.errorString();
+        return false;
+    }
+    cfile.write(bytes);
+    cfile.close();
+    if (cfile.error() != QFile::NoError) {
+        *errStr = cfile.errorString();
+        return false;
+    }
+    return true;
+#endif
+}
+
+bool QMakeVfs::readFile(const QString &fn, QString *contents, QString *errStr)
+{
+#ifndef PROEVALUATOR_FULL
+# ifdef PROEVALUATOR_THREAD_SAFE
+    QMutexLocker locker(&m_mutex);
+# endif
+    QHash<QString, QString>::ConstIterator it = m_files.constFind(fn);
+    if (it != m_files.constEnd()) {
+        if (it->constData() == m_magicMissing.constData()) {
+            *errStr = fL1S("No such file or directory");
+            return false;
+        }
+        if (it->constData() != m_magicExisting.constData()) {
+            *contents = *it;
+            return true;
+        }
+    }
+#endif
+
+    QFile file(fn);
+    if (!file.open(QIODevice::ReadOnly)) {
+#ifndef PROEVALUATOR_FULL
+        if (!IoUtils::exists(fn)) {
+            m_files[fn] = m_magicMissing;
+            *errStr = fL1S("No such file or directory");
+        } else
+#endif
+            *errStr = file.errorString();
+        return false;
+    }
+#ifndef PROEVALUATOR_FULL
+    m_files[fn] = m_magicExisting;
+#endif
+
+    QByteArray bcont = file.readAll();
+    if (bcont.startsWith("\xef\xbb\xbf")) {
+        // UTF-8 BOM will cause subtle errors
+        *errStr = fL1S("Unexpected UTF-8 BOM");
+        return false;
+    }
+    *contents = QString::fromLocal8Bit(bcont);
+    return true;
+}
+
+bool QMakeVfs::exists(const QString &fn)
+{
+#ifndef PROEVALUATOR_FULL
+# ifdef PROEVALUATOR_THREAD_SAFE
+    QMutexLocker locker(&m_mutex);
+# endif
+    QHash<QString, QString>::ConstIterator it = m_files.constFind(fn);
+    if (it != m_files.constEnd())
+        return it->constData() != m_magicMissing.constData();
+#endif
+    bool ex = IoUtils::exists(fn);
+#ifndef PROEVALUATOR_FULL
+    m_files[fn] = ex ? m_magicExisting : m_magicMissing;
+#endif
+    return ex;
+}
+
+#ifndef PROEVALUATOR_FULL
+// This should be called when the sources may have changed (e.g., VCS update).
+void QMakeVfs::invalidateCache()
+{
+# ifdef PROEVALUATOR_THREAD_SAFE
+    QMutexLocker locker(&m_mutex);
+# endif
+    QHash<QString, QString>::Iterator it = m_files.begin(), eit = m_files.end();
+    while (it != eit) {
+        if (it->constData() == m_magicMissing.constData()
+                ||it->constData() == m_magicExisting.constData())
+            it = m_files.erase(it);
+        else
+            ++it;
+    }
+}
+
+// This should be called when generated files may have changed (e.g., actual build).
+void QMakeVfs::invalidateContents()
+{
+# ifdef PROEVALUATOR_THREAD_SAFE
+    QMutexLocker locker(&m_mutex);
+# endif
+    m_files.clear();
+}
+#endif
+
+QT_END_NAMESPACE
diff --git a/qmake/library/qmakevfs.h b/qmake/library/qmakevfs.h
new file mode 100644
index 0000000000..13204ece9d
--- /dev/null
+++ b/qmake/library/qmakevfs.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the qmake application of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMAKEVFS_H
+#define QMAKEVFS_H
+
+#include "qmake_global.h"
+
+# include <qiodevice.h>
+#ifndef PROEVALUATOR_FULL
+# include <qhash.h>
+# include <qstring.h>
+# ifdef PROEVALUATOR_THREAD_SAFE
+#  include <qmutex.h>
+# endif
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QMAKE_EXPORT QMakeVfs
+{
+public:
+    QMakeVfs();
+
+    bool writeFile(const QString &fn, QIODevice::OpenMode mode, const QString &contents, QString *errStr);
+    bool readFile(const QString &fn, QString *contents, QString *errStr);
+    bool exists(const QString &fn);
+
+#ifndef PROEVALUATOR_FULL
+    void invalidateCache();
+    void invalidateContents();
+#endif
+
+private:
+#ifndef PROEVALUATOR_FULL
+# ifdef PROEVALUATOR_THREAD_SAFE
+    QMutex m_mutex;
+# endif
+    QHash<QString, QString> m_files;
+    QString m_magicMissing;
+    QString m_magicExisting;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif // QMAKEVFS_H