make error() abort the qmake run, not just the current file

sync up implementation with qmake.
this doesn't actually have an effect on lupdate, as error() is disarmed
in cumulative mode.

Change-Id: I82fc55680f9ffb227e25acb39c797596225ba89e
Reviewed-by: Daniel Teske <daniel.teske@digia.com>
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
(cherry picked from qtbase/0da7f097249f71726140a38647bb4824b09fad7b)
Reviewed-by: hjk <hjk121@nokiamail.com>

diff --git a/src/linguist/shared/qmakebuiltins.cpp b/src/linguist/shared/qmakebuiltins.cpp
index 0b36a16..37ab82f 100644 (file)
--- a/src/linguist/shared/qmakebuiltins.cpp
+++ b/src/linguist/shared/qmakebuiltins.cpp
@@ -688,7 +688,7 @@ ProStringList QMakeEvaluator::evaluateBuiltinExpand(
             ProValueMap vars;
             QString fn = resolvePath(m_option->expandEnvVars(args.at(0).toQString(m_tmp1)));
             fn.detach();
-            if (evaluateFileInto(fn, &vars, LoadProOnly))
+            if (evaluateFileInto(fn, &vars, LoadProOnly) == ReturnTrue)
                 ret = vars.value(map(args.at(1)));
         }
         break;
@@ -1098,8 +1098,9 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
             ProValueMap vars;
             QString fn = resolvePath(m_option->expandEnvVars(args.at(0).toQString(m_tmp1)));
             fn.detach();
-            if (!evaluateFileInto(fn, &vars, LoadProOnly))
-                return ReturnFalse;
+            VisitReturn ok = evaluateFileInto(fn, &vars, LoadProOnly);
+            if (ok != ReturnTrue)
+                return ok;
             if (args.count() == 2)
                 return returnBool(vars.contains(map(args.at(1))));
             QRegExp regx;
@@ -1308,12 +1309,12 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
         }
         QString fn = resolvePath(m_option->expandEnvVars(args.at(0).toQString(m_tmp1)));
         fn.detach();
-        bool ok;
+        VisitReturn ok;
         if (parseInto.isEmpty()) {
             ok = evaluateFileChecked(fn, QMakeHandler::EvalIncludeFile, LoadProOnly | flags);
         } else {
             ProValueMap symbols;
-            if ((ok = evaluateFileInto(fn, &symbols, LoadAll | flags))) {
+            if ((ok = evaluateFileInto(fn, &symbols, LoadAll | flags)) == ReturnTrue) {
                 ProValueMap newMap;
                 for (ProValueMap::ConstIterator
                         it = m_valuemapStack.top().constBegin(),
@@ -1334,7 +1335,9 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
                 m_valuemapStack.top() = newMap;
             }
         }
-        return returnBool(ok || (flags & LoadSilent));
+        if (ok == ReturnFalse && (flags & LoadSilent))
+            ok = ReturnTrue;
+        return ok;
     }
     case T_LOAD: {
         bool ignore_error = false;
@@ -1344,8 +1347,11 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
             evalError(fL1S("load(feature) requires one or two arguments."));
             return ReturnFalse;
         }
-        return returnBool(evaluateFeatureFile(m_option->expandEnvVars(args.at(0).toQString()),
-                                              ignore_error) || ignore_error);
+        VisitReturn ok = evaluateFeatureFile(m_option->expandEnvVars(args.at(0).toQString()),
+                                             ignore_error);
+        if (ok == ReturnFalse && ignore_error)
+            ok = ReturnTrue;
+        return ok;
     }
     case T_DEBUG: {
 #ifdef PROEVALUATOR_DEBUG

diff --git a/src/linguist/shared/qmakeevaluator.cpp b/src/linguist/shared/qmakeevaluator.cpp
index 51d42e4..33befc0 100644 (file)
--- a/src/linguist/shared/qmakeevaluator.cpp
+++ b/src/linguist/shared/qmakeevaluator.cpp
@@ -1130,10 +1130,10 @@ bool QMakeEvaluator::prepareProject(const QString &inDir)
 
 bool QMakeEvaluator::loadSpecInternal()
 {
-    if (!evaluateFeatureFile(QLatin1String("spec_pre.prf")))
+    if (evaluateFeatureFile(QLatin1String("spec_pre.prf")) != ReturnTrue)
         return false;
     QString spec = m_qmakespec + QLatin1String("/qmake.conf");
-    if (!evaluateFile(spec, QMakeHandler::EvalConfigFile, LoadProOnly)) {
+    if (evaluateFile(spec, QMakeHandler::EvalConfigFile, LoadProOnly) != ReturnTrue) {
         evalError(fL1S("Could not read qmake configuration file %1.").arg(spec));
         return false;
     }
@@ -1157,7 +1157,7 @@ bool QMakeEvaluator::loadSpecInternal()
 #endif
     valuesRef(ProKey("QMAKESPEC")) << ProString(m_qmakespec);
     m_qmakespecName = IoUtils::fileName(m_qmakespec).toString();
-    if (!evaluateFeatureFile(QLatin1String("spec_post.prf")))
+    if (evaluateFeatureFile(QLatin1String("spec_post.prf")) != ReturnTrue)
         return false;
     // The MinGW and x-build specs may change the separator; $$shell_{path,quote}() need it
     m_dirSep = first(ProKey("QMAKE_DIR_SEP"));
@@ -1173,17 +1173,20 @@ bool QMakeEvaluator::loadSpec()
         QMakeEvaluator evaluator(m_option, m_parser, m_handler);
         if (!m_superfile.isEmpty()) {
             valuesRef(ProKey("_QMAKE_SUPER_CACHE_")) << ProString(m_superfile);
-            if (!evaluator.evaluateFile(m_superfile, QMakeHandler::EvalConfigFile, LoadProOnly))
+            if (evaluator.evaluateFile(
+                    m_superfile, QMakeHandler::EvalConfigFile, LoadProOnly) != ReturnTrue)
                 return false;
         }
         if (!m_conffile.isEmpty()) {
             valuesRef(ProKey("_QMAKE_CONF_")) << ProString(m_conffile);
-            if (!evaluator.evaluateFile(m_conffile, QMakeHandler::EvalConfigFile, LoadProOnly))
+            if (evaluator.evaluateFile(
+                    m_conffile, QMakeHandler::EvalConfigFile, LoadProOnly) != ReturnTrue)
                 return false;
         }
         if (!m_cachefile.isEmpty()) {
             valuesRef(ProKey("_QMAKE_CACHE_")) << ProString(m_cachefile);
-            if (!evaluator.evaluateFile(m_cachefile, QMakeHandler::EvalConfigFile, LoadProOnly))
+            if (evaluator.evaluateFile(
+                    m_cachefile, QMakeHandler::EvalConfigFile, LoadProOnly) != ReturnTrue)
                 return false;
         }
         if (qmakespec.isEmpty()) {
@@ -1219,17 +1222,17 @@ bool QMakeEvaluator::loadSpec()
     m_qmakespec = QDir::cleanPath(qmakespec);
 
     if (!m_superfile.isEmpty()
-        && !evaluateFile(m_superfile, QMakeHandler::EvalConfigFile, LoadProOnly)) {
+        && evaluateFile(m_superfile, QMakeHandler::EvalConfigFile, LoadProOnly) != ReturnTrue) {
         return false;
     }
     if (!loadSpecInternal())
         return false;
     if (!m_conffile.isEmpty()
-        && !evaluateFile(m_conffile, QMakeHandler::EvalConfigFile, LoadProOnly)) {
+        && evaluateFile(m_conffile, QMakeHandler::EvalConfigFile, LoadProOnly) != ReturnTrue) {
         return false;
     }
     if (!m_cachefile.isEmpty()
-        && !evaluateFile(m_cachefile, QMakeHandler::EvalConfigFile, LoadProOnly)) {
+        && evaluateFile(m_cachefile, QMakeHandler::EvalConfigFile, LoadProOnly) != ReturnTrue) {
         return false;
     }
     return true;
@@ -1260,7 +1263,7 @@ void QMakeEvaluator::evaluateCommand(const QString &cmds, const QString &where)
     }
 }
 
-void QMakeEvaluator::evaluateConfigFeatures()
+QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateConfigFeatures()
 {
     QSet<QString> processed;
     forever {
@@ -1271,7 +1274,10 @@ void QMakeEvaluator::evaluateConfigFeatures()
             if (!processed.contains(config)) {
                 config.detach();
                 processed.insert(config);
-                if (evaluateFeatureFile(config, true)) {
+                VisitReturn vr = evaluateFeatureFile(config, true);
+                if (vr == ReturnError)
+                    return vr;
+                if (vr == ReturnTrue) {
                     finished = false;
                     break;
                 }
@@ -1280,6 +1286,7 @@ void QMakeEvaluator::evaluateConfigFeatures()
         if (finished)
             break;
     }
+    return ReturnTrue;
 }
 
 QMakeEvaluator::VisitReturn QMakeEvaluator::visitProFile(
@@ -1354,13 +1361,16 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::visitProFile(
          it != m_extraVars.constEnd(); ++it)
         m_valuemapStack.first().insert(it.key(), it.value());
 
+    VisitReturn vr;
+
     m_handler->aboutToEval(currentProFile(), pro, type);
     m_profileStack.push(pro);
     valuesRef(ProKey("PWD")) = ProStringList(ProString(currentDirectory()));
     if (flags & LoadPreFiles) {
         setupProject();
 
-        evaluateFeatureFile(QLatin1String("default_pre.prf"));
+        if ((vr = evaluateFeatureFile(QLatin1String("default_pre.prf"))) == ReturnError)
+            goto failed;
 
         evaluateCommand(m_option->precmds, fL1S("(command line)"));
 
@@ -1370,7 +1380,8 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::visitProFile(
     }
 
     debugMsg(1, "visiting file %s", qPrintable(pro->fileName()));
-    visitProBlock(pro, pro->tokPtr());
+    if ((vr = visitProBlock(pro, pro->tokPtr())) == ReturnError)
+        goto failed;
     debugMsg(1, "done visiting file %s", qPrintable(pro->fileName()));
 
     if (flags & LoadPostFiles) {
@@ -1382,15 +1393,19 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::visitProFile(
         if (!m_extraConfigs.isEmpty())
             evaluateCommand(fL1S("CONFIG += ") + m_extraConfigs.join(QLatin1Char(' ')), fL1S("(extra configs)"));
 
-        evaluateFeatureFile(QLatin1String("default_post.prf"));
+        if ((vr = evaluateFeatureFile(QLatin1String("default_post.prf"))) == ReturnError)
+            goto failed;
 
-        evaluateConfigFeatures();
+        if ((vr = evaluateConfigFeatures()) == ReturnError)
+            goto failed;
     }
+    vr = ReturnTrue;
+  failed:
     m_profileStack.pop();
     valuesRef(ProKey("PWD")) = ProStringList(ProString(currentDirectory()));
     m_handler->doneWithEval(currentProFile());
 
-    return ReturnTrue;
+    return vr;
 }
 
 
@@ -1597,14 +1612,14 @@ QList<ProStringList> QMakeEvaluator::prepareFunctionArgs(const ushort *&tokPtr)
 }
 
 ProStringList QMakeEvaluator::evaluateFunction(
-        const ProFunctionDef &func, const QList<ProStringList> &argumentsList, bool *ok)
+        const ProFunctionDef &func, const QList<ProStringList> &argumentsList, VisitReturn *ok)
 {
-    bool oki;
+    VisitReturn vr;
     ProStringList ret;
 
     if (m_valuemapStack.count() >= 100) {
         evalError(fL1S("Ran into infinite recursion (depth > 100)."));
-        oki = false;
+        vr = ReturnFalse;
     } else {
         m_valuemapStack.push(ProValueMap());
         m_locationStack.push(m_current);
@@ -1615,8 +1630,9 @@ ProStringList QMakeEvaluator::evaluateFunction(
             m_valuemapStack.top()[ProKey(QString::number(i+1))] = argumentsList[i];
         }
         m_valuemapStack.top()[statics.strARGS] = args;
-        VisitReturn vr = visitProBlock(func.pro(), func.tokPtr());
-        oki = (vr != ReturnFalse && vr != ReturnError); // True || Return
+        vr = visitProBlock(func.pro(), func.tokPtr());
+        if (vr == ReturnReturn)
+            vr = ReturnTrue;
         ret = m_returnValue;
         m_returnValue.clear();
 
@@ -1624,8 +1640,8 @@ ProStringList QMakeEvaluator::evaluateFunction(
         m_valuemapStack.pop();
     }
     if (ok)
-        *ok = oki;
-    if (oki)
+        *ok = vr;
+    if (vr == ReturnTrue)
         return ret;
     return ProStringList();
 }
@@ -1634,14 +1650,15 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBoolFunction(
         const ProFunctionDef &func, const QList<ProStringList> &argumentsList,
         const ProString &function)
 {
-    bool ok;
-    ProStringList ret = evaluateFunction(func, argumentsList, &ok);
-    if (ok) {
+    VisitReturn vr;
+    ProStringList ret = evaluateFunction(func, argumentsList, &vr);
+    if (vr == ReturnTrue) {
         if (ret.isEmpty())
             return ReturnTrue;
         if (ret.at(0) != statics.strfalse) {
             if (ret.at(0) == statics.strtrue)
                 return ReturnTrue;
+            bool ok;
             int val = ret.at(0).toQString(m_tmp1).toInt(&ok);
             if (ok) {
                 if (val)
@@ -1652,8 +1669,9 @@ QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBoolFunction(
                           .arg(ret.join(QLatin1String(" :: "))));
             }
         }
+        return ReturnFalse;
     }
-    return ReturnFalse;
+    return vr;
 }
 
 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateConditionalFunction(
@@ -1786,16 +1804,16 @@ ProString QMakeEvaluator::first(const ProKey &variableName) const
     return ProString();
 }
 
-bool QMakeEvaluator::evaluateFile(
+QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFile(
         const QString &fileName, QMakeHandler::EvalFileType type, LoadFlags flags)
 {
     if (ProFile *pro = m_parser->parsedProFile(fileName, true)) {
         m_locationStack.push(m_current);
-        bool ok = (visitProFile(pro, type, flags) == ReturnTrue);
+        VisitReturn ok = visitProFile(pro, type, flags);
         m_current = m_locationStack.pop();
         pro->deref();
 #ifdef PROEVALUATOR_FULL
-        if (ok) {
+        if (ok == ReturnTrue) {
             ProStringList &iif = m_valuemapStack.first()[ProKey("QMAKE_INTERNAL_INCLUDED_FILES")];
             ProString ifn(fileName);
             if (!iif.contains(ifn))
@@ -1806,27 +1824,28 @@ bool QMakeEvaluator::evaluateFile(
     } else {
         if (!(flags & LoadSilent) && !IoUtils::exists(fileName))
             evalError(fL1S("WARNING: Include file %1 not found").arg(fileName));
-        return false;
+        return ReturnFalse;
     }
 }
 
-bool QMakeEvaluator::evaluateFileChecked(
+QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFileChecked(
         const QString &fileName, QMakeHandler::EvalFileType type, LoadFlags flags)
 {
     if (fileName.isEmpty())
-        return false;
+        return ReturnFalse;
     QMakeEvaluator *ref = this;
     do {
         foreach (const ProFile *pf, ref->m_profileStack)
             if (pf->fileName() == fileName) {
                 evalError(fL1S("Circular inclusion of %1.").arg(fileName));
-                return false;
+                return ReturnFalse;
             }
     } while ((ref = ref->m_caller));
     return evaluateFile(fileName, type, flags);
 }
 
-bool QMakeEvaluator::evaluateFeatureFile(const QString &fileName, bool silent)
+QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFeatureFile(
+        const QString &fileName, bool silent)
 {
     QString fn = fileName;
     if (!fn.endsWith(QLatin1String(".prf")))
@@ -1857,7 +1876,7 @@ bool QMakeEvaluator::evaluateFeatureFile(const QString &fileName, bool silent)
 #endif
     if (!silent)
         evalError(fL1S("Cannot find feature %1").arg(fileName));
-    return false;
+    return ReturnFalse;
 
   cool:
     ProStringList &already = valuesRef(ProKey("QMAKE_INTERNAL_INCLUDED_FEATURES"));
@@ -1865,7 +1884,7 @@ bool QMakeEvaluator::evaluateFeatureFile(const QString &fileName, bool silent)
     if (already.contains(afn)) {
         if (!silent)
             languageWarning(fL1S("Feature %1 already included").arg(fileName));
-        return true;
+        return ReturnTrue;
     }
     already.append(afn);
 
@@ -1875,7 +1894,7 @@ bool QMakeEvaluator::evaluateFeatureFile(const QString &fileName, bool silent)
 #endif
 
     // The path is fully normalized already.
-    bool ok = evaluateFile(fn, QMakeHandler::EvalFeatureFile, LoadProOnly);
+    VisitReturn ok = evaluateFile(fn, QMakeHandler::EvalFeatureFile, LoadProOnly);
 
 #ifdef PROEVALUATOR_CUMULATIVE
     m_cumulative = cumulative;
@@ -1883,14 +1902,16 @@ bool QMakeEvaluator::evaluateFeatureFile(const QString &fileName, bool silent)
     return ok;
 }
 
-bool QMakeEvaluator::evaluateFileInto(const QString &fileName, ProValueMap *values, LoadFlags flags)
+QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFileInto(
+        const QString &fileName, ProValueMap *values, LoadFlags flags)
 {
     QMakeEvaluator visitor(m_option, m_parser, m_handler);
     visitor.m_caller = this;
     visitor.m_outputDir = m_outputDir;
     visitor.m_featureRoots = m_featureRoots;
-    if (!visitor.evaluateFileChecked(fileName, QMakeHandler::EvalAuxFile, flags))
-        return false;
+    VisitReturn ret = visitor.evaluateFileChecked(fileName, QMakeHandler::EvalAuxFile, flags);
+    if (ret != ReturnTrue)
+        return ret;
     *values = visitor.m_valuemapStack.top();
 #ifdef PROEVALUATOR_FULL
     ProKey qiif("QMAKE_INTERNAL_INCLUDED_FILES");
@@ -1899,7 +1920,7 @@ bool QMakeEvaluator::evaluateFileInto(const QString &fileName, ProValueMap *valu
         if (!iif.contains(ifn))
             iif << ifn;
 #endif
-    return true;
+    return ReturnTrue;
 }
 
 void QMakeEvaluator::message(int type, const QString &msg) const

diff --git a/src/linguist/shared/qmakeevaluator.h b/src/linguist/shared/qmakeevaluator.h
index dee73d1..21f487a 100644 (file)
--- a/src/linguist/shared/qmakeevaluator.h
+++ b/src/linguist/shared/qmakeevaluator.h
@@ -176,15 +176,15 @@ public:
     QString resolvePath(const QString &fileName) const
         { return QMakeInternal::IoUtils::resolvePath(currentDirectory(), fileName); }
 
-    bool evaluateFile(const QString &fileName, QMakeHandler::EvalFileType type,
-                      LoadFlags flags);
-    bool evaluateFileChecked(const QString &fileName, QMakeHandler::EvalFileType type,
+    VisitReturn evaluateFile(const QString &fileName, QMakeHandler::EvalFileType type,
                              LoadFlags flags);
-    bool evaluateFeatureFile(const QString &fileName, bool silent = false);
-    bool evaluateFileInto(const QString &fileName,
-                          ProValueMap *values, // output-only
-                          LoadFlags flags);
-    void evaluateConfigFeatures();
+    VisitReturn evaluateFileChecked(const QString &fileName, QMakeHandler::EvalFileType type,
+                                    LoadFlags flags);
+    VisitReturn evaluateFeatureFile(const QString &fileName, bool silent = false);
+    VisitReturn evaluateFileInto(const QString &fileName,
+                                 ProValueMap *values, // output-only
+                                 LoadFlags flags);
+    VisitReturn evaluateConfigFeatures();
     void message(int type, const QString &msg) const;
     void evalError(const QString &msg) const
             { message(QMakeHandler::EvalError, msg); }
@@ -195,7 +195,7 @@ public:
 
     QList<ProStringList> prepareFunctionArgs(const ushort *&tokPtr);
     ProStringList evaluateFunction(const ProFunctionDef &func,
-                                   const QList<ProStringList> &argumentsList, bool *ok);
+                                   const QList<ProStringList> &argumentsList, VisitReturn *ok);
     VisitReturn evaluateBoolFunction(const ProFunctionDef &func,
                                      const QList<ProStringList> &argumentsList,
                                      const ProString &function);