You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
600 lines
21 KiB
600 lines
21 KiB
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
#include "cmExportBuildFileGenerator.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <set>
|
|
#include <sstream>
|
|
#include <utility>
|
|
|
|
#include <cm/string_view>
|
|
#include <cmext/string_view>
|
|
|
|
#include "cmCryptoHash.h"
|
|
#include "cmExportSet.h"
|
|
#include "cmFileSet.h"
|
|
#include "cmGeneratedFileStream.h"
|
|
#include "cmGeneratorExpression.h"
|
|
#include "cmGeneratorTarget.h"
|
|
#include "cmGlobalGenerator.h"
|
|
#include "cmList.h"
|
|
#include "cmLocalGenerator.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmMessageType.h"
|
|
#include "cmOutputConverter.h"
|
|
#include "cmPolicies.h"
|
|
#include "cmStateTypes.h"
|
|
#include "cmStringAlgorithms.h"
|
|
#include "cmSystemTools.h"
|
|
#include "cmTarget.h"
|
|
#include "cmTargetExport.h"
|
|
#include "cmValue.h"
|
|
#include "cmake.h"
|
|
|
|
class cmSourceFile;
|
|
|
|
cmExportBuildFileGenerator::cmExportBuildFileGenerator()
|
|
{
|
|
this->LG = nullptr;
|
|
this->ExportSet = nullptr;
|
|
}
|
|
|
|
void cmExportBuildFileGenerator::Compute(cmLocalGenerator* lg)
|
|
{
|
|
this->LG = lg;
|
|
if (this->ExportSet) {
|
|
this->ExportSet->Compute(lg);
|
|
}
|
|
}
|
|
|
|
bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
|
|
{
|
|
{
|
|
std::string expectedTargets;
|
|
std::string sep;
|
|
std::vector<TargetExport> targets;
|
|
bool generatedInterfaceRequired = false;
|
|
this->GetTargets(targets);
|
|
for (auto const& tei : targets) {
|
|
cmGeneratorTarget* te = this->LG->FindGeneratorTargetToUse(tei.Name);
|
|
expectedTargets += sep + this->Namespace + te->GetExportName();
|
|
sep = " ";
|
|
if (this->ExportedTargets.insert(te).second) {
|
|
this->Exports.emplace_back(te, tei.XcFrameworkLocation);
|
|
} else {
|
|
std::ostringstream e;
|
|
e << "given target \"" << te->GetName() << "\" more than once.";
|
|
this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
|
|
MessageType::FATAL_ERROR, e.str(),
|
|
this->LG->GetMakefile()->GetBacktrace());
|
|
return false;
|
|
}
|
|
generatedInterfaceRequired |=
|
|
this->GetExportTargetType(te) == cmStateEnums::INTERFACE_LIBRARY;
|
|
}
|
|
|
|
if (generatedInterfaceRequired) {
|
|
this->SetRequiredCMakeVersion(3, 0, 0);
|
|
}
|
|
this->GenerateExpectedTargetsCode(os, expectedTargets);
|
|
}
|
|
|
|
// Create all the imported targets.
|
|
for (auto const& exp : this->Exports) {
|
|
cmGeneratorTarget* gte = exp.Target;
|
|
this->GenerateImportTargetCode(os, gte, this->GetExportTargetType(gte));
|
|
|
|
gte->Target->AppendBuildInterfaceIncludes();
|
|
|
|
ImportPropertyMap properties;
|
|
|
|
this->PopulateInterfaceProperty("INTERFACE_INCLUDE_DIRECTORIES", gte,
|
|
cmGeneratorExpression::BuildInterface,
|
|
properties);
|
|
this->PopulateInterfaceProperty("INTERFACE_SOURCES", gte,
|
|
cmGeneratorExpression::BuildInterface,
|
|
properties);
|
|
this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", gte,
|
|
cmGeneratorExpression::BuildInterface,
|
|
properties);
|
|
this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", gte,
|
|
cmGeneratorExpression::BuildInterface,
|
|
properties);
|
|
this->PopulateInterfaceProperty("INTERFACE_PRECOMPILE_HEADERS", gte,
|
|
cmGeneratorExpression::BuildInterface,
|
|
properties);
|
|
this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", gte,
|
|
cmGeneratorExpression::BuildInterface,
|
|
properties);
|
|
this->PopulateInterfaceProperty("INTERFACE_AUTOMOC_MACRO_NAMES", gte,
|
|
cmGeneratorExpression::BuildInterface,
|
|
properties);
|
|
this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gte,
|
|
cmGeneratorExpression::BuildInterface,
|
|
properties);
|
|
this->PopulateInterfaceProperty("INTERFACE_LINK_OPTIONS", gte,
|
|
cmGeneratorExpression::BuildInterface,
|
|
properties);
|
|
this->PopulateInterfaceProperty("INTERFACE_LINK_DIRECTORIES", gte,
|
|
cmGeneratorExpression::BuildInterface,
|
|
properties);
|
|
this->PopulateInterfaceProperty("INTERFACE_LINK_DEPENDS", gte,
|
|
cmGeneratorExpression::BuildInterface,
|
|
properties);
|
|
this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", gte,
|
|
properties);
|
|
|
|
std::string errorMessage;
|
|
if (!this->PopulateCxxModuleExportProperties(
|
|
gte, properties, cmGeneratorExpression::BuildInterface, {},
|
|
errorMessage)) {
|
|
this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
|
|
MessageType::FATAL_ERROR, errorMessage,
|
|
this->LG->GetMakefile()->GetBacktrace());
|
|
return false;
|
|
}
|
|
|
|
if (!this->PopulateExportProperties(gte, properties, errorMessage)) {
|
|
this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
|
|
MessageType::FATAL_ERROR, errorMessage,
|
|
this->LG->GetMakefile()->GetBacktrace());
|
|
return false;
|
|
}
|
|
|
|
const bool newCMP0022Behavior =
|
|
gte->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
|
|
gte->GetPolicyStatusCMP0022() != cmPolicies::OLD;
|
|
if (newCMP0022Behavior) {
|
|
this->PopulateInterfaceLinkLibrariesProperty(
|
|
gte, cmGeneratorExpression::BuildInterface, properties);
|
|
}
|
|
this->PopulateCompatibleInterfaceProperties(gte, properties);
|
|
|
|
this->GenerateInterfaceProperties(gte, os, properties);
|
|
|
|
this->GenerateTargetFileSets(gte, os);
|
|
}
|
|
|
|
std::string cxx_modules_name;
|
|
if (this->ExportSet) {
|
|
cxx_modules_name = this->ExportSet->GetName();
|
|
} else {
|
|
cmCryptoHash hasher(cmCryptoHash::AlgoSHA3_512);
|
|
constexpr std::size_t HASH_TRUNCATION = 12;
|
|
for (auto const& target : this->Targets) {
|
|
hasher.Append(target.Name);
|
|
}
|
|
cxx_modules_name = hasher.FinalizeHex().substr(0, HASH_TRUNCATION);
|
|
}
|
|
|
|
this->GenerateCxxModuleInformation(cxx_modules_name, os);
|
|
|
|
// Generate import file content for each configuration.
|
|
for (std::string const& c : this->Configurations) {
|
|
this->GenerateImportConfig(os, c);
|
|
}
|
|
|
|
// Generate import file content for each configuration.
|
|
for (std::string const& c : this->Configurations) {
|
|
this->GenerateImportCxxModuleConfigTargetInclusion(cxx_modules_name, c);
|
|
}
|
|
|
|
this->GenerateMissingTargetsCheckCode(os);
|
|
|
|
return true;
|
|
}
|
|
|
|
void cmExportBuildFileGenerator::GenerateImportTargetsConfig(
|
|
std::ostream& os, const std::string& config, std::string const& suffix)
|
|
{
|
|
for (auto const& exp : this->Exports) {
|
|
cmGeneratorTarget* target = exp.Target;
|
|
|
|
// Collect import properties for this target.
|
|
ImportPropertyMap properties;
|
|
|
|
if (this->GetExportTargetType(target) != cmStateEnums::INTERFACE_LIBRARY) {
|
|
this->SetImportLocationProperty(config, suffix, target, properties);
|
|
}
|
|
if (!properties.empty()) {
|
|
// Get the rest of the target details.
|
|
if (this->GetExportTargetType(target) !=
|
|
cmStateEnums::INTERFACE_LIBRARY) {
|
|
this->SetImportDetailProperties(config, suffix, target, properties);
|
|
this->SetImportLinkInterface(config, suffix,
|
|
cmGeneratorExpression::BuildInterface,
|
|
target, properties);
|
|
}
|
|
|
|
// TODO: PUBLIC_HEADER_LOCATION
|
|
// This should wait until the build feature propagation stuff
|
|
// is done. Then this can be a propagated include directory.
|
|
// this->GenerateImportProperty(config, te->HeaderGenerator,
|
|
// properties);
|
|
|
|
// Generate code in the export file.
|
|
std::string importedXcFrameworkLocation = exp.XcFrameworkLocation;
|
|
if (!importedXcFrameworkLocation.empty()) {
|
|
importedXcFrameworkLocation = cmGeneratorExpression::Preprocess(
|
|
importedXcFrameworkLocation,
|
|
cmGeneratorExpression::PreprocessContext::BuildInterface);
|
|
importedXcFrameworkLocation = cmGeneratorExpression::Evaluate(
|
|
importedXcFrameworkLocation, exp.Target->GetLocalGenerator(), config,
|
|
exp.Target, nullptr, exp.Target);
|
|
if (!importedXcFrameworkLocation.empty() &&
|
|
!cmSystemTools::FileIsFullPath(importedXcFrameworkLocation)) {
|
|
importedXcFrameworkLocation =
|
|
cmStrCat(this->LG->GetCurrentBinaryDirectory(), '/',
|
|
importedXcFrameworkLocation);
|
|
}
|
|
}
|
|
this->GenerateImportPropertyCode(os, config, suffix, target, properties,
|
|
importedXcFrameworkLocation);
|
|
}
|
|
}
|
|
}
|
|
|
|
cmStateEnums::TargetType cmExportBuildFileGenerator::GetExportTargetType(
|
|
cmGeneratorTarget const* target) const
|
|
{
|
|
cmStateEnums::TargetType targetType = target->GetType();
|
|
// An object library exports as an interface library if we cannot
|
|
// tell clients where to find the objects. This is sufficient
|
|
// to support transitive usage requirements on other targets that
|
|
// use the object library.
|
|
if (targetType == cmStateEnums::OBJECT_LIBRARY &&
|
|
!target->Target->HasKnownObjectFileLocation(nullptr)) {
|
|
targetType = cmStateEnums::INTERFACE_LIBRARY;
|
|
}
|
|
return targetType;
|
|
}
|
|
|
|
void cmExportBuildFileGenerator::SetExportSet(cmExportSet* exportSet)
|
|
{
|
|
this->ExportSet = exportSet;
|
|
}
|
|
|
|
void cmExportBuildFileGenerator::SetImportLocationProperty(
|
|
const std::string& config, std::string const& suffix,
|
|
cmGeneratorTarget* target, ImportPropertyMap& properties)
|
|
{
|
|
// Get the makefile in which to lookup target information.
|
|
cmMakefile* mf = target->Makefile;
|
|
|
|
if (target->GetType() == cmStateEnums::OBJECT_LIBRARY) {
|
|
std::string prop = cmStrCat("IMPORTED_OBJECTS", suffix);
|
|
|
|
// Compute all the object files inside this target and setup
|
|
// IMPORTED_OBJECTS as a list of object files
|
|
std::vector<cmSourceFile const*> objectSources;
|
|
target->GetObjectSources(objectSources, config);
|
|
std::string const obj_dir = target->GetObjectDirectory(config);
|
|
std::vector<std::string> objects;
|
|
for (cmSourceFile const* sf : objectSources) {
|
|
const std::string& obj = target->GetObjectName(sf);
|
|
objects.push_back(obj_dir + obj);
|
|
}
|
|
|
|
// Store the property.
|
|
properties[prop] = cmList::to_string(objects);
|
|
} else {
|
|
// Add the main target file.
|
|
{
|
|
std::string prop = cmStrCat("IMPORTED_LOCATION", suffix);
|
|
std::string value;
|
|
if (target->IsAppBundleOnApple()) {
|
|
value =
|
|
target->GetFullPath(config, cmStateEnums::RuntimeBinaryArtifact);
|
|
} else {
|
|
value = target->GetFullPath(config,
|
|
cmStateEnums::RuntimeBinaryArtifact, true);
|
|
}
|
|
properties[prop] = value;
|
|
}
|
|
|
|
// Add the import library for windows DLLs.
|
|
if (target->HasImportLibrary(config)) {
|
|
std::string prop = cmStrCat("IMPORTED_IMPLIB", suffix);
|
|
std::string value =
|
|
target->GetFullPath(config, cmStateEnums::ImportLibraryArtifact, true);
|
|
if (mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) {
|
|
target->GetImplibGNUtoMS(config, value, value,
|
|
"${CMAKE_IMPORT_LIBRARY_SUFFIX}");
|
|
}
|
|
properties[prop] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmExportBuildFileGenerator::HandleMissingTarget(
|
|
std::string& link_libs, cmGeneratorTarget const* depender,
|
|
cmGeneratorTarget* dependee)
|
|
{
|
|
// The target is not in the export.
|
|
if (!this->AppendMode) {
|
|
const std::string name = dependee->GetName();
|
|
cmGlobalGenerator* gg =
|
|
dependee->GetLocalGenerator()->GetGlobalGenerator();
|
|
auto exportInfo = this->FindBuildExportInfo(gg, name);
|
|
std::vector<std::string> const& exportFiles = exportInfo.first;
|
|
|
|
if (exportFiles.size() == 1) {
|
|
std::string missingTarget = exportInfo.second;
|
|
|
|
missingTarget += dependee->GetExportName();
|
|
link_libs += missingTarget;
|
|
this->MissingTargets.emplace_back(std::move(missingTarget));
|
|
return;
|
|
}
|
|
// We are not appending, so all exported targets should be
|
|
// known here. This is probably user-error.
|
|
this->ComplainAboutMissingTarget(depender, dependee, exportFiles);
|
|
}
|
|
// Assume the target will be exported by another command.
|
|
// Append it with the export namespace.
|
|
link_libs += this->Namespace;
|
|
link_libs += dependee->GetExportName();
|
|
}
|
|
|
|
void cmExportBuildFileGenerator::GetTargets(
|
|
std::vector<TargetExport>& targets) const
|
|
{
|
|
if (this->ExportSet) {
|
|
for (std::unique_ptr<cmTargetExport> const& te :
|
|
this->ExportSet->GetTargetExports()) {
|
|
if (te->NamelinkOnly) {
|
|
continue;
|
|
}
|
|
targets.emplace_back(te->TargetName, te->XcFrameworkLocation);
|
|
}
|
|
return;
|
|
}
|
|
targets = this->Targets;
|
|
}
|
|
|
|
std::pair<std::vector<std::string>, std::string>
|
|
cmExportBuildFileGenerator::FindBuildExportInfo(cmGlobalGenerator* gg,
|
|
const std::string& name)
|
|
{
|
|
std::vector<std::string> exportFiles;
|
|
std::string ns;
|
|
|
|
auto& exportSets = gg->GetBuildExportSets();
|
|
|
|
for (auto const& exp : exportSets) {
|
|
const auto& exportSet = exp.second;
|
|
std::vector<TargetExport> targets;
|
|
exportSet->GetTargets(targets);
|
|
if (std::any_of(
|
|
targets.begin(), targets.end(),
|
|
[&name](const TargetExport& te) { return te.Name == name; })) {
|
|
exportFiles.push_back(exp.first);
|
|
ns = exportSet->GetNamespace();
|
|
}
|
|
}
|
|
|
|
return { exportFiles, ns };
|
|
}
|
|
|
|
void cmExportBuildFileGenerator::ComplainAboutMissingTarget(
|
|
cmGeneratorTarget const* depender, cmGeneratorTarget const* dependee,
|
|
std::vector<std::string> const& exportFiles)
|
|
{
|
|
std::ostringstream e;
|
|
e << "export called with target \"" << depender->GetName()
|
|
<< "\" which requires target \"" << dependee->GetName() << "\" ";
|
|
if (exportFiles.empty()) {
|
|
e << "that is not in any export set.";
|
|
} else {
|
|
e << "that is not in this export set, but in multiple other export sets: "
|
|
<< cmJoin(exportFiles, ", ") << ".\n";
|
|
e << "An exported target cannot depend upon another target which is "
|
|
"exported multiple times. Consider consolidating the exports of the "
|
|
"\""
|
|
<< dependee->GetName() << "\" target to a single export.";
|
|
}
|
|
|
|
this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
|
|
MessageType::FATAL_ERROR, e.str(),
|
|
this->LG->GetMakefile()->GetBacktrace());
|
|
}
|
|
|
|
std::string cmExportBuildFileGenerator::InstallNameDir(
|
|
cmGeneratorTarget const* target, const std::string& config)
|
|
{
|
|
std::string install_name_dir;
|
|
|
|
cmMakefile* mf = target->Target->GetMakefile();
|
|
if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
|
|
install_name_dir = target->GetInstallNameDirForBuildTree(config);
|
|
}
|
|
|
|
return install_name_dir;
|
|
}
|
|
|
|
namespace {
|
|
bool EntryIsContextSensitive(
|
|
const std::unique_ptr<cmCompiledGeneratorExpression>& cge)
|
|
{
|
|
return cge->GetHadContextSensitiveCondition();
|
|
}
|
|
}
|
|
|
|
std::string cmExportBuildFileGenerator::GetFileSetDirectories(
|
|
cmGeneratorTarget* gte, cmFileSet* fileSet, cmTargetExport* /*te*/)
|
|
{
|
|
std::vector<std::string> resultVector;
|
|
|
|
auto configs =
|
|
gte->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
|
|
auto directoryEntries = fileSet->CompileDirectoryEntries();
|
|
|
|
for (auto const& config : configs) {
|
|
auto directories = fileSet->EvaluateDirectoryEntries(
|
|
directoryEntries, gte->LocalGenerator, config, gte);
|
|
|
|
bool const contextSensitive =
|
|
std::any_of(directoryEntries.begin(), directoryEntries.end(),
|
|
EntryIsContextSensitive);
|
|
|
|
auto const& type = fileSet->GetType();
|
|
// C++ modules do not support interface file sets which are dependent upon
|
|
// the configuration.
|
|
if (contextSensitive && type == "CXX_MODULES"_s) {
|
|
auto* mf = this->LG->GetMakefile();
|
|
std::ostringstream e;
|
|
e << "The \"" << gte->GetName() << "\" target's interface file set \""
|
|
<< fileSet->GetName() << "\" of type \"" << type
|
|
<< "\" contains context-sensitive base directory entries which is not "
|
|
"supported.";
|
|
mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
|
|
return std::string{};
|
|
}
|
|
|
|
for (auto const& directory : directories) {
|
|
auto dest = cmOutputConverter::EscapeForCMake(
|
|
directory, cmOutputConverter::WrapQuotes::NoWrap);
|
|
|
|
if (contextSensitive && configs.size() != 1) {
|
|
resultVector.push_back(
|
|
cmStrCat("\"$<$<CONFIG:", config, ">:", dest, ">\""));
|
|
} else {
|
|
resultVector.emplace_back(cmStrCat('"', dest, '"'));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return cmJoin(resultVector, " ");
|
|
}
|
|
|
|
std::string cmExportBuildFileGenerator::GetFileSetFiles(cmGeneratorTarget* gte,
|
|
cmFileSet* fileSet,
|
|
cmTargetExport* /*te*/)
|
|
{
|
|
std::vector<std::string> resultVector;
|
|
|
|
auto configs =
|
|
gte->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
|
|
|
|
auto fileEntries = fileSet->CompileFileEntries();
|
|
auto directoryEntries = fileSet->CompileDirectoryEntries();
|
|
|
|
for (auto const& config : configs) {
|
|
auto directories = fileSet->EvaluateDirectoryEntries(
|
|
directoryEntries, gte->LocalGenerator, config, gte);
|
|
|
|
std::map<std::string, std::vector<std::string>> files;
|
|
for (auto const& entry : fileEntries) {
|
|
fileSet->EvaluateFileEntry(directories, files, entry,
|
|
gte->LocalGenerator, config, gte);
|
|
}
|
|
|
|
bool const contextSensitive =
|
|
std::any_of(directoryEntries.begin(), directoryEntries.end(),
|
|
EntryIsContextSensitive) ||
|
|
std::any_of(fileEntries.begin(), fileEntries.end(),
|
|
EntryIsContextSensitive);
|
|
|
|
auto const& type = fileSet->GetType();
|
|
// C++ modules do not support interface file sets which are dependent upon
|
|
// the configuration.
|
|
if (contextSensitive && type == "CXX_MODULES"_s) {
|
|
auto* mf = this->LG->GetMakefile();
|
|
std::ostringstream e;
|
|
e << "The \"" << gte->GetName() << "\" target's interface file set \""
|
|
<< fileSet->GetName() << "\" of type \"" << type
|
|
<< "\" contains context-sensitive file entries which is not "
|
|
"supported.";
|
|
mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
|
|
return std::string{};
|
|
}
|
|
|
|
for (auto const& it : files) {
|
|
for (auto const& filename : it.second) {
|
|
auto escapedFile = cmOutputConverter::EscapeForCMake(
|
|
filename, cmOutputConverter::WrapQuotes::NoWrap);
|
|
if (contextSensitive && configs.size() != 1) {
|
|
resultVector.push_back(
|
|
cmStrCat("\"$<$<CONFIG:", config, ">:", escapedFile, ">\""));
|
|
} else {
|
|
resultVector.emplace_back(cmStrCat('"', escapedFile, '"'));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!(contextSensitive && configs.size() != 1)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return cmJoin(resultVector, " ");
|
|
}
|
|
|
|
std::string cmExportBuildFileGenerator::GetCxxModulesDirectory() const
|
|
{
|
|
return this->CxxModulesDirectory;
|
|
}
|
|
|
|
void cmExportBuildFileGenerator::GenerateCxxModuleConfigInformation(
|
|
std::string const& name, std::ostream& os) const
|
|
{
|
|
const char* opt = "";
|
|
if (this->Configurations.size() > 1) {
|
|
// With more than one configuration, each individual file is optional.
|
|
opt = " OPTIONAL";
|
|
}
|
|
|
|
// Generate import file content for each configuration.
|
|
for (std::string c : this->Configurations) {
|
|
if (c.empty()) {
|
|
c = "noconfig";
|
|
}
|
|
os << "include(\"${CMAKE_CURRENT_LIST_DIR}/cxx-modules-" << name << '-'
|
|
<< c << ".cmake\"" << opt << ")\n";
|
|
}
|
|
}
|
|
|
|
bool cmExportBuildFileGenerator::GenerateImportCxxModuleConfigTargetInclusion(
|
|
std::string const& name, std::string config) const
|
|
{
|
|
auto cxx_modules_dirname = this->GetCxxModulesDirectory();
|
|
if (cxx_modules_dirname.empty()) {
|
|
return true;
|
|
}
|
|
|
|
if (config.empty()) {
|
|
config = "noconfig";
|
|
}
|
|
|
|
std::string fileName =
|
|
cmStrCat(this->FileDir, '/', cxx_modules_dirname, "/cxx-modules-", name,
|
|
'-', config, ".cmake");
|
|
|
|
cmGeneratedFileStream os(fileName, true);
|
|
if (!os) {
|
|
std::string se = cmSystemTools::GetLastSystemError();
|
|
std::ostringstream e;
|
|
e << "cannot write to file \"" << fileName << "\": " << se;
|
|
cmSystemTools::Error(e.str());
|
|
return false;
|
|
}
|
|
os.SetCopyIfDifferent(true);
|
|
|
|
for (auto const* tgt : this->ExportedTargets) {
|
|
// Only targets with C++ module sources will have a
|
|
// collator-generated install script.
|
|
if (!tgt->HaveCxx20ModuleSources()) {
|
|
continue;
|
|
}
|
|
|
|
os << "include(\"${CMAKE_CURRENT_LIST_DIR}/target-"
|
|
<< tgt->GetFilesystemExportName() << '-' << config << ".cmake\")\n";
|
|
}
|
|
|
|
return true;
|
|
}
|