1 files changed, 96 insertions, 264 deletions

diff --git a/share/qbs/modules/cpp/sdcc.js b/share/qbs/modules/cpp/sdcc.js
index 1904f59fc..b3dfd92b4 100644
--- a/share/qbs/modules/cpp/sdcc.js
+++ b/share/qbs/modules/cpp/sdcc.js
@@ -41,38 +41,24 @@ var TextFile = require("qbs.TextFile");
 var Utilities = require("qbs.Utilities");
 var WindowsUtils = require("qbs.WindowsUtils");
 
-function compilerName(qbs) {
-    return "sdcc";
-}
-
-function assemblerName(qbs) {
-    switch (qbs.architecture) {
-    case "mcs51":
-        return "sdas8051";
-    case "stm8":
-        return "sdasstm8";
-    case "hcs8":
-        return "sdas6808";
-    }
-    throw "Unable to deduce assembler name for unsupported architecture: '"
-            + qbs.architecture + "'";
-}
-
-function linkerName(qbs) {
-    switch (qbs.architecture) {
-    case "mcs51":
-        return "sdld";
-    case "stm8":
-        return "sdldstm8";
-    case "hcs8":
-        return "sdld6808";
+function toolchainDetails(qbs) {
+    var architecture = qbs.architecture;
+    if (architecture === "mcs51") {
+        return {
+            "assemblerName": "sdas8051",
+            "linkerName": "sdld"
+        }
+    } else if (architecture === "stm8") {
+        return {
+            "assemblerName": "sdasstm8",
+            "linkerName": "sdldstm8"
+        }
+    } else if (architecture === "hcs8") {
+        return {
+            "assemblerName": "sdas6808",
+            "linkerName": "sdld6808"
+        }
     }
-    throw "Unable to deduce linker name for unsupported architecture: '"
-            + qbs.architecture + "'";
-}
-
-function archiverName(qbs) {
-    return "sdar";
 }
 
 function targetArchitectureFlag(architecture) {
@@ -126,7 +112,7 @@ function dumpMacros(compilerFilePath, architecture) {
 
     var p = new Process();
     p.exec(compilerFilePath, args, true);
-    return ModUtils.extractMacros(p.readStdOut());
+    return Cpp.extractMacros(p.readStdOut());
 }
 
 function dumpDefaultPaths(compilerFilePath, architecture) {
@@ -184,150 +170,61 @@ function escapePreprocessorFlags(preprocessorFlags) {
     return ["-Wp " + preprocessorFlags.join(",")];
 }
 
-function collectLibraryDependencies(product) {
-    var seen = {};
-    var result = [];
-
-    function addFilePath(filePath) {
-        result.push({ filePath: filePath });
-    }
-
-    function addArtifactFilePaths(dep, artifacts) {
-        if (!artifacts)
-            return;
-        var artifactFilePaths = artifacts.map(function(a) { return a.filePath; });
-        artifactFilePaths.forEach(addFilePath);
-    }
-
-    function addExternalStaticLibs(obj) {
-        if (!obj.cpp)
-            return;
-        function ensureArray(a) {
-            return (a instanceof Array) ? a : [];
-        }
-        function sanitizedModuleListProperty(obj, moduleName, propertyName) {
-            return ensureArray(ModUtils.sanitizedModuleProperty(obj, moduleName, propertyName));
-        }
-        var externalLibs = [].concat(
-                    sanitizedModuleListProperty(obj, "cpp", "staticLibraries"));
-        var staticLibrarySuffix = obj.moduleProperty("cpp", "staticLibrarySuffix");
-        externalLibs.forEach(function(staticLibraryName) {
-            if (!staticLibraryName.endsWith(staticLibrarySuffix))
-                staticLibraryName += staticLibrarySuffix;
-            addFilePath(staticLibraryName);
-        });
-    }
-
-    function traverse(dep) {
-        if (seen.hasOwnProperty(dep.name))
-            return;
-        seen[dep.name] = true;
-
-        if (dep.parameters.cpp && dep.parameters.cpp.link === false)
-            return;
-
-        var staticLibraryArtifacts = dep.artifacts["staticlibrary"];
-        if (staticLibraryArtifacts) {
-            dep.dependencies.forEach(traverse);
-            addArtifactFilePaths(dep, staticLibraryArtifacts);
-            addExternalStaticLibs(dep);
-        }
-    }
-
-    product.dependencies.forEach(traverse);
-    addExternalStaticLibs(product);
-    return result;
+// We need to use the asm_adb, asm_src, asm_sym and rst_data
+// artifacts without of any conditions. Because SDCC always generates
+// it (and seems, this behavior can not be disabled for SDCC).
+function extraCompilerOutputTags() {
+    return ["asm_adb", "asm_src", "asm_sym", "rst_data"];
 }
 
-function compilerOutputArtifacts(input, isCompilerArtifacts) {
-    var obj = {
-        fileTags: ["obj"],
-        filePath: Utilities.getHash(input.baseDir) + "/"
-              + input.fileName + input.cpp.objectSuffix
-    };
+// We need to use the lk_cmd, and mem_summary artifacts without
+// of any conditions. Because SDCC always generates
+// it (and seems, this behavior can not be disabled for SDCC).
+function extraApplicationLinkerOutputTags() {
+    return ["lk_cmd", "mem_summary"];
+}
 
-    // We need to use the asm_adb, asm_src, asm_sym and rst_data
-    // artifacts without of any conditions. Because SDCC always generates
-    // it (and seems, this behavior can not be disabled for SDCC).
-    var asm_adb = {
+// We need to use the asm_adb, asm_src, asm_sym and rst_data
+// artifacts without of any conditions. Because SDCC always generates
+// it (and seems, this behavior can not be disabled for SDCC).
+function extraCompilerOutputArtifacts(input) {
+    return [{
         fileTags: ["asm_adb"],
         filePath: Utilities.getHash(input.baseDir) + "/"
-              + input.fileName + ".adb"
-    };
-    var asm_src = {
+            + input.fileName + ".adb"
+    }, {
         fileTags: ["asm_src"],
         filePath: Utilities.getHash(input.baseDir) + "/"
-              + input.fileName + ".asm"
-    };
-    var asm_sym = {
+            + input.fileName + ".asm"
+    }, {
         fileTags: ["asm_sym"],
         filePath: Utilities.getHash(input.baseDir) + "/"
-              + input.fileName + ".sym"
-    };
-    var rst_data = {
+            + input.fileName + ".sym"
+    }, {
         fileTags: ["rst_data"],
         filePath: Utilities.getHash(input.baseDir) + "/"
-              + input.fileName + ".rst"
-    };
-    var artifacts = [obj, asm_adb, asm_src, asm_sym, rst_data];
-    if (isCompilerArtifacts && input.cpp.generateCompilerListingFiles) {
-        artifacts.push({
-            fileTags: ["lst"],
-            filePath: Utilities.getHash(input.baseDir) + "/"
-              + input.fileName + input.cpp.compilerListingSuffix
-        });
-    } else if (!isCompilerArtifacts && input.cpp.generateAssemblerListingFiles) {
-        artifacts.push({
-            fileTags: ["lst"],
-            filePath: Utilities.getHash(input.baseDir) + "/"
-              + input.fileName + input.cpp.assemblerListingSuffix
-        });
-    }
-    return artifacts;
+            + input.fileName + ".rst"
+    }];
 }
 
-function applicationLinkerOutputArtifacts(product) {
-    var app = {
-        fileTags: ["application"],
-        filePath: FileInfo.joinPaths(
-                      product.destinationDirectory,
-                      PathTools.applicationFilePath(product))
-    };
-    var lk_cmd = {
+// We need to use the lk_cmd, and mem_summary artifacts without
+// of any conditions. Because SDCC always generates
+// it (and seems, this behavior can not be disabled for SDCC).
+function extraApplicationLinkerOutputArtifacts(product) {
+    return [{
         fileTags: ["lk_cmd"],
         filePath: FileInfo.joinPaths(
-                      product.destinationDirectory,
-                      product.targetName + ".lk")
-    };
-    var mem_summary = {
+            product.destinationDirectory,
+            product.targetName + ".lk")
+    }, {
         fileTags: ["mem_summary"],
         filePath: FileInfo.joinPaths(
-                      product.destinationDirectory,
-                      product.targetName + ".mem")
-    };
-    var mem_map = {
-        fileTags: ["mem_map"],
-        filePath: FileInfo.joinPaths(
-                      product.destinationDirectory,
-                      product.targetName + product.cpp.linkerMapSuffix)
-    };
-    return [app, lk_cmd, mem_summary, mem_map]
-}
-
-function staticLibraryLinkerOutputArtifacts(product) {
-    var staticLib = {
-        fileTags: ["staticlibrary"],
-        filePath: FileInfo.joinPaths(
-                      product.destinationDirectory,
-                      PathTools.staticLibraryFilePath(product))
-    };
-    return [staticLib]
+            product.destinationDirectory,
+            product.targetName + ".mem")
+    }];
 }
 
 function compilerFlags(project, product, input, outputs, explicitlyDependsOn) {
-    // Determine which C-language we"re compiling.
-    var tag = ModUtils.fileTagForTargetLanguage(input.fileTags.concat(outputs.obj[0].fileTags));
-
     var args = [];
     var escapablePreprocessorFlags = [];
 
@@ -338,37 +235,19 @@ function compilerFlags(project, product, input, outputs, explicitlyDependsOn) {
     args.push("-c");
     args.push("-o", outputs.obj[0].filePath);
 
-    var prefixHeaders = input.cpp.prefixHeaders;
-    for (var i in prefixHeaders)
-        escapablePreprocessorFlags.push("-include " + prefixHeaders[i]);
+    // Prefix headers.
+    escapablePreprocessorFlags = escapablePreprocessorFlags.concat(
+                Cpp.collectPreincludePathsArguments(input));
 
     // Defines.
-    var allDefines = [];
-    var platformDefines = input.cpp.platformDefines;
-    if (platformDefines)
-        allDefines = allDefines.uniqueConcat(platformDefines);
-    var defines = input.cpp.defines;
-    if (defines)
-        allDefines = allDefines.uniqueConcat(defines);
-    args = args.concat(allDefines.map(function(define) { return "-D" + define }));
+    args = args.concat(Cpp.collectDefinesArguments(input));
 
     // Includes.
-    var includePaths = input.cpp.includePaths;
-    if (includePaths) {
-        args = args.concat([].uniqueConcat(includePaths).map(function(path) {
-            return "-I" + path; }));
-    }
-
-    var allSystemIncludePaths = [];
-    var systemIncludePaths = input.cpp.systemIncludePaths;
-    if (systemIncludePaths)
-        allSystemIncludePaths = allSystemIncludePaths.uniqueConcat(systemIncludePaths);
-    var distributionIncludePaths = input.cpp.distributionIncludePaths;
-    if (distributionIncludePaths)
-        allSystemIncludePaths = allSystemIncludePaths.uniqueConcat(distributionIncludePaths);
+    args = args.concat(Cpp.collectIncludePathsArguments(input));
     escapablePreprocessorFlags = escapablePreprocessorFlags.concat(
-        allSystemIncludePaths.map(function(include) { return "-isystem " + include }));
+                Cpp.collectSystemIncludePathsArguments(input));
 
+    // Target MCU flag.
     var targetFlag = targetArchitectureFlag(input.cpp.architecture);
     if (targetFlag)
         args.push(targetFlag);
@@ -401,6 +280,9 @@ function compilerFlags(project, product, input, outputs, explicitlyDependsOn) {
     if (input.cpp.treatWarningsAsErrors)
         args.push("--Werror");
 
+    // Determine which C-language we"re compiling.
+    var tag = ModUtils.fileTagForTargetLanguage(input.fileTags.concat(outputs.obj[0].fileTags));
+
     // C language version flags.
     if (tag === "c") {
         var knownValues = ["c11", "c99", "c89"];
@@ -419,46 +301,25 @@ function compilerFlags(project, product, input, outputs, explicitlyDependsOn) {
         }
     }
 
-    // Misc flags.
-    escapablePreprocessorFlags = escapablePreprocessorFlags.uniqueConcat(input.cpp.cppFlags);
     var escapedPreprocessorFlags = escapePreprocessorFlags(escapablePreprocessorFlags);
     if (escapedPreprocessorFlags)
         Array.prototype.push.apply(args, escapedPreprocessorFlags);
 
-    args = args.concat(ModUtils.moduleProperty(input, "platformFlags"),
-                       ModUtils.moduleProperty(input, "flags"),
-                       ModUtils.moduleProperty(input, "platformFlags", tag),
-                       ModUtils.moduleProperty(input, "flags", tag),
-                       ModUtils.moduleProperty(input, "driverFlags", tag));
-
+    // Misc flags.
+    args = args.concat(Cpp.collectMiscCompilerArguments(input, tag),
+                       Cpp.collectMiscDriverArguments(input));
     return args;
 }
 
 function assemblerFlags(project, product, input, outputs, explicitlyDependsOn) {
-    // Determine which C-language we"re compiling
-    var tag = ModUtils.fileTagForTargetLanguage(input.fileTags.concat(outputs.obj[0].fileTags));
-
     var args = [];
 
     // Includes.
-    var includePaths = input.cpp.includePaths;
-    if (includePaths) {
-        args = args.concat([].uniqueConcat(includePaths).map(function(path) {
-            return "-I" + path; }));
-    }
-
-    var allSystemIncludePaths = [];
-    var systemIncludePaths = input.cpp.systemIncludePaths;
-    if (systemIncludePaths)
-        allSystemIncludePaths = allSystemIncludePaths.uniqueConcat(systemIncludePaths);
-    var distributionIncludePaths = input.cpp.distributionIncludePaths;
-    if (distributionIncludePaths)
-        allSystemIncludePaths = allSystemIncludePaths.uniqueConcat(distributionIncludePaths);
-    args = args.concat(allSystemIncludePaths.map(function(include) { return "-I" + include }));
+    args = args.concat(Cpp.collectIncludePathsArguments(input));
+    args = args.concat(Cpp.collectSystemIncludePathsArguments(input, input.cpp.includeFlag));
 
     // Misc flags.
-    args = args.concat(ModUtils.moduleProperty(input, "platformFlags", tag),
-                       ModUtils.moduleProperty(input, "flags", tag));
+    args = args.concat(Cpp.collectMiscAssemblerArguments(input, "asm"));
 
     args.push("-ol");
     args.push(outputs.obj[0].filePath);
@@ -474,82 +335,53 @@ function linkerFlags(project, product, inputs, outputs) {
     if (targetFlag)
         args.push(targetFlag);
 
-    var allLibraryPaths = [];
-    var libraryPaths = product.cpp.libraryPaths;
-    if (libraryPaths)
-        allLibraryPaths = allLibraryPaths.uniqueConcat(libraryPaths);
-    var distributionLibraryPaths = product.cpp.distributionLibraryPaths;
-    if (distributionLibraryPaths)
-        allLibraryPaths = allLibraryPaths.uniqueConcat(distributionLibraryPaths);
-
-    var libraryDependencies = collectLibraryDependencies(product);
-
     var escapableLinkerFlags = [];
 
     // Map file generation flag.
     if (product.cpp.generateLinkerMapFile)
         escapableLinkerFlags.push("-m");
 
-    if (product.cpp.platformLinkerFlags)
-        Array.prototype.push.apply(escapableLinkerFlags, product.cpp.platformLinkerFlags);
-    if (product.cpp.linkerFlags)
-        Array.prototype.push.apply(escapableLinkerFlags, product.cpp.linkerFlags);
+    escapableLinkerFlags = escapableLinkerFlags.concat(Cpp.collectMiscEscapableLinkerArguments(product));
 
     var useCompilerDriver = useCompilerDriverLinker(product);
-    if (useCompilerDriver) {
-        // Output.
-        args.push("-o", outputs.application[0].filePath);
-
-        // Inputs.
-        if (inputs.obj)
-            args = args.concat(inputs.obj.map(function(obj) { return obj.filePath }));
-
-        // Library paths.
-        args = args.concat(allLibraryPaths.map(function(path) { return "-L" + path }));
-
-        // Linker scripts.
-        var scripts = inputs.linkerscript
-            ? inputs.linkerscript.map(function(scr) { return "-f" + scr.filePath; }) : [];
-        if (scripts)
-            Array.prototype.push.apply(escapableLinkerFlags, scripts);
-    } else {
-        // Output.
-        args.push(outputs.application[0].filePath);
-
-        // Inputs.
-        if (inputs.obj)
-            args = args.concat(inputs.obj.map(function(obj) { return obj.filePath }));
-
-        // Library paths.
-        args = args.concat(allLibraryPaths.map(function(path) { return "-k" + path }));
-
-        // Linker scripts.
-        // Note: We need to split the '-f' and the file path to separate
-        // lines; otherwise the linking fails.
-        inputs.linkerscript.forEach(function(scr) {
-            escapableLinkerFlags.push("-f", scr.filePath);
-        });
-    }
+
+    // Output.
+    if (useCompilerDriver)
+        args.push("-o");
+    args.push(outputs.application[0].filePath);
+
+    // Inputs.
+    args = args.concat(Cpp.collectLinkerObjectPaths(inputs));
+
+    // Library paths.
+    var libraryPathFlag = useCompilerDriver ? "-L" : "-k";
+    args = args.concat(Cpp.collectLibraryPathsArguments(product, libraryPathFlag));
+
+    // Linker scripts.
+    // Note: We need to split the '-f' flag and the file path to separate
+    // lines when we don't use the compiler driver mode.
+    escapableLinkerFlags = escapableLinkerFlags.concat(
+                Cpp.collectLinkerScriptPathsArguments(product, inputs, !useCompilerDriver));
 
     // Library dependencies.
-    if (libraryDependencies)
-        args = args.concat(libraryDependencies.map(function(dep) { return "-l" + dep.filePath }));
+    args = args.concat(Cpp.collectLibraryDependenciesArguments(product));
 
-    // Misc flags.
     var escapedLinkerFlags = escapeLinkerFlags(product, escapableLinkerFlags);
     if (escapedLinkerFlags)
         Array.prototype.push.apply(args, escapedLinkerFlags);
-    var driverLinkerFlags = useCompilerDriver ? product.cpp.driverLinkerFlags : undefined;
-    if (driverLinkerFlags)
-        Array.prototype.push.apply(args, driverLinkerFlags);
+
+    // Misc flags.
+    if (useCompilerDriver) {
+        args = args.concat(Cpp.collectMiscLinkerArguments(product),
+                           Cpp.collectMiscDriverArguments(product));
+    }
     return args;
 }
 
 function archiverFlags(project, product, inputs, outputs) {
     var args = ["-rc"];
     args.push(outputs.staticlibrary[0].filePath);
-    if (inputs.obj)
-        args = args.concat(inputs.obj.map(function(obj) { return obj.filePath }));
+    args = args.concat(Cpp.collectLinkerObjectPaths(inputs));
     return args;
 }