diff options
Diffstat (limited to 'share/qbs/modules/cpp/cpp.js')
| -rw-r--r-- | share/qbs/modules/cpp/cpp.js | 378 |
1 files changed, 378 insertions, 0 deletions
diff --git a/share/qbs/modules/cpp/cpp.js b/share/qbs/modules/cpp/cpp.js index 0e440bdb0..9563a5c84 100644 --- a/share/qbs/modules/cpp/cpp.js +++ b/share/qbs/modules/cpp/cpp.js @@ -28,6 +28,12 @@ ** ****************************************************************************/ +var File = require("qbs.File"); +var FileInfo = require("qbs.FileInfo"); +var ModUtils = require("qbs.ModUtils"); +var PathTools = require("qbs.PathTools"); +var Utilities = require("qbs.Utilities"); + function languageVersion(versionArray, knownValues, lang) { if (!versionArray) return undefined; @@ -44,3 +50,375 @@ function languageVersion(versionArray, knownValues, lang) { + "' from list of unknown " + lang + " version strings (" + versions + ")"); return version; } + +function extractMacros(output) { + var m = {}; + output.trim().split(/\r?\n/g).map(function (line) { + var prefix = "#define "; + if (!line.startsWith(prefix)) + return; + var index = line.indexOf(" ", prefix.length); + if (index !== -1) + m[line.substr(prefix.length, index - prefix.length)] = line.substr(index + 1); + }); + return m; +} + +function relativePath(baseDirectory, filePath) { + if (FileInfo.isAbsolutePath(filePath)) + return FileInfo.relativePath(baseDirectory, filePath); + return filePath; +} + +function assemblerOutputTags(needsListingFiles) { + var tags = ["obj"]; + if (needsListingFiles) + tags.push("lst"); + return tags; +} + +function compilerOutputTags(needsListingFiles) { + var tags = ["obj"]; + if (needsListingFiles) + tags.push("lst"); + return tags; +} + +function applicationLinkerOutputTags(needsLinkerMapFile) { + var tags = ["application"]; + if (needsLinkerMapFile) + tags.push("mem_map"); + return tags; +} + +function dynamicLibraryLinkerOutputTags() { + return ["dynamiclibrary", "dynamiclibrary_import"]; +} + +function staticLibraryLinkerOutputTags() { + return ["staticlibrary"]; +} + +function resourceCompilerOutputTags() { + return ["res"]; +} + +function assemblerOutputArtifacts(input) { + var artifacts = []; + artifacts.push({ + fileTags: ["obj"], + filePath: Utilities.getHash(input.baseDir) + "/" + + input.fileName + input.cpp.objectSuffix + }); + if (input.cpp.generateAssemblerListingFiles) { + artifacts.push({ + fileTags: ["lst"], + filePath: Utilities.getHash(input.baseDir) + "/" + + input.fileName + input.cpp.assemblerListingSuffix + }); + } + return artifacts; +} + +function compilerOutputArtifacts(input) { + var artifacts = []; + artifacts.push({ + fileTags: ["obj"], + filePath: Utilities.getHash(input.baseDir) + "/" + + input.fileName + input.cpp.objectSuffix + }); + if (input.cpp.generateCompilerListingFiles) { + artifacts.push({ + fileTags: ["lst"], + filePath: Utilities.getHash(input.baseDir) + "/" + + input.fileName + input.cpp.compilerListingSuffix + }); + } + return artifacts; +} + +function applicationLinkerOutputArtifacts(product) { + var artifacts = [{ + fileTags: ["application"], + filePath: FileInfo.joinPaths( + product.destinationDirectory, + PathTools.applicationFilePath(product)) + }]; + if (product.cpp.generateLinkerMapFile) { + artifacts.push({ + fileTags: ["mem_map"], + filePath: FileInfo.joinPaths( + product.destinationDirectory, + product.targetName + product.cpp.linkerMapSuffix) + }); + } + return artifacts; +} + +function dynamicLibraryLinkerOutputArtifacts(product) { + return [{ + fileTags: ["dynamiclibrary"], + filePath: FileInfo.joinPaths(product.destinationDirectory, + PathTools.dynamicLibraryFilePath(product)) + }, { + fileTags: ["dynamiclibrary_import"], + filePath: FileInfo.joinPaths(product.destinationDirectory, + PathTools.importLibraryFilePath(product)), + alwaysUpdated: false + }]; +} + +function staticLibraryLinkerOutputArtifacts(product) { + return [{ + fileTags: ["staticlibrary"], + filePath: FileInfo.joinPaths(product.destinationDirectory, + PathTools.staticLibraryFilePath(product)) + }]; +} + +function resourceCompilerOutputArtifacts(input) { + return [{ + fileTags: ["res"], + filePath: FileInfo.joinPaths(Utilities.getHash(input.baseDir), + input.completeBaseName + input.cpp.resourceSuffix) + }]; +} + +function collectLibraryDependencies(product) { + var seen = {}; + var result = []; + + function addFilePath(filePath, wholeArchive, productName) { + result.push({ filePath: filePath, wholeArchive: wholeArchive, productName: productName }); + } + + function addArtifactFilePaths(dep, artifacts) { + if (!artifacts) + return; + var artifactFilePaths = artifacts.map(function(a) { return a.filePath; }); + var wholeArchive = dep.parameters.cpp && dep.parameters.cpp.linkWholeArchive; + var artifactsAreImportLibs = artifacts.length > 0 + && artifacts[0].fileTags.contains("dynamiclibrary_import"); + for (var i = 0; i < artifactFilePaths.length; ++i) { + addFilePath(artifactFilePaths[i], wholeArchive, + artifactsAreImportLibs ? dep.name : undefined); + } + } + + function addExternalLibs(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"), + sanitizedModuleListProperty(obj, "cpp", "dynamicLibraries")); + var libSuffix = obj.moduleProperty("cpp", "staticLibrarySuffix"); + externalLibs.forEach(function(libName) { + if (!libName.endsWith(libSuffix) && !libName.startsWith('@')) + libName += libSuffix; + addFilePath(libName); + }); + } + + function traverse(dep) { + if (seen.hasOwnProperty(dep.name)) + return; + if (dep.parameters.cpp && dep.parameters.cpp.link === false) + return; + + var staticLibraryArtifacts = dep.artifacts["staticlibrary"]; + var dynamicLibraryArtifacts = staticLibraryArtifacts + ? null : dep.artifacts["dynamiclibrary_import"]; + if (staticLibraryArtifacts) { + seen[dep.name] = true; + dep.dependencies.forEach(traverse); + addArtifactFilePaths(dep, staticLibraryArtifacts); + addExternalLibs(dep); + } else if (dynamicLibraryArtifacts) { + seen[dep.name] = true; + addArtifactFilePaths(dep, dynamicLibraryArtifacts); + } + } + + product.dependencies.forEach(traverse); + addExternalLibs(product); + return result; +} + +function collectAbsoluteLibraryDependencyPaths(product) { + var paths = collectLibraryPaths(product); + var deps = collectLibraryDependencies(product); + return deps.map(function(dep) { + var filePath = dep.filePath; + if (FileInfo.isAbsolutePath(filePath)) + return filePath; + for (var i = 0; i < paths.length; ++i) { + var fullPath = FileInfo.joinPaths(paths[i], filePath); + if (File.exists(fullPath)) + return fullPath; + } + return filePath; + }); +} + +function collectDefines(input) { + var allDefines = []; + var platformDefines = input.cpp.platformDefines; + if (platformDefines) + allDefines = allDefines.uniqueConcat(platformDefines); + var defines = input.cpp.defines; + if (defines) + allDefines = allDefines.uniqueConcat(defines); + return allDefines; +} + +function collectIncludePaths(input) { + var allIncludePaths = []; + var includePaths = input.cpp.includePaths; + if (includePaths) + allIncludePaths = allIncludePaths.uniqueConcat(includePaths); + return allIncludePaths; +} + +function collectSystemIncludePaths(input) { + var allIncludePaths = []; + var systemIncludePaths = input.cpp.systemIncludePaths; + if (systemIncludePaths) + allIncludePaths = allIncludePaths.uniqueConcat(systemIncludePaths); + var distributionIncludePaths = input.cpp.distributionIncludePaths; + if (distributionIncludePaths) + allIncludePaths = allIncludePaths.uniqueConcat(distributionIncludePaths); + return allIncludePaths; +} + +function collectPreincludePaths(input) { + return input.cpp.prefixHeaders; +} + +function collectLibraryPaths(product) { + var allLibraryPaths = []; + var libraryPaths = product.cpp.libraryPaths; + if (libraryPaths) + allLibraryPaths = allLibraryPaths.uniqueConcat(libraryPaths); + var distributionLibraryPaths = product.cpp.distributionLibraryPaths; + if (distributionLibraryPaths) + allLibraryPaths = allLibraryPaths.uniqueConcat(distributionLibraryPaths); + return allLibraryPaths; +} + +function collectLinkerScriptPaths(inputs) { + return inputs.linkerscript + ? inputs.linkerscript.map(function(script) { return script.filePath; }) + : []; +} + +function collectLinkerObjectPaths(inputs) { + return inputs.obj ? inputs.obj.map(function(obj) { return obj.filePath; }) : []; +} + +function collectResourceObjectPaths(inputs) { + return inputs.res ? inputs.res.map(function(res) { return res.filePath; }) : []; +} + +function collectLibraryDependenciesArguments(product) { + var deps = collectLibraryDependencies(product); + return deps.map(function(dep) { return product.cpp.libraryDependencyFlag + dep.filePath }) +} + +function collectDefinesArguments(input) { + var defines = collectDefines(input); + return defines.map(function(define) { return input.cpp.defineFlag + define }); +} + +function collectIncludePathsArguments(input) { + var paths = collectIncludePaths(input); + return paths.map(function(path) { return input.cpp.includeFlag + path }); +} + +function collectSystemIncludePathsArguments(input, flag) { + flag = (flag === undefined) ? input.cpp.systemIncludeFlag : flag; + var paths = collectSystemIncludePaths(input); + return paths.map(function(path) { return flag + path }); +} + +function collectPreincludePathsArguments(input, split) { + var paths = collectPreincludePaths(input); + if (split) { + var args = []; + for (var i = 0; i < paths.length; ++i) + args.push(input.cpp.preincludeFlag, paths[i]); + return args; + } else { + return paths.map(function(path) { return input.cpp.preincludeFlag + path }); + } +} + +function collectLibraryPathsArguments(product, flag) { + flag = (flag === undefined) ? product.cpp.libraryPathFlag : flag; + var paths = collectLibraryPaths(product); + return paths.map(function(path) { return flag + path }); +} + +function collectLinkerScriptPathsArguments(product, inputs, split, flag) { + flag = (flag === undefined) ? product.cpp.linkerScriptFlag : flag; + var paths = collectLinkerScriptPaths(inputs); + if (split) { + var args = []; + for (var i = 0; i < paths.length; ++i) + args.push(flag, paths[i]); + return args; + } else { + return paths.map(function(path) { return flag + path }); + } +} + +function collectLinkerObjectPathsArguments(product, inputs, flag) { + flag = (flag === undefined) ? "" : flag; + var paths = collectLinkerObjectPaths(product); + return paths.map(function(path) { return flag + path }); +} + +function collectMiscCompilerArguments(input, tag) { + return [].concat(ModUtils.moduleProperty(input, "platformFlags"), + ModUtils.moduleProperty(input, "flags"), + ModUtils.moduleProperty(input, "platformFlags", tag), + ModUtils.moduleProperty(input, "flags", tag)); +} + +function collectMiscAssemblerArguments(input, tag) { + return [].concat(ModUtils.moduleProperty(input, "platformFlags", tag), + ModUtils.moduleProperty(input, "flags", tag)); +} + +function collectMiscDriverArguments(config) { + return [].concat(ModUtils.moduleProperty(config, "platformDriverFlags"), + ModUtils.moduleProperty(config, "driverFlags"), + ModUtils.moduleProperty(config, "targetDriverFlags")); +} + +function collectMiscLinkerArguments(product) { + return [].concat(ModUtils.moduleProperty(product, "driverLinkerFlags")); +} + +function collectMiscEscapableLinkerArguments(product) { + return [].concat(ModUtils.moduleProperty(product, "platformLinkerFlags"), + ModUtils.moduleProperty(product, "linkerFlags")); +} + +function supportsArchitecture(architecture, knownArchitectures) { + for (var i = 0; i < knownArchitectures.length; ++i) { + if (architecture.startsWith("arm")) { + if (architecture.startsWith(knownArchitectures[i])) + return true; + } else { + if (architecture === knownArchitectures[i]) + return true; + } + } + return false; +} |