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>

9 files changed, 69 insertions, 28 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"];
diff --git a/share/qbs/modules/cpp/CppModule.qbs b/share/qbs/modules/cpp/CppModule.qbs
index c681e8175..1517c3b32 100644
--- a/share/qbs/modules/cpp/CppModule.qbs
+++ b/share/qbs/modules/cpp/CppModule.qbs
@@ -62,11 +62,15 @@ Module {
 
     property stringList defines
     property stringList platformDefines: qbs.enableDebugCode ? [] : ["NDEBUG"]
-    property stringList compilerDefines
+    property stringList compilerDefines: compilerDefinesByLanguage
+                                  ? ModUtils.flattenDictionary(compilerDefinesByLanguage["c"])
+                                  : []
+    property var compilerDefinesByLanguage: undefined
     PropertyOptions {
-        name: "compilerDefines"
+        name: "compilerDefinesByLanguage"
         description: "preprocessor macros that are defined when using this particular compiler"
     }
+    property stringList enableCompilerDefinesByLanguage: []
 
     property string windowsApiCharacterSet
     property string windowsApiFamily
@@ -434,6 +438,7 @@ Module {
         }, "'" + architecture + "' is invalid. You must use the canonical name '" +
         Utilities.canonicalArchitecture(architecture) + "'");
         validator.setRequiredProperty("endianness", endianness);
+        validator.setRequiredProperty("compilerDefinesByLanguage", compilerDefinesByLanguage);
         validator.setRequiredProperty("compilerVersion", compilerVersion);
         validator.setRequiredProperty("compilerVersionMajor", compilerVersionMajor);
         validator.setRequiredProperty("compilerVersionMinor", compilerVersionMinor);
diff --git a/share/qbs/modules/cpp/DarwinGCC.qbs b/share/qbs/modules/cpp/DarwinGCC.qbs
index c1c92e740..317d9d782 100644
--- a/share/qbs/modules/cpp/DarwinGCC.qbs
+++ b/share/qbs/modules/cpp/DarwinGCC.qbs
@@ -69,7 +69,6 @@ UnixGCC {
     targetAbi: "macho"
     imageFormat: "macho"
 
-    compilerDefines: ["__GNUC__=4", "__APPLE__"]
     cxxStandardLibrary: libcxxAvailable ? "libc++" : base
     loadableModulePrefix: ""
     loadableModuleSuffix: ".bundle"
diff --git a/share/qbs/modules/cpp/GenericGCC.qbs b/share/qbs/modules/cpp/GenericGCC.qbs
index b25de28c0..722ac7438 100644
--- a/share/qbs/modules/cpp/GenericGCC.qbs
+++ b/share/qbs/modules/cpp/GenericGCC.qbs
@@ -60,7 +60,8 @@ CppModule {
 
     Probes.GccProbe {
         id: gccProbe
-        compilerFilePath: compilerPath
+        compilerFilePathByLanguage: compilerPathByLanguage
+        enableDefinesByLanguage: enableCompilerDefinesByLanguage
         environment: buildEnv
         flags: targetDriverFlags.concat(sysrootFlags)
         _sysroot: sysroot
@@ -98,6 +99,8 @@ CppModule {
     qbs.architecture: gccProbe.found ? gccProbe.architecture : original
     endianness: gccProbe.endianness
 
+    compilerDefinesByLanguage: gccProbe.compilerDefinesByLanguage
+
     compilerVersionMajor: gccVersionProbe.versionMajor
     compilerVersionMinor: gccVersionProbe.versionMinor
     compilerVersionPatch: gccVersionProbe.versionPatch
diff --git a/share/qbs/modules/cpp/gcc.js b/share/qbs/modules/cpp/gcc.js
index 8214373ab..d86f814e7 100644
--- a/share/qbs/modules/cpp/gcc.js
+++ b/share/qbs/modules/cpp/gcc.js
@@ -1259,7 +1259,7 @@ function isNumericProductVersion(version) {
     return version && version.match(/^([0-9]+\.){0,3}[0-9]+$/);
 }
 
-function dumpMacros(env, compilerFilePath, args, nullDevice) {
+function dumpMacros(env, compilerFilePath, args, nullDevice, tag) {
     var p = new Process();
     try {
         p.setEnv("LC_ALL", "C");
@@ -1267,7 +1267,8 @@ function dumpMacros(env, compilerFilePath, args, nullDevice) {
             p.setEnv(key, env[key]);
         // qcc NEEDS the explicit -Wp, prefix to -dM; clang and gcc do not but all three accept it
         p.exec(compilerFilePath,
-               (args || []).concat(["-Wp,-dM", "-E", "-x", "c", nullDevice]), true);
+               (args || []).concat(["-Wp,-dM", "-E", "-x", languageName(tag || "c") , nullDevice]),
+               true);
         var map = {};
         p.readStdOut().trim().split("\n").map(function (line) {
             var parts = line.split(" ", 3);
diff --git a/share/qbs/modules/cpp/msvc.js b/share/qbs/modules/cpp/msvc.js
index 898a6ed96..8279f591f 100644
--- a/share/qbs/modules/cpp/msvc.js
+++ b/share/qbs/modules/cpp/msvc.js
@@ -34,15 +34,6 @@ var ModUtils = require("qbs.ModUtils");
 var Utilities = require("qbs.Utilities");
 var WindowsUtils = require("qbs.WindowsUtils");
 
-function compilerVersionDefine(cpp) {
-    var result = '_MSC_VER=' + cpp.compilerVersionMajor;
-    var s = cpp.compilerVersionMinor.toString();
-    while (s.length < 2)
-        s = '0' + s;
-    result += s;
-    return result;
-}
-
 function prepareCompiler(project, product, inputs, outputs, input, output, explicitlyDependsOn) {
     var i;
     var debugInformation = input.cpp.debugInformation;
diff --git a/share/qbs/modules/cpp/windows-mingw.qbs b/share/qbs/modules/cpp/windows-mingw.qbs
index d74588c71..1b19bb06b 100644
--- a/share/qbs/modules/cpp/windows-mingw.qbs
+++ b/share/qbs/modules/cpp/windows-mingw.qbs
@@ -47,7 +47,7 @@ GenericGCC {
     imageFormat: "pe"
     windowsApiCharacterSet: "unicode"
     platformDefines: base.concat(WindowsUtils.characterSetDefines(windowsApiCharacterSet))
-    compilerDefines: ['__GNUC__', 'WIN32', '_WIN32']
+                         .concat("WIN32")
 
     property string windresName: 'windres'
     property path windresPath: { return toolchainPathPrefix + windresName }
diff --git a/share/qbs/modules/cpp/windows-msvc.qbs b/share/qbs/modules/cpp/windows-msvc.qbs
index 051678d64..426978055 100644
--- a/share/qbs/modules/cpp/windows-msvc.qbs
+++ b/share/qbs/modules/cpp/windows-msvc.qbs
@@ -43,8 +43,6 @@ CppModule {
                qbs.targetOS.contains('windows') &&
                qbs.toolchain && qbs.toolchain.contains('msvc')
 
-    id: module
-
     Probes.BinaryProbe {
         id: compilerPathProbe
         condition: !toolchainInstallPath
@@ -54,6 +52,7 @@ CppModule {
     Probes.MsvcProbe {
         id: msvcProbe
         compilerFilePath: compilerPath
+        enableDefinesByLanguage: enableCompilerDefinesByLanguage
         preferredArchitecture: qbs.architecture
     }
 
@@ -82,7 +81,7 @@ CppModule {
             flags.push("/FS");
         return flags;
     }
-    compilerDefines: ['_WIN32', MSVC.compilerVersionDefine(module)]
+    compilerDefinesByLanguage: msvcProbe.compilerDefinesByLanguage
     warningLevel: "default"
     compilerName: "cl.exe"
     compilerPath: FileInfo.joinPaths(toolchainInstallPath, compilerName)