Automatically determine built-in compiler defines

This provides users with access to the full list of macros defined by
the MSVC, GCC, Clang, or MinGW compiler in use.

Change-Id: I6e7f6841bbc18aed13958724b268283d97b17320
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

2 files changed, 52 insertions, 9 deletions

diff --git a/share/qbs/imports/qbs/Probes/GccProbe.qbs b/share/qbs/imports/qbs/Probes/GccProbe.qbs
index 0ffe10f4d..627f9b468 100644
--- a/share/qbs/imports/qbs/Probes/GccProbe.qbs
+++ b/share/qbs/imports/qbs/Probes/GccProbe.qbs
@@ -35,7 +35,8 @@ import "../../../modules/cpp/gcc.js" as Gcc
 
 PathProbe {
     // Inputs
-    property string compilerFilePath
+    property var compilerFilePathByLanguage
+    property stringList enableDefinesByLanguage
     property stringList flags: []
     property var environment
 
@@ -49,15 +50,40 @@ PathProbe {
     property stringList includePaths
     property stringList libraryPaths
     property stringList frameworkPaths
+    property var compilerDefinesByLanguage
 
     configure: {
-        if (!File.exists(compilerFilePath)) {
-            found = false;
-            return;
+        compilerDefinesByLanguage = {};
+        var languages = enableDefinesByLanguage;
+        if (!languages || languages.length === 0)
+            languages = ["c"];
+        for (var i = 0; i < languages.length; ++i) {
+            var fp = compilerFilePathByLanguage[languages[i]];
+            if (fp && File.exists(fp)) {
+                try {
+                    compilerDefinesByLanguage[languages[i]] = Gcc.dumpMacros(environment, fp,
+                                                                             flags, _nullDevice,
+                                                                             languages[i]);
+                } catch (e) {
+                    // Only throw errors when determining the compiler defines for the C language;
+                    // for other languages we presume it is an indication that the language is not
+                    // installed (as is typically the case for Objective-C/C++ on non-Apple systems)
+                    if (languages[i] === "c")
+                        throw e;
+                }
+            } else if (languages[i] === "c") {
+                found = false;
+                return;
+            }
         }
 
-        var macros = Gcc.dumpMacros(environment, compilerFilePath, flags, _nullDevice);
-        var defaultPaths = Gcc.dumpDefaultPaths(environment, compilerFilePath, flags, _nullDevice,
+        var macros = compilerDefinesByLanguage["c"]
+                  || compilerDefinesByLanguage["cpp"]
+                  || compilerDefinesByLanguage["objc"]
+                  || compilerDefinesByLanguage["objcpp"];
+        var defaultPaths = Gcc.dumpDefaultPaths(environment, compilerFilePathByLanguage["cpp"] ||
+                                                compilerFilePathByLanguage["c"],
+                                                flags, _nullDevice,
                                                 _pathListSeparator, _sysroot);
         found = !!macros && !!defaultPaths;
 
diff --git a/share/qbs/imports/qbs/Probes/MsvcProbe.qbs b/share/qbs/imports/qbs/Probes/MsvcProbe.qbs
index d62a9e1ea..1ee2b8159 100644
--- a/share/qbs/imports/qbs/Probes/MsvcProbe.qbs
+++ b/share/qbs/imports/qbs/Probes/MsvcProbe.qbs
@@ -37,6 +37,7 @@ import qbs.Utilities
 PathProbe {
     // Inputs
     property string compilerFilePath
+    property stringList enableDefinesByLanguage
     property string preferredArchitecture
 
     // Outputs
@@ -46,12 +47,28 @@ PathProbe {
     property int versionPatch
     property stringList includePaths
     property var buildEnv
+    property var compilerDefinesByLanguage
 
     configure: {
-        var info = Utilities.msvcCompilerInfo(compilerFilePath);
-        found = !!info && !!info.macros && !!info.buildEnvironment;
+        var languages = enableDefinesByLanguage;
+        if (!languages || languages.length === 0)
+            languages = ["c"];
 
-        var macros = info.macros;
+        var info = languages.contains("c")
+                ? Utilities.msvcCompilerInfo(compilerFilePath, "c") : {};
+        var infoCpp = languages.contains("cpp")
+                ? Utilities.msvcCompilerInfo(compilerFilePath, "cpp") : {};
+        found = (!languages.contains("c") ||
+                 (!!info && !!info.macros && !!info.buildEnvironment))
+             && (!languages.contains("cpp") ||
+                 (!!infoCpp && !!infoCpp.macros && !!infoCpp.buildEnvironment));
+
+        compilerDefinesByLanguage = {
+            "c": info.macros,
+            "cpp": infoCpp.macros,
+        };
+
+        var macros = info.macros || infoCpp.macros;
         architecture = ModUtils.guessArchitecture(macros);
 
         var ver = macros["_MSC_FULL_VER"];