mirror of
https://github.com/Kitware/CMake.git
synced 2025-10-14 02:08:27 +08:00
export: Factor out CMake-specific export generation (*/2)
In order to support generation of Common Package Specifications, the mechanisms CMake uses to export package information need to be made more abstract. This will involve substantial refactoring of the classes used to generate the actual export files. In order to help git track what's happening, create the new files as copies of the files that will serve as their source material. The class names have been updated and formatting repaired, but no other refactoring has been done, which should still allow git to detect the copies. This commit is a purely intermediate step that exists for no other reason than to improve history tracking.
This commit is contained in:
Matthew Woehlke
196
Source/cmExportAndroidMKGenerator.cxx
Normal file
196
Source/cmExportAndroidMKGenerator.cxx
Normal file
@@ -0,0 +1,196 @@
|
||||
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
file Copyright.txt or https://cmake.org/licensing for details. */
|
||||
#include "cmExportAndroidMKGenerator.h"
|
||||
|
||||
#include <map>
|
||||
#include <sstream>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include <cmext/algorithm>
|
||||
|
||||
#include "cmGeneratorTarget.h"
|
||||
#include "cmLinkItem.h"
|
||||
#include "cmList.h"
|
||||
#include "cmMakefile.h"
|
||||
#include "cmMessageType.h"
|
||||
#include "cmPolicies.h"
|
||||
#include "cmStateTypes.h"
|
||||
#include "cmStringAlgorithms.h"
|
||||
#include "cmSystemTools.h"
|
||||
#include "cmTarget.h"
|
||||
|
||||
cmExportAndroidMKGenerator::cmExportAndroidMKGenerator()
|
||||
{
|
||||
this->LG = nullptr;
|
||||
this->ExportSet = nullptr;
|
||||
}
|
||||
|
||||
void cmExportAndroidMKGenerator::GenerateImportHeaderCode(std::ostream& os,
|
||||
const std::string&)
|
||||
{
|
||||
os << "LOCAL_PATH := $(call my-dir)\n\n";
|
||||
}
|
||||
|
||||
void cmExportAndroidMKGenerator::GenerateImportFooterCode(std::ostream&)
|
||||
{
|
||||
}
|
||||
|
||||
void cmExportAndroidMKGenerator::GenerateExpectedTargetsCode(
|
||||
std::ostream&, const std::string&)
|
||||
{
|
||||
}
|
||||
|
||||
void cmExportAndroidMKGenerator::GenerateImportTargetCode(
|
||||
std::ostream& os, cmGeneratorTarget const* target,
|
||||
cmStateEnums::TargetType /*targetType*/)
|
||||
{
|
||||
std::string targetName = cmStrCat(this->Namespace, target->GetExportName());
|
||||
os << "include $(CLEAR_VARS)\n";
|
||||
os << "LOCAL_MODULE := ";
|
||||
os << targetName << "\n";
|
||||
os << "LOCAL_SRC_FILES := ";
|
||||
std::string const noConfig; // FIXME: What config to use here?
|
||||
std::string path =
|
||||
cmSystemTools::ConvertToOutputPath(target->GetFullPath(noConfig));
|
||||
os << path << "\n";
|
||||
}
|
||||
|
||||
void cmExportAndroidMKGenerator::GenerateImportPropertyCode(
|
||||
std::ostream&, const std::string&, const std::string&,
|
||||
cmGeneratorTarget const*, ImportPropertyMap const&, const std::string&)
|
||||
{
|
||||
}
|
||||
|
||||
void cmExportAndroidMKGenerator::GenerateMissingTargetsCheckCode(std::ostream&)
|
||||
{
|
||||
}
|
||||
|
||||
void cmExportAndroidMKGenerator::GenerateInterfaceProperties(
|
||||
const cmGeneratorTarget* target, std::ostream& os,
|
||||
const ImportPropertyMap& properties)
|
||||
{
|
||||
std::string config;
|
||||
if (!this->Configurations.empty()) {
|
||||
config = this->Configurations[0];
|
||||
}
|
||||
cmExportAndroidMKGenerator::GenerateInterfaceProperties(
|
||||
target, os, properties, cmExportAndroidMKGenerator::BUILD, config);
|
||||
}
|
||||
|
||||
void cmExportAndroidMKGenerator::GenerateInterfaceProperties(
|
||||
const cmGeneratorTarget* target, std::ostream& os,
|
||||
const ImportPropertyMap& properties, GenerateType type,
|
||||
std::string const& config)
|
||||
{
|
||||
const bool newCMP0022Behavior =
|
||||
target->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
|
||||
target->GetPolicyStatusCMP0022() != cmPolicies::OLD;
|
||||
if (!newCMP0022Behavior) {
|
||||
std::ostringstream w;
|
||||
if (type == cmExportAndroidMKGenerator::BUILD) {
|
||||
w << "export(TARGETS ... ANDROID_MK) called with policy CMP0022";
|
||||
} else {
|
||||
w << "install( EXPORT_ANDROID_MK ...) called with policy CMP0022";
|
||||
}
|
||||
w << " set to OLD for target " << target->Target->GetName() << ". "
|
||||
<< "The export will only work with CMP0022 set to NEW.";
|
||||
target->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, w.str());
|
||||
}
|
||||
if (!properties.empty()) {
|
||||
os << "LOCAL_CPP_FEATURES := rtti exceptions\n";
|
||||
for (auto const& property : properties) {
|
||||
if (property.first == "INTERFACE_COMPILE_OPTIONS") {
|
||||
os << "LOCAL_CPP_FEATURES += ";
|
||||
os << (property.second) << "\n";
|
||||
} else if (property.first == "INTERFACE_LINK_LIBRARIES") {
|
||||
std::string staticLibs;
|
||||
std::string sharedLibs;
|
||||
std::string ldlibs;
|
||||
cmLinkInterfaceLibraries const* linkIFace =
|
||||
target->GetLinkInterfaceLibraries(config, target,
|
||||
cmGeneratorTarget::UseTo::Link);
|
||||
for (cmLinkItem const& item : linkIFace->Libraries) {
|
||||
cmGeneratorTarget const* gt = item.Target;
|
||||
std::string const& lib = item.AsStr();
|
||||
if (gt) {
|
||||
|
||||
if (gt->GetType() == cmStateEnums::SHARED_LIBRARY ||
|
||||
gt->GetType() == cmStateEnums::MODULE_LIBRARY) {
|
||||
sharedLibs += " " + lib;
|
||||
} else {
|
||||
staticLibs += " " + lib;
|
||||
}
|
||||
} else {
|
||||
bool relpath = false;
|
||||
if (type == cmExportAndroidMKGenerator::INSTALL) {
|
||||
relpath = cmHasLiteralPrefix(lib, "../");
|
||||
}
|
||||
// check for full path or if it already has a -l, or
|
||||
// in the case of an install check for relative paths
|
||||
// if it is full or a link library then use string directly
|
||||
if (cmSystemTools::FileIsFullPath(lib) ||
|
||||
cmHasLiteralPrefix(lib, "-l") || relpath) {
|
||||
ldlibs += " " + lib;
|
||||
// if it is not a path and does not have a -l then add -l
|
||||
} else if (!lib.empty()) {
|
||||
ldlibs += " -l" + lib;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!sharedLibs.empty()) {
|
||||
os << "LOCAL_SHARED_LIBRARIES :=" << sharedLibs << "\n";
|
||||
}
|
||||
if (!staticLibs.empty()) {
|
||||
os << "LOCAL_STATIC_LIBRARIES :=" << staticLibs << "\n";
|
||||
}
|
||||
if (!ldlibs.empty()) {
|
||||
os << "LOCAL_EXPORT_LDLIBS :=" << ldlibs << "\n";
|
||||
}
|
||||
} else if (property.first == "INTERFACE_INCLUDE_DIRECTORIES") {
|
||||
std::string includes = property.second;
|
||||
cmList includeList{ includes };
|
||||
os << "LOCAL_EXPORT_C_INCLUDES := ";
|
||||
std::string end;
|
||||
for (std::string const& i : includeList) {
|
||||
os << end << i;
|
||||
end = "\\\n";
|
||||
}
|
||||
os << "\n";
|
||||
} else if (property.first == "INTERFACE_LINK_OPTIONS") {
|
||||
os << "LOCAL_EXPORT_LDFLAGS := ";
|
||||
cmList linkFlagsList{ property.second };
|
||||
os << linkFlagsList.join(" ") << "\n";
|
||||
} else {
|
||||
os << "# " << property.first << " " << (property.second) << "\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Tell the NDK build system if prebuilt static libraries use C++.
|
||||
if (target->GetType() == cmStateEnums::STATIC_LIBRARY) {
|
||||
cmLinkImplementation const* li =
|
||||
target->GetLinkImplementation(config, cmGeneratorTarget::UseTo::Link);
|
||||
if (cm::contains(li->Languages, "CXX")) {
|
||||
os << "LOCAL_HAS_CPP := true\n";
|
||||
}
|
||||
}
|
||||
|
||||
switch (target->GetType()) {
|
||||
case cmStateEnums::SHARED_LIBRARY:
|
||||
case cmStateEnums::MODULE_LIBRARY:
|
||||
os << "include $(PREBUILT_SHARED_LIBRARY)\n";
|
||||
break;
|
||||
case cmStateEnums::STATIC_LIBRARY:
|
||||
os << "include $(PREBUILT_STATIC_LIBRARY)\n";
|
||||
break;
|
||||
case cmStateEnums::EXECUTABLE:
|
||||
case cmStateEnums::UTILITY:
|
||||
case cmStateEnums::OBJECT_LIBRARY:
|
||||
case cmStateEnums::GLOBAL_TARGET:
|
||||
case cmStateEnums::INTERFACE_LIBRARY:
|
||||
case cmStateEnums::UNKNOWN_LIBRARY:
|
||||
break;
|
||||
}
|
||||
os << "\n";
|
||||
}
|
||||
62
Source/cmExportAndroidMKGenerator.h
Normal file
62
Source/cmExportAndroidMKGenerator.h
Normal file
@@ -0,0 +1,62 @@
|
||||
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
file Copyright.txt or https://cmake.org/licensing for details. */
|
||||
#pragma once
|
||||
|
||||
#include "cmConfigure.h" // IWYU pragma: keep
|
||||
|
||||
#include <iosfwd>
|
||||
#include <string>
|
||||
|
||||
#include "cmExportBuildFileGenerator.h"
|
||||
#include "cmStateTypes.h"
|
||||
|
||||
class cmGeneratorTarget;
|
||||
|
||||
/** \class cmExportAndroidMKGenerator
|
||||
* \brief Generate a file exporting targets from a build tree.
|
||||
*
|
||||
* cmExportAndroidMKGenerator generates a file exporting targets from
|
||||
* a build tree. This exports the targets to the Android ndk build tool
|
||||
* makefile format for prebuilt libraries.
|
||||
*
|
||||
* This is used to implement the export() command.
|
||||
*/
|
||||
class cmExportAndroidMKGenerator : public cmExportBuildFileGenerator
|
||||
{
|
||||
public:
|
||||
cmExportAndroidMKGenerator();
|
||||
// this is so cmExportInstallAndroidMKGenerator can share this
|
||||
// function as they are almost the same
|
||||
enum GenerateType
|
||||
{
|
||||
BUILD,
|
||||
INSTALL
|
||||
};
|
||||
static void GenerateInterfaceProperties(cmGeneratorTarget const* target,
|
||||
std::ostream& os,
|
||||
const ImportPropertyMap& properties,
|
||||
GenerateType type,
|
||||
std::string const& config);
|
||||
|
||||
protected:
|
||||
// Implement virtual methods from the superclass.
|
||||
void GeneratePolicyHeaderCode(std::ostream&) override {}
|
||||
void GeneratePolicyFooterCode(std::ostream&) override {}
|
||||
void GenerateImportHeaderCode(std::ostream& os,
|
||||
const std::string& config = "") override;
|
||||
void GenerateImportFooterCode(std::ostream& os) override;
|
||||
void GenerateImportTargetCode(
|
||||
std::ostream& os, cmGeneratorTarget const* target,
|
||||
cmStateEnums::TargetType /*targetType*/) override;
|
||||
void GenerateExpectedTargetsCode(
|
||||
std::ostream& os, const std::string& expectedTargets) override;
|
||||
void GenerateImportPropertyCode(
|
||||
std::ostream& os, const std::string& config, const std::string& suffix,
|
||||
cmGeneratorTarget const* target, ImportPropertyMap const& properties,
|
||||
const std::string& importedXcFrameworkLocation) override;
|
||||
void GenerateMissingTargetsCheckCode(std::ostream& os) override;
|
||||
void GenerateFindDependencyCalls(std::ostream&) override {}
|
||||
void GenerateInterfaceProperties(
|
||||
cmGeneratorTarget const* target, std::ostream& os,
|
||||
const ImportPropertyMap& properties) override;
|
||||
};
|
||||
602
Source/cmExportBuildCMakeConfigGenerator.cxx
Normal file
602
Source/cmExportBuildCMakeConfigGenerator.cxx
Normal file
@@ -0,0 +1,602 @@
|
||||
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
file Copyright.txt or https://cmake.org/licensing for details. */
|
||||
#include "cmExportBuildCMakeConfigGenerator.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;
|
||||
|
||||
cmExportBuildCMakeConfigGenerator::cmExportBuildCMakeConfigGenerator()
|
||||
{
|
||||
this->LG = nullptr;
|
||||
this->ExportSet = nullptr;
|
||||
}
|
||||
|
||||
void cmExportBuildCMakeConfigGenerator::Compute(cmLocalGenerator* lg)
|
||||
{
|
||||
this->LG = lg;
|
||||
if (this->ExportSet) {
|
||||
this->ExportSet->Compute(lg);
|
||||
}
|
||||
}
|
||||
|
||||
bool cmExportBuildCMakeConfigGenerator::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->PopulateCustomTransitiveInterfaceProperties(
|
||||
gte, cmGeneratorExpression::BuildInterface, 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 cmExportBuildCMakeConfigGenerator::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
|
||||
cmExportBuildCMakeConfigGenerator::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 cmExportBuildCMakeConfigGenerator::SetExportSet(cmExportSet* exportSet)
|
||||
{
|
||||
this->ExportSet = exportSet;
|
||||
}
|
||||
|
||||
void cmExportBuildCMakeConfigGenerator::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 cmExportBuildCMakeConfigGenerator::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 cmExportBuildCMakeConfigGenerator::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>
|
||||
cmExportBuildCMakeConfigGenerator::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 cmExportBuildCMakeConfigGenerator::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 cmExportBuildCMakeConfigGenerator::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 cmExportBuildCMakeConfigGenerator::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 cmExportBuildCMakeConfigGenerator::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 cmExportBuildCMakeConfigGenerator::GetCxxModulesDirectory() const
|
||||
{
|
||||
return this->CxxModulesDirectory;
|
||||
}
|
||||
|
||||
void cmExportBuildCMakeConfigGenerator::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 cmExportBuildCMakeConfigGenerator::
|
||||
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;
|
||||
}
|
||||
135
Source/cmExportBuildCMakeConfigGenerator.h
Normal file
135
Source/cmExportBuildCMakeConfigGenerator.h
Normal file
@@ -0,0 +1,135 @@
|
||||
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
file Copyright.txt or https://cmake.org/licensing for details. */
|
||||
#pragma once
|
||||
|
||||
#include "cmConfigure.h" // IWYU pragma: keep
|
||||
|
||||
#include <iosfwd>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include <cmext/algorithm>
|
||||
|
||||
#include "cmExportFileGenerator.h"
|
||||
#include "cmStateTypes.h"
|
||||
|
||||
class cmExportSet;
|
||||
class cmFileSet;
|
||||
class cmGeneratorTarget;
|
||||
class cmGlobalGenerator;
|
||||
class cmLocalGenerator;
|
||||
class cmTargetExport;
|
||||
|
||||
/** \class cmExportBuildCMakeConfigGenerator
|
||||
* \brief Generate a file exporting targets from a build tree.
|
||||
*
|
||||
* cmExportBuildCMakeConfigGenerator generates a file exporting targets from
|
||||
* a build tree. A single file exports information for all
|
||||
* configurations built.
|
||||
*
|
||||
* This is used to implement the export() command.
|
||||
*/
|
||||
class cmExportBuildCMakeConfigGenerator : public cmExportFileGenerator
|
||||
{
|
||||
public:
|
||||
struct TargetExport
|
||||
{
|
||||
TargetExport(std::string name, std::string xcFrameworkLocation)
|
||||
: Name(std::move(name))
|
||||
, XcFrameworkLocation(std::move(xcFrameworkLocation))
|
||||
{
|
||||
}
|
||||
|
||||
std::string Name;
|
||||
std::string XcFrameworkLocation;
|
||||
};
|
||||
|
||||
cmExportBuildCMakeConfigGenerator();
|
||||
|
||||
/** Set the list of targets to export. */
|
||||
void SetTargets(std::vector<TargetExport> const& targets)
|
||||
{
|
||||
this->Targets = targets;
|
||||
}
|
||||
void GetTargets(std::vector<TargetExport>& targets) const;
|
||||
void AppendTargets(std::vector<TargetExport> const& targets)
|
||||
{
|
||||
cm::append(this->Targets, targets);
|
||||
}
|
||||
void SetExportSet(cmExportSet*);
|
||||
|
||||
/** Set the name of the C++ module directory. */
|
||||
void SetCxxModuleDirectory(std::string cxx_module_dir)
|
||||
{
|
||||
this->CxxModulesDirectory = std::move(cxx_module_dir);
|
||||
}
|
||||
const std::string& GetCxxModuleDirectory() const
|
||||
{
|
||||
return this->CxxModulesDirectory;
|
||||
}
|
||||
|
||||
/** Set whether to append generated code to the output file. */
|
||||
void SetAppendMode(bool append) { this->AppendMode = append; }
|
||||
|
||||
void Compute(cmLocalGenerator* lg);
|
||||
|
||||
protected:
|
||||
// Implement virtual methods from the superclass.
|
||||
bool GenerateMainFile(std::ostream& os) override;
|
||||
void GenerateImportTargetsConfig(std::ostream& os, const std::string& config,
|
||||
std::string const& suffix) override;
|
||||
cmStateEnums::TargetType GetExportTargetType(
|
||||
cmGeneratorTarget const* target) const;
|
||||
void HandleMissingTarget(std::string& link_libs,
|
||||
cmGeneratorTarget const* depender,
|
||||
cmGeneratorTarget* dependee) override;
|
||||
|
||||
void ComplainAboutMissingTarget(cmGeneratorTarget const* depender,
|
||||
cmGeneratorTarget const* dependee,
|
||||
std::vector<std::string> const& namespaces);
|
||||
|
||||
/** Fill in properties indicating built file locations. */
|
||||
void SetImportLocationProperty(const std::string& config,
|
||||
std::string const& suffix,
|
||||
cmGeneratorTarget* target,
|
||||
ImportPropertyMap& properties);
|
||||
|
||||
std::string InstallNameDir(cmGeneratorTarget const* target,
|
||||
const std::string& config) override;
|
||||
|
||||
std::string GetFileSetDirectories(cmGeneratorTarget* gte, cmFileSet* fileSet,
|
||||
cmTargetExport* te) override;
|
||||
std::string GetFileSetFiles(cmGeneratorTarget* gte, cmFileSet* fileSet,
|
||||
cmTargetExport* te) override;
|
||||
cmExportSet* GetExportSet() const override { return this->ExportSet; }
|
||||
|
||||
std::string GetCxxModulesDirectory() const override;
|
||||
void GenerateCxxModuleConfigInformation(std::string const&,
|
||||
std::ostream&) const override;
|
||||
bool GenerateImportCxxModuleConfigTargetInclusion(std::string const&,
|
||||
std::string) const;
|
||||
|
||||
std::pair<std::vector<std::string>, std::string> FindBuildExportInfo(
|
||||
cmGlobalGenerator* gg, const std::string& name);
|
||||
|
||||
struct TargetExportPrivate
|
||||
{
|
||||
TargetExportPrivate(cmGeneratorTarget* target,
|
||||
std::string xcFrameworkLocation)
|
||||
: Target(target)
|
||||
, XcFrameworkLocation(std::move(xcFrameworkLocation))
|
||||
{
|
||||
}
|
||||
|
||||
cmGeneratorTarget* Target;
|
||||
std::string XcFrameworkLocation;
|
||||
};
|
||||
|
||||
std::vector<TargetExport> Targets;
|
||||
cmExportSet* ExportSet;
|
||||
std::vector<TargetExportPrivate> Exports;
|
||||
cmLocalGenerator* LG;
|
||||
// The directory for C++ module information.
|
||||
std::string CxxModulesDirectory;
|
||||
};
|
||||
1683
Source/cmExportCMakeConfigGenerator.cxx
Normal file
1683
Source/cmExportCMakeConfigGenerator.cxx
Normal file
File diff suppressed because it is too large
Load Diff
264
Source/cmExportCMakeConfigGenerator.h
Normal file
264
Source/cmExportCMakeConfigGenerator.h
Normal file
@@ -0,0 +1,264 @@
|
||||
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
file Copyright.txt or https://cmake.org/licensing for details. */
|
||||
#pragma once
|
||||
|
||||
#include "cmConfigure.h" // IWYU pragma: keep
|
||||
|
||||
#include <iosfwd>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "cmGeneratorExpression.h"
|
||||
#include "cmStateTypes.h"
|
||||
#include "cmVersion.h"
|
||||
#include "cmVersionConfig.h"
|
||||
|
||||
class cmExportSet;
|
||||
class cmFileSet;
|
||||
class cmGeneratorTarget;
|
||||
class cmLocalGenerator;
|
||||
class cmTargetExport;
|
||||
|
||||
#define STRINGIFY_HELPER(X) #X
|
||||
#define STRINGIFY(X) STRINGIFY_HELPER(X)
|
||||
|
||||
#define DEVEL_CMAKE_VERSION(major, minor) \
|
||||
(CMake_VERSION_ENCODE(major, minor, 0) > \
|
||||
CMake_VERSION_ENCODE(CMake_VERSION_MAJOR, CMake_VERSION_MINOR, 0) \
|
||||
? STRINGIFY(CMake_VERSION_MAJOR) "." STRINGIFY( \
|
||||
CMake_VERSION_MINOR) "." STRINGIFY(CMake_VERSION_PATCH) \
|
||||
: #major "." #minor ".0")
|
||||
|
||||
/** \class cmExportCMakeConfigGenerator
|
||||
* \brief Generate a file exporting targets from a build or install tree.
|
||||
*
|
||||
* cmExportCMakeConfigGenerator is the superclass for
|
||||
* cmExportBuildFileGenerator and cmExportInstallFileGenerator. It
|
||||
* contains common code generation routines for the two kinds of
|
||||
* export implementations.
|
||||
*/
|
||||
class cmExportCMakeConfigGenerator
|
||||
{
|
||||
public:
|
||||
cmExportCMakeConfigGenerator();
|
||||
virtual ~cmExportCMakeConfigGenerator() = default;
|
||||
|
||||
/** Set the full path to the export file to generate. */
|
||||
void SetExportFile(const char* mainFile);
|
||||
const std::string& GetMainExportFileName() const;
|
||||
|
||||
/** Set the namespace in which to place exported target names. */
|
||||
void SetNamespace(const std::string& ns) { this->Namespace = ns; }
|
||||
std::string GetNamespace() const { return this->Namespace; }
|
||||
|
||||
void SetExportOld(bool exportOld) { this->ExportOld = exportOld; }
|
||||
|
||||
/** Add a configuration to be exported. */
|
||||
void AddConfiguration(const std::string& config);
|
||||
|
||||
/** Actually generate the export file. Returns whether there was an
|
||||
error. */
|
||||
bool GenerateImportFile();
|
||||
|
||||
void SetExportPackageDependencies(bool exportPackageDependencies)
|
||||
{
|
||||
this->ExportPackageDependencies = exportPackageDependencies;
|
||||
}
|
||||
|
||||
protected:
|
||||
using ImportPropertyMap = std::map<std::string, std::string>;
|
||||
|
||||
// Generate per-configuration target information to the given output
|
||||
// stream.
|
||||
void GenerateImportConfig(std::ostream& os, const std::string& config);
|
||||
|
||||
// Methods to implement export file code generation.
|
||||
virtual void GeneratePolicyHeaderCode(std::ostream& os);
|
||||
virtual void GeneratePolicyFooterCode(std::ostream& os);
|
||||
virtual void GenerateImportHeaderCode(std::ostream& os,
|
||||
const std::string& config = "");
|
||||
virtual void GenerateImportFooterCode(std::ostream& os);
|
||||
void GenerateImportVersionCode(std::ostream& os);
|
||||
virtual void GenerateImportTargetCode(std::ostream& os,
|
||||
cmGeneratorTarget const* target,
|
||||
cmStateEnums::TargetType targetType);
|
||||
virtual void GenerateImportPropertyCode(
|
||||
std::ostream& os, const std::string& config, const std::string& suffix,
|
||||
cmGeneratorTarget const* target, ImportPropertyMap const& properties,
|
||||
const std::string& importedXcFrameworkLocation);
|
||||
virtual void GenerateImportedFileChecksCode(
|
||||
std::ostream& os, cmGeneratorTarget* target,
|
||||
ImportPropertyMap const& properties,
|
||||
const std::set<std::string>& importedLocations,
|
||||
const std::string& importedXcFrameworkLocation);
|
||||
virtual void GenerateImportedFileCheckLoop(std::ostream& os);
|
||||
virtual void GenerateMissingTargetsCheckCode(std::ostream& os);
|
||||
virtual void GenerateFindDependencyCalls(std::ostream& os);
|
||||
|
||||
virtual void GenerateExpectedTargetsCode(std::ostream& os,
|
||||
const std::string& expectedTargets);
|
||||
|
||||
// Collect properties with detailed information about targets beyond
|
||||
// their location on disk.
|
||||
void SetImportDetailProperties(const std::string& config,
|
||||
std::string const& suffix,
|
||||
cmGeneratorTarget* target,
|
||||
ImportPropertyMap& properties);
|
||||
|
||||
enum class ImportLinkPropertyTargetNames
|
||||
{
|
||||
Yes,
|
||||
No,
|
||||
};
|
||||
template <typename T>
|
||||
void SetImportLinkProperty(std::string const& suffix,
|
||||
cmGeneratorTarget const* target,
|
||||
const std::string& propName,
|
||||
std::vector<T> const& entries,
|
||||
ImportPropertyMap& properties,
|
||||
ImportLinkPropertyTargetNames targetNames);
|
||||
|
||||
/** Each subclass knows how to generate its kind of export file. */
|
||||
virtual bool GenerateMainFile(std::ostream& os) = 0;
|
||||
|
||||
/** Each subclass knows where the target files are located. */
|
||||
virtual void GenerateImportTargetsConfig(std::ostream& os,
|
||||
const std::string& config,
|
||||
std::string const& suffix) = 0;
|
||||
|
||||
/** Each subclass knows how to deal with a target that is missing from an
|
||||
* export set. */
|
||||
virtual void HandleMissingTarget(std::string& link_libs,
|
||||
cmGeneratorTarget const* depender,
|
||||
cmGeneratorTarget* dependee) = 0;
|
||||
void PopulateInterfaceProperty(const std::string&,
|
||||
cmGeneratorTarget const* target,
|
||||
cmGeneratorExpression::PreprocessContext,
|
||||
ImportPropertyMap& properties);
|
||||
bool PopulateInterfaceLinkLibrariesProperty(
|
||||
cmGeneratorTarget const* target, cmGeneratorExpression::PreprocessContext,
|
||||
ImportPropertyMap& properties);
|
||||
void PopulateInterfaceProperty(const std::string& propName,
|
||||
cmGeneratorTarget const* target,
|
||||
ImportPropertyMap& properties);
|
||||
void PopulateCompatibleInterfaceProperties(cmGeneratorTarget const* target,
|
||||
ImportPropertyMap& properties);
|
||||
void PopulateCustomTransitiveInterfaceProperties(
|
||||
cmGeneratorTarget const* target,
|
||||
cmGeneratorExpression::PreprocessContext preprocessRule,
|
||||
ImportPropertyMap& properties);
|
||||
virtual void GenerateInterfaceProperties(
|
||||
cmGeneratorTarget const* target, std::ostream& os,
|
||||
const ImportPropertyMap& properties);
|
||||
void PopulateIncludeDirectoriesInterface(
|
||||
cmGeneratorTarget const* target,
|
||||
cmGeneratorExpression::PreprocessContext preprocessRule,
|
||||
ImportPropertyMap& properties, cmTargetExport const& te,
|
||||
std::string& includesDestinationDirs);
|
||||
void PopulateSourcesInterface(
|
||||
cmGeneratorTarget const* target,
|
||||
cmGeneratorExpression::PreprocessContext preprocessRule,
|
||||
ImportPropertyMap& properties);
|
||||
void PopulateLinkDirectoriesInterface(
|
||||
cmGeneratorTarget const* target,
|
||||
cmGeneratorExpression::PreprocessContext preprocessRule,
|
||||
ImportPropertyMap& properties);
|
||||
void PopulateLinkDependsInterface(
|
||||
cmGeneratorTarget const* target,
|
||||
cmGeneratorExpression::PreprocessContext preprocessRule,
|
||||
ImportPropertyMap& properties);
|
||||
|
||||
void SetImportLinkInterface(
|
||||
const std::string& config, std::string const& suffix,
|
||||
cmGeneratorExpression::PreprocessContext preprocessRule,
|
||||
cmGeneratorTarget const* target, ImportPropertyMap& properties);
|
||||
|
||||
enum FreeTargetsReplace
|
||||
{
|
||||
ReplaceFreeTargets,
|
||||
NoReplaceFreeTargets
|
||||
};
|
||||
|
||||
void ResolveTargetsInGeneratorExpressions(
|
||||
std::string& input, cmGeneratorTarget const* target,
|
||||
FreeTargetsReplace replace = NoReplaceFreeTargets);
|
||||
|
||||
bool PopulateCxxModuleExportProperties(
|
||||
cmGeneratorTarget const* gte, ImportPropertyMap& properties,
|
||||
cmGeneratorExpression::PreprocessContext ctx,
|
||||
std::string const& includesDestinationDirs, std::string& errorMessage);
|
||||
bool PopulateExportProperties(cmGeneratorTarget const* gte,
|
||||
ImportPropertyMap& properties,
|
||||
std::string& errorMessage);
|
||||
|
||||
void GenerateTargetFileSets(cmGeneratorTarget* gte, std::ostream& os,
|
||||
cmTargetExport* te = nullptr);
|
||||
|
||||
void GenerateCxxModuleInformation(std::string const& name, std::ostream& os);
|
||||
|
||||
virtual std::string GetFileSetDirectories(cmGeneratorTarget* gte,
|
||||
cmFileSet* fileSet,
|
||||
cmTargetExport* te) = 0;
|
||||
virtual std::string GetFileSetFiles(cmGeneratorTarget* gte,
|
||||
cmFileSet* fileSet,
|
||||
cmTargetExport* te) = 0;
|
||||
|
||||
virtual cmExportSet* GetExportSet() const { return nullptr; }
|
||||
|
||||
std::string GetCxxModuleFile(std::string const& name) const;
|
||||
|
||||
void SetRequiredCMakeVersion(unsigned int major, unsigned int minor,
|
||||
unsigned int patch);
|
||||
|
||||
// The namespace in which the exports are placed in the generated file.
|
||||
std::string Namespace;
|
||||
|
||||
bool ExportOld;
|
||||
|
||||
// The set of configurations to export.
|
||||
std::vector<std::string> Configurations;
|
||||
|
||||
// The file to generate.
|
||||
std::string MainImportFile;
|
||||
std::string FileDir;
|
||||
std::string FileBase;
|
||||
std::string FileExt;
|
||||
bool AppendMode;
|
||||
|
||||
// The set of targets included in the export.
|
||||
std::set<cmGeneratorTarget*> ExportedTargets;
|
||||
|
||||
std::vector<std::string> MissingTargets;
|
||||
|
||||
std::set<cmGeneratorTarget const*> ExternalTargets;
|
||||
|
||||
unsigned int RequiredCMakeVersionMajor = 2;
|
||||
unsigned int RequiredCMakeVersionMinor = 8;
|
||||
unsigned int RequiredCMakeVersionPatch = 3;
|
||||
|
||||
bool ExportPackageDependencies = false;
|
||||
|
||||
private:
|
||||
void PopulateInterfaceProperty(const std::string&, const std::string&,
|
||||
cmGeneratorTarget const* target,
|
||||
cmGeneratorExpression::PreprocessContext,
|
||||
ImportPropertyMap& properties);
|
||||
|
||||
bool AddTargetNamespace(std::string& input, cmGeneratorTarget const* target,
|
||||
cmLocalGenerator const* lg);
|
||||
|
||||
void ResolveTargetsInGeneratorExpression(std::string& input,
|
||||
cmGeneratorTarget const* target,
|
||||
cmLocalGenerator const* lg);
|
||||
|
||||
virtual void ReplaceInstallPrefix(std::string& input);
|
||||
|
||||
virtual std::string InstallNameDir(cmGeneratorTarget const* target,
|
||||
const std::string& config) = 0;
|
||||
|
||||
virtual std::string GetCxxModulesDirectory() const = 0;
|
||||
virtual void GenerateCxxModuleConfigInformation(std::string const&,
|
||||
std::ostream& os) const = 0;
|
||||
};
|
||||
800
Source/cmExportInstallCMakeConfigGenerator.cxx
Normal file
800
Source/cmExportInstallCMakeConfigGenerator.cxx
Normal file
@@ -0,0 +1,800 @@
|
||||
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
file Copyright.txt or https://cmake.org/licensing for details. */
|
||||
#include "cmExportInstallCMakeConfigGenerator.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <memory>
|
||||
#include <sstream>
|
||||
#include <utility>
|
||||
|
||||
#include <cm/string_view>
|
||||
#include <cmext/string_view>
|
||||
|
||||
#include "cmExportSet.h"
|
||||
#include "cmFileSet.h"
|
||||
#include "cmGeneratedFileStream.h"
|
||||
#include "cmGeneratorExpression.h"
|
||||
#include "cmGeneratorTarget.h"
|
||||
#include "cmGlobalGenerator.h"
|
||||
#include "cmInstallExportGenerator.h"
|
||||
#include "cmInstallFileSetGenerator.h"
|
||||
#include "cmInstallTargetGenerator.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"
|
||||
|
||||
cmExportInstallCMakeConfigGenerator::cmExportInstallCMakeConfigGenerator(
|
||||
cmInstallExportGenerator* iegen)
|
||||
: IEGen(iegen)
|
||||
{
|
||||
}
|
||||
|
||||
std::string cmExportInstallCMakeConfigGenerator::GetConfigImportFileGlob()
|
||||
{
|
||||
std::string glob = cmStrCat(this->FileBase, "-*", this->FileExt);
|
||||
return glob;
|
||||
}
|
||||
|
||||
bool cmExportInstallCMakeConfigGenerator::GenerateMainFile(std::ostream& os)
|
||||
{
|
||||
std::vector<cmTargetExport*> allTargets;
|
||||
{
|
||||
std::string expectedTargets;
|
||||
std::string sep;
|
||||
for (std::unique_ptr<cmTargetExport> const& te :
|
||||
this->GetExportSet()->GetTargetExports()) {
|
||||
if (te->NamelinkOnly) {
|
||||
continue;
|
||||
}
|
||||
expectedTargets += sep + this->Namespace + te->Target->GetExportName();
|
||||
sep = " ";
|
||||
if (this->ExportedTargets.insert(te->Target).second) {
|
||||
allTargets.push_back(te.get());
|
||||
} else {
|
||||
std::ostringstream e;
|
||||
e << "install(EXPORT \"" << this->GetExportSet()->GetName()
|
||||
<< "\" ...) "
|
||||
<< "includes target \"" << te->Target->GetName()
|
||||
<< "\" more than once in the export set.";
|
||||
cmSystemTools::Error(e.str());
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
this->GenerateExpectedTargetsCode(os, expectedTargets);
|
||||
}
|
||||
|
||||
// Compute the relative import prefix for the file
|
||||
this->GenerateImportPrefix(os);
|
||||
|
||||
bool requiresConfigFiles = false;
|
||||
// Create all the imported targets.
|
||||
for (cmTargetExport* te : allTargets) {
|
||||
cmGeneratorTarget* gt = te->Target;
|
||||
cmStateEnums::TargetType targetType = this->GetExportTargetType(te);
|
||||
|
||||
requiresConfigFiles =
|
||||
requiresConfigFiles || targetType != cmStateEnums::INTERFACE_LIBRARY;
|
||||
|
||||
this->GenerateImportTargetCode(os, gt, targetType);
|
||||
|
||||
ImportPropertyMap properties;
|
||||
|
||||
std::string includesDestinationDirs;
|
||||
this->PopulateIncludeDirectoriesInterface(
|
||||
gt, cmGeneratorExpression::InstallInterface, properties, *te,
|
||||
includesDestinationDirs);
|
||||
this->PopulateSourcesInterface(gt, cmGeneratorExpression::InstallInterface,
|
||||
properties);
|
||||
this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", gt,
|
||||
cmGeneratorExpression::InstallInterface,
|
||||
properties);
|
||||
this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", gt,
|
||||
cmGeneratorExpression::InstallInterface,
|
||||
properties);
|
||||
this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", gt,
|
||||
cmGeneratorExpression::InstallInterface,
|
||||
properties);
|
||||
this->PopulateInterfaceProperty("INTERFACE_PRECOMPILE_HEADERS", gt,
|
||||
cmGeneratorExpression::InstallInterface,
|
||||
properties);
|
||||
this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", gt,
|
||||
cmGeneratorExpression::InstallInterface,
|
||||
properties);
|
||||
this->PopulateInterfaceProperty("INTERFACE_AUTOMOC_MACRO_NAMES", gt,
|
||||
cmGeneratorExpression::InstallInterface,
|
||||
properties);
|
||||
this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gt,
|
||||
cmGeneratorExpression::InstallInterface,
|
||||
properties);
|
||||
this->PopulateInterfaceProperty("INTERFACE_LINK_OPTIONS", gt,
|
||||
cmGeneratorExpression::InstallInterface,
|
||||
properties);
|
||||
this->PopulateLinkDirectoriesInterface(
|
||||
gt, cmGeneratorExpression::InstallInterface, properties);
|
||||
this->PopulateLinkDependsInterface(
|
||||
gt, cmGeneratorExpression::InstallInterface, properties);
|
||||
|
||||
std::string errorMessage;
|
||||
if (!this->PopulateCxxModuleExportProperties(
|
||||
gt, properties, cmGeneratorExpression::InstallInterface,
|
||||
includesDestinationDirs, errorMessage)) {
|
||||
cmSystemTools::Error(errorMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!this->PopulateExportProperties(gt, properties, errorMessage)) {
|
||||
cmSystemTools::Error(errorMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
const bool newCMP0022Behavior =
|
||||
gt->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
|
||||
gt->GetPolicyStatusCMP0022() != cmPolicies::OLD;
|
||||
if (newCMP0022Behavior) {
|
||||
if (this->PopulateInterfaceLinkLibrariesProperty(
|
||||
gt, cmGeneratorExpression::InstallInterface, properties) &&
|
||||
!this->ExportOld) {
|
||||
this->SetRequiredCMakeVersion(2, 8, 12);
|
||||
}
|
||||
}
|
||||
if (targetType == cmStateEnums::INTERFACE_LIBRARY) {
|
||||
this->SetRequiredCMakeVersion(3, 0, 0);
|
||||
}
|
||||
if (gt->GetProperty("INTERFACE_SOURCES")) {
|
||||
// We can only generate INTERFACE_SOURCES in CMake 3.3, but CMake 3.1
|
||||
// can consume them.
|
||||
this->SetRequiredCMakeVersion(3, 1, 0);
|
||||
}
|
||||
|
||||
this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", gt,
|
||||
properties);
|
||||
|
||||
this->PopulateCompatibleInterfaceProperties(gt, properties);
|
||||
this->PopulateCustomTransitiveInterfaceProperties(
|
||||
gt, cmGeneratorExpression::InstallInterface, properties);
|
||||
|
||||
this->GenerateInterfaceProperties(gt, os, properties);
|
||||
|
||||
this->GenerateTargetFileSets(gt, os, te);
|
||||
}
|
||||
|
||||
this->LoadConfigFiles(os);
|
||||
|
||||
bool result = true;
|
||||
|
||||
std::string cxx_modules_name = this->GetExportSet()->GetName();
|
||||
this->GenerateCxxModuleInformation(cxx_modules_name, os);
|
||||
if (requiresConfigFiles) {
|
||||
for (std::string const& c : this->Configurations) {
|
||||
if (!this->GenerateImportCxxModuleConfigTargetInclusion(cxx_modules_name,
|
||||
c)) {
|
||||
result = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this->CleanupTemporaryVariables(os);
|
||||
this->GenerateImportedFileCheckLoop(os);
|
||||
|
||||
// Generate an import file for each configuration.
|
||||
// Don't do this if we only export INTERFACE_LIBRARY targets.
|
||||
if (requiresConfigFiles) {
|
||||
for (std::string const& c : this->Configurations) {
|
||||
if (!this->GenerateImportFileConfig(c)) {
|
||||
result = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this->GenerateMissingTargetsCheckCode(os);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void cmExportInstallCMakeConfigGenerator::GenerateImportPrefix(
|
||||
std::ostream& os)
|
||||
{
|
||||
// Set an _IMPORT_PREFIX variable for import location properties
|
||||
// to reference if they are relative to the install prefix.
|
||||
std::string installPrefix =
|
||||
this->IEGen->GetLocalGenerator()->GetMakefile()->GetSafeDefinition(
|
||||
"CMAKE_INSTALL_PREFIX");
|
||||
std::string const& expDest = this->IEGen->GetDestination();
|
||||
if (cmSystemTools::FileIsFullPath(expDest)) {
|
||||
// The export file is being installed to an absolute path so the
|
||||
// package is not relocatable. Use the configured install prefix.
|
||||
/* clang-format off */
|
||||
os <<
|
||||
"# The installation prefix configured by this project.\n"
|
||||
"set(_IMPORT_PREFIX \"" << installPrefix << "\")\n"
|
||||
"\n";
|
||||
/* clang-format on */
|
||||
} else {
|
||||
// Add code to compute the installation prefix relative to the
|
||||
// import file location.
|
||||
std::string absDest = installPrefix + "/" + expDest;
|
||||
std::string absDestS = absDest + "/";
|
||||
os << "# Compute the installation prefix relative to this file.\n"
|
||||
<< "get_filename_component(_IMPORT_PREFIX"
|
||||
<< " \"${CMAKE_CURRENT_LIST_FILE}\" PATH)\n";
|
||||
if (cmHasLiteralPrefix(absDestS, "/lib/") ||
|
||||
cmHasLiteralPrefix(absDestS, "/lib64/") ||
|
||||
cmHasLiteralPrefix(absDestS, "/libx32/") ||
|
||||
cmHasLiteralPrefix(absDestS, "/usr/lib/") ||
|
||||
cmHasLiteralPrefix(absDestS, "/usr/lib64/") ||
|
||||
cmHasLiteralPrefix(absDestS, "/usr/libx32/")) {
|
||||
// Handle "/usr move" symlinks created by some Linux distros.
|
||||
/* clang-format off */
|
||||
os <<
|
||||
"# Use original install prefix when loaded through a\n"
|
||||
"# cross-prefix symbolic link such as /lib -> /usr/lib.\n"
|
||||
"get_filename_component(_realCurr \"${_IMPORT_PREFIX}\" REALPATH)\n"
|
||||
"get_filename_component(_realOrig \"" << absDest << "\" REALPATH)\n"
|
||||
"if(_realCurr STREQUAL _realOrig)\n"
|
||||
" set(_IMPORT_PREFIX \"" << absDest << "\")\n"
|
||||
"endif()\n"
|
||||
"unset(_realOrig)\n"
|
||||
"unset(_realCurr)\n";
|
||||
/* clang-format on */
|
||||
}
|
||||
std::string dest = expDest;
|
||||
while (!dest.empty()) {
|
||||
os << "get_filename_component(_IMPORT_PREFIX \"${_IMPORT_PREFIX}\" "
|
||||
"PATH)\n";
|
||||
dest = cmSystemTools::GetFilenamePath(dest);
|
||||
}
|
||||
os << "if(_IMPORT_PREFIX STREQUAL \"/\")\n"
|
||||
<< " set(_IMPORT_PREFIX \"\")\n"
|
||||
<< "endif()\n"
|
||||
<< "\n";
|
||||
}
|
||||
}
|
||||
|
||||
void cmExportInstallCMakeConfigGenerator::CleanupTemporaryVariables(
|
||||
std::ostream& os)
|
||||
{
|
||||
/* clang-format off */
|
||||
os << "# Cleanup temporary variables.\n"
|
||||
<< "set(_IMPORT_PREFIX)\n"
|
||||
<< "\n";
|
||||
/* clang-format on */
|
||||
}
|
||||
|
||||
void cmExportInstallCMakeConfigGenerator::LoadConfigFiles(std::ostream& os)
|
||||
{
|
||||
// Now load per-configuration properties for them.
|
||||
/* clang-format off */
|
||||
os << "# Load information for each installed configuration.\n"
|
||||
<< "file(GLOB _cmake_config_files \"${CMAKE_CURRENT_LIST_DIR}/"
|
||||
<< this->GetConfigImportFileGlob() << "\")\n"
|
||||
<< "foreach(_cmake_config_file IN LISTS _cmake_config_files)\n"
|
||||
<< " include(\"${_cmake_config_file}\")\n"
|
||||
<< "endforeach()\n"
|
||||
<< "unset(_cmake_config_file)\n"
|
||||
<< "unset(_cmake_config_files)\n"
|
||||
<< "\n";
|
||||
/* clang-format on */
|
||||
}
|
||||
|
||||
void cmExportInstallCMakeConfigGenerator::ReplaceInstallPrefix(
|
||||
std::string& input)
|
||||
{
|
||||
cmGeneratorExpression::ReplaceInstallPrefix(input, "${_IMPORT_PREFIX}");
|
||||
}
|
||||
|
||||
bool cmExportInstallCMakeConfigGenerator::GenerateImportFileConfig(
|
||||
const std::string& config)
|
||||
{
|
||||
// Skip configurations not enabled for this export.
|
||||
if (!this->IEGen->InstallsForConfig(config)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Construct the name of the file to generate.
|
||||
std::string fileName = cmStrCat(this->FileDir, '/', this->FileBase, '-');
|
||||
if (!config.empty()) {
|
||||
fileName += cmSystemTools::LowerCase(config);
|
||||
} else {
|
||||
fileName += "noconfig";
|
||||
}
|
||||
fileName += this->FileExt;
|
||||
|
||||
// Open the output file to generate it.
|
||||
cmGeneratedFileStream exportFileStream(fileName, true);
|
||||
if (!exportFileStream) {
|
||||
std::string se = cmSystemTools::GetLastSystemError();
|
||||
std::ostringstream e;
|
||||
e << "cannot write to file \"" << fileName << "\": " << se;
|
||||
cmSystemTools::Error(e.str());
|
||||
return false;
|
||||
}
|
||||
exportFileStream.SetCopyIfDifferent(true);
|
||||
std::ostream& os = exportFileStream;
|
||||
|
||||
// Start with the import file header.
|
||||
this->GenerateImportHeaderCode(os, config);
|
||||
|
||||
// Generate the per-config target information.
|
||||
this->GenerateImportConfig(os, config);
|
||||
|
||||
// End with the import file footer.
|
||||
this->GenerateImportFooterCode(os);
|
||||
|
||||
// Record this per-config import file.
|
||||
this->ConfigImportFiles[config] = fileName;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void cmExportInstallCMakeConfigGenerator::GenerateImportTargetsConfig(
|
||||
std::ostream& os, const std::string& config, std::string const& suffix)
|
||||
{
|
||||
// Add each target in the set to the export.
|
||||
for (std::unique_ptr<cmTargetExport> const& te :
|
||||
this->GetExportSet()->GetTargetExports()) {
|
||||
// Collect import properties for this target.
|
||||
if (this->GetExportTargetType(te.get()) ==
|
||||
cmStateEnums::INTERFACE_LIBRARY) {
|
||||
continue;
|
||||
}
|
||||
|
||||
ImportPropertyMap properties;
|
||||
std::set<std::string> importedLocations;
|
||||
|
||||
this->SetImportLocationProperty(config, suffix, te->ArchiveGenerator,
|
||||
properties, importedLocations);
|
||||
this->SetImportLocationProperty(config, suffix, te->LibraryGenerator,
|
||||
properties, importedLocations);
|
||||
this->SetImportLocationProperty(config, suffix, te->RuntimeGenerator,
|
||||
properties, importedLocations);
|
||||
this->SetImportLocationProperty(config, suffix, te->ObjectsGenerator,
|
||||
properties, importedLocations);
|
||||
this->SetImportLocationProperty(config, suffix, te->FrameworkGenerator,
|
||||
properties, importedLocations);
|
||||
this->SetImportLocationProperty(config, suffix, te->BundleGenerator,
|
||||
properties, importedLocations);
|
||||
|
||||
// If any file location was set for the target add it to the
|
||||
// import file.
|
||||
if (!properties.empty()) {
|
||||
// Get the rest of the target details.
|
||||
cmGeneratorTarget* gtgt = te->Target;
|
||||
this->SetImportDetailProperties(config, suffix, gtgt, properties);
|
||||
|
||||
this->SetImportLinkInterface(config, suffix,
|
||||
cmGeneratorExpression::InstallInterface,
|
||||
gtgt, 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 = te->XcFrameworkLocation;
|
||||
if (!importedXcFrameworkLocation.empty()) {
|
||||
importedXcFrameworkLocation = cmGeneratorExpression::Preprocess(
|
||||
importedXcFrameworkLocation,
|
||||
cmGeneratorExpression::PreprocessContext::InstallInterface, true);
|
||||
importedXcFrameworkLocation = cmGeneratorExpression::Evaluate(
|
||||
importedXcFrameworkLocation, te->Target->GetLocalGenerator(), config,
|
||||
te->Target, nullptr, te->Target);
|
||||
if (!importedXcFrameworkLocation.empty() &&
|
||||
!cmSystemTools::FileIsFullPath(importedXcFrameworkLocation) &&
|
||||
!cmHasLiteralPrefix(importedXcFrameworkLocation,
|
||||
"${_IMPORT_PREFIX}/")) {
|
||||
importedXcFrameworkLocation =
|
||||
cmStrCat("${_IMPORT_PREFIX}/", importedXcFrameworkLocation);
|
||||
}
|
||||
}
|
||||
this->GenerateImportPropertyCode(os, config, suffix, gtgt, properties,
|
||||
importedXcFrameworkLocation);
|
||||
this->GenerateImportedFileChecksCode(
|
||||
os, gtgt, properties, importedLocations, importedXcFrameworkLocation);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void cmExportInstallCMakeConfigGenerator::SetImportLocationProperty(
|
||||
const std::string& config, std::string const& suffix,
|
||||
cmInstallTargetGenerator* itgen, ImportPropertyMap& properties,
|
||||
std::set<std::string>& importedLocations)
|
||||
{
|
||||
// Skip rules that do not match this configuration.
|
||||
if (!(itgen && itgen->InstallsForConfig(config))) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Get the target to be installed.
|
||||
cmGeneratorTarget* target = itgen->GetTarget();
|
||||
|
||||
// Construct the installed location of the target.
|
||||
std::string dest = itgen->GetDestination(config);
|
||||
std::string value;
|
||||
if (!cmSystemTools::FileIsFullPath(dest)) {
|
||||
// The target is installed relative to the installation prefix.
|
||||
value = "${_IMPORT_PREFIX}/";
|
||||
}
|
||||
value += dest;
|
||||
value += "/";
|
||||
|
||||
if (itgen->IsImportLibrary()) {
|
||||
// Construct the property name.
|
||||
std::string prop = cmStrCat("IMPORTED_IMPLIB", suffix);
|
||||
|
||||
// Append the installed file name.
|
||||
value += cmInstallTargetGenerator::GetInstallFilename(
|
||||
target, config, cmInstallTargetGenerator::NameImplibReal);
|
||||
|
||||
// Store the property.
|
||||
properties[prop] = value;
|
||||
importedLocations.insert(prop);
|
||||
} else if (itgen->GetTarget()->GetType() == cmStateEnums::OBJECT_LIBRARY) {
|
||||
// Construct the property name.
|
||||
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<std::string> objects;
|
||||
itgen->GetInstallObjectNames(config, objects);
|
||||
for (std::string& obj : objects) {
|
||||
obj = cmStrCat(value, obj);
|
||||
}
|
||||
|
||||
// Store the property.
|
||||
properties[prop] = cmList::to_string(objects);
|
||||
importedLocations.insert(prop);
|
||||
} else {
|
||||
if (target->IsFrameworkOnApple() && target->HasImportLibrary(config)) {
|
||||
// store as well IMPLIB value
|
||||
auto importProp = cmStrCat("IMPORTED_IMPLIB", suffix);
|
||||
auto importValue =
|
||||
cmStrCat(value,
|
||||
cmInstallTargetGenerator::GetInstallFilename(
|
||||
target, config, cmInstallTargetGenerator::NameImplibReal));
|
||||
|
||||
// Store the property.
|
||||
properties[importProp] = importValue;
|
||||
importedLocations.insert(importProp);
|
||||
}
|
||||
|
||||
// Construct the property name.
|
||||
std::string prop = cmStrCat("IMPORTED_LOCATION", suffix);
|
||||
|
||||
// Append the installed file name.
|
||||
if (target->IsAppBundleOnApple()) {
|
||||
value += cmInstallTargetGenerator::GetInstallFilename(target, config);
|
||||
value += ".app/";
|
||||
if (!target->Makefile->PlatformIsAppleEmbedded()) {
|
||||
value += "Contents/MacOS/";
|
||||
}
|
||||
value += cmInstallTargetGenerator::GetInstallFilename(target, config);
|
||||
} else {
|
||||
value += cmInstallTargetGenerator::GetInstallFilename(
|
||||
target, config, cmInstallTargetGenerator::NameReal);
|
||||
}
|
||||
|
||||
// Store the property.
|
||||
properties[prop] = value;
|
||||
importedLocations.insert(prop);
|
||||
}
|
||||
}
|
||||
|
||||
cmStateEnums::TargetType
|
||||
cmExportInstallCMakeConfigGenerator::GetExportTargetType(
|
||||
cmTargetExport const* targetExport) const
|
||||
{
|
||||
cmStateEnums::TargetType targetType = targetExport->Target->GetType();
|
||||
// An OBJECT library installed with no OBJECTS DESTINATION
|
||||
// is transformed to an INTERFACE library.
|
||||
if (targetType == cmStateEnums::OBJECT_LIBRARY &&
|
||||
targetExport->ObjectsGenerator == nullptr) {
|
||||
targetType = cmStateEnums::INTERFACE_LIBRARY;
|
||||
}
|
||||
return targetType;
|
||||
}
|
||||
|
||||
void cmExportInstallCMakeConfigGenerator::HandleMissingTarget(
|
||||
std::string& link_libs, cmGeneratorTarget const* depender,
|
||||
cmGeneratorTarget* dependee)
|
||||
{
|
||||
const std::string name = dependee->GetName();
|
||||
cmGlobalGenerator* gg = dependee->GetLocalGenerator()->GetGlobalGenerator();
|
||||
auto exportInfo = this->FindNamespaces(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));
|
||||
} else {
|
||||
// All exported targets should be known here and should be unique.
|
||||
// This is probably user-error.
|
||||
this->ComplainAboutMissingTarget(depender, dependee, exportFiles);
|
||||
}
|
||||
}
|
||||
|
||||
std::pair<std::vector<std::string>, std::string>
|
||||
cmExportInstallCMakeConfigGenerator::FindNamespaces(cmGlobalGenerator* gg,
|
||||
const std::string& name)
|
||||
{
|
||||
std::vector<std::string> exportFiles;
|
||||
std::string ns;
|
||||
const cmExportSetMap& exportSets = gg->GetExportSets();
|
||||
|
||||
for (auto const& expIt : exportSets) {
|
||||
const cmExportSet& exportSet = expIt.second;
|
||||
|
||||
bool containsTarget = false;
|
||||
for (auto const& target : exportSet.GetTargetExports()) {
|
||||
if (name == target->TargetName) {
|
||||
containsTarget = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (containsTarget) {
|
||||
std::vector<cmInstallExportGenerator const*> const* installs =
|
||||
exportSet.GetInstallations();
|
||||
for (cmInstallExportGenerator const* install : *installs) {
|
||||
exportFiles.push_back(install->GetDestinationFile());
|
||||
ns = install->GetNamespace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return { exportFiles, ns };
|
||||
}
|
||||
|
||||
void cmExportInstallCMakeConfigGenerator::ComplainAboutMissingTarget(
|
||||
cmGeneratorTarget const* depender, cmGeneratorTarget const* dependee,
|
||||
std::vector<std::string> const& exportFiles)
|
||||
{
|
||||
std::ostringstream e;
|
||||
e << "install(EXPORT \"" << this->GetExportSet()->GetName() << "\" ...) "
|
||||
<< "includes 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.";
|
||||
}
|
||||
cmSystemTools::Error(e.str());
|
||||
}
|
||||
|
||||
std::string cmExportInstallCMakeConfigGenerator::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->GetInstallNameDirForInstallTree(config, "${_IMPORT_PREFIX}");
|
||||
}
|
||||
|
||||
return install_name_dir;
|
||||
}
|
||||
|
||||
namespace {
|
||||
bool EntryIsContextSensitive(
|
||||
const std::unique_ptr<cmCompiledGeneratorExpression>& cge)
|
||||
{
|
||||
return cge->GetHadContextSensitiveCondition();
|
||||
}
|
||||
}
|
||||
|
||||
std::string cmExportInstallCMakeConfigGenerator::GetFileSetDirectories(
|
||||
cmGeneratorTarget* gte, cmFileSet* fileSet, cmTargetExport* te)
|
||||
{
|
||||
std::vector<std::string> resultVector;
|
||||
|
||||
auto configs =
|
||||
gte->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
|
||||
|
||||
cmGeneratorExpression ge(*gte->Makefile->GetCMakeInstance());
|
||||
auto cge = ge.Parse(te->FileSetGenerators.at(fileSet)->GetDestination());
|
||||
|
||||
for (auto const& config : configs) {
|
||||
auto unescapedDest = cge->Evaluate(gte->LocalGenerator, config, gte);
|
||||
auto dest = cmOutputConverter::EscapeForCMake(
|
||||
unescapedDest, cmOutputConverter::WrapQuotes::NoWrap);
|
||||
if (!cmSystemTools::FileIsFullPath(unescapedDest)) {
|
||||
dest = cmStrCat("${_IMPORT_PREFIX}/", dest);
|
||||
}
|
||||
|
||||
auto const& type = fileSet->GetType();
|
||||
// C++ modules do not support interface file sets which are dependent upon
|
||||
// the configuration.
|
||||
if (cge->GetHadContextSensitiveCondition() && type == "CXX_MODULES"_s) {
|
||||
auto* mf = this->IEGen->GetLocalGenerator()->GetMakefile();
|
||||
std::ostringstream e;
|
||||
e << "The \"" << gte->GetName() << "\" target's interface file set \""
|
||||
<< fileSet->GetName() << "\" of type \"" << type
|
||||
<< "\" contains context-sensitive base file entries which is not "
|
||||
"supported.";
|
||||
mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
|
||||
return std::string{};
|
||||
}
|
||||
|
||||
if (cge->GetHadContextSensitiveCondition() && configs.size() != 1) {
|
||||
resultVector.push_back(
|
||||
cmStrCat("\"$<$<CONFIG:", config, ">:", dest, ">\""));
|
||||
} else {
|
||||
resultVector.emplace_back(cmStrCat('"', dest, '"'));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return cmJoin(resultVector, " ");
|
||||
}
|
||||
|
||||
std::string cmExportInstallCMakeConfigGenerator::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();
|
||||
|
||||
cmGeneratorExpression destGe(*gte->Makefile->GetCMakeInstance());
|
||||
auto destCge =
|
||||
destGe.Parse(te->FileSetGenerators.at(fileSet)->GetDestination());
|
||||
|
||||
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);
|
||||
}
|
||||
auto unescapedDest = destCge->Evaluate(gte->LocalGenerator, config, gte);
|
||||
auto dest =
|
||||
cmStrCat(cmOutputConverter::EscapeForCMake(
|
||||
unescapedDest, cmOutputConverter::WrapQuotes::NoWrap),
|
||||
'/');
|
||||
if (!cmSystemTools::FileIsFullPath(unescapedDest)) {
|
||||
dest = cmStrCat("${_IMPORT_PREFIX}/", dest);
|
||||
}
|
||||
|
||||
bool const contextSensitive = destCge->GetHadContextSensitiveCondition() ||
|
||||
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->IEGen->GetLocalGenerator()->GetMakefile();
|
||||
std::ostringstream e;
|
||||
e << "The \"" << gte->GetName() << "\" target's interface file set \""
|
||||
<< fileSet->GetName() << "\" of type \"" << type
|
||||
<< "\" contains context-sensitive base file entries which is not "
|
||||
"supported.";
|
||||
mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
|
||||
return std::string{};
|
||||
}
|
||||
|
||||
for (auto const& it : files) {
|
||||
auto prefix = it.first.empty() ? "" : cmStrCat(it.first, '/');
|
||||
for (auto const& filename : it.second) {
|
||||
auto relFile =
|
||||
cmStrCat(prefix, cmSystemTools::GetFilenameName(filename));
|
||||
auto escapedFile =
|
||||
cmStrCat(dest,
|
||||
cmOutputConverter::EscapeForCMake(
|
||||
relFile, 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 cmExportInstallCMakeConfigGenerator::GetCxxModulesDirectory() const
|
||||
{
|
||||
return IEGen->GetCxxModuleDirectory();
|
||||
}
|
||||
|
||||
void cmExportInstallCMakeConfigGenerator::GenerateCxxModuleConfigInformation(
|
||||
std::string const& name, std::ostream& os) const
|
||||
{
|
||||
// Now load per-configuration properties for them.
|
||||
/* clang-format off */
|
||||
os << "# Load information for each installed configuration.\n"
|
||||
"file(GLOB _cmake_cxx_module_includes \"${CMAKE_CURRENT_LIST_DIR}/cxx-modules-" << name << "-*.cmake\")\n"
|
||||
"foreach(_cmake_cxx_module_include IN LISTS _cmake_cxx_module_includes)\n"
|
||||
" include(\"${_cmake_cxx_module_include}\")\n"
|
||||
"endforeach()\n"
|
||||
"unset(_cmake_cxx_module_include)\n"
|
||||
"unset(_cmake_cxx_module_includes)\n";
|
||||
/* clang-format on */
|
||||
}
|
||||
|
||||
std::string cmExportInstallCMakeConfigGenerator::GetCxxModuleFile() const
|
||||
{
|
||||
return this->GetCxxModuleFile(this->GetExportSet()->GetName());
|
||||
}
|
||||
|
||||
bool cmExportInstallCMakeConfigGenerator::
|
||||
GenerateImportCxxModuleConfigTargetInclusion(std::string const& name,
|
||||
std::string const& config)
|
||||
{
|
||||
auto cxx_modules_dirname = this->GetCxxModulesDirectory();
|
||||
if (cxx_modules_dirname.empty()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
std::string filename_config = config;
|
||||
if (filename_config.empty()) {
|
||||
filename_config = "noconfig";
|
||||
}
|
||||
|
||||
std::string const dest =
|
||||
cmStrCat(this->FileDir, '/', cxx_modules_dirname, '/');
|
||||
std::string fileName =
|
||||
cmStrCat(dest, "cxx-modules-", name, '-', filename_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);
|
||||
|
||||
// Record this per-config import file.
|
||||
this->ConfigCxxModuleFiles[config] = fileName;
|
||||
|
||||
auto& prop_files = this->ConfigCxxModuleTargetFiles[config];
|
||||
for (auto const* tgt : this->ExportedTargets) {
|
||||
// Only targets with C++ module sources will have a
|
||||
// collator-generated install script.
|
||||
if (!tgt->HaveCxx20ModuleSources()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
auto prop_filename = cmStrCat("target-", tgt->GetFilesystemExportName(),
|
||||
'-', filename_config, ".cmake");
|
||||
prop_files.emplace_back(cmStrCat(dest, prop_filename));
|
||||
os << "include(\"${CMAKE_CURRENT_LIST_DIR}/" << prop_filename << "\")\n";
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
145
Source/cmExportInstallCMakeConfigGenerator.h
Normal file
145
Source/cmExportInstallCMakeConfigGenerator.h
Normal file
@@ -0,0 +1,145 @@
|
||||
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
file Copyright.txt or https://cmake.org/licensing for details. */
|
||||
#pragma once
|
||||
|
||||
#include "cmConfigure.h" // IWYU pragma: keep
|
||||
|
||||
#include <iosfwd>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "cmExportFileGenerator.h"
|
||||
#include "cmInstallExportGenerator.h"
|
||||
#include "cmStateTypes.h"
|
||||
|
||||
class cmExportSet;
|
||||
class cmFileSet;
|
||||
class cmGeneratorTarget;
|
||||
class cmGlobalGenerator;
|
||||
class cmInstallTargetGenerator;
|
||||
class cmTargetExport;
|
||||
|
||||
/** \class cmExportInstallCMakeConfigGenerator
|
||||
* \brief Generate a file exporting targets from an install tree.
|
||||
*
|
||||
* cmExportInstallCMakeConfigGenerator generates files exporting targets from
|
||||
* install an installation tree. The files are placed in a temporary
|
||||
* location for installation by cmInstallExportGenerator. One main
|
||||
* file is generated that creates the imported targets and loads
|
||||
* per-configuration files. Target locations and settings for each
|
||||
* configuration are written to these per-configuration files. After
|
||||
* installation the main file loads the configurations that have been
|
||||
* installed.
|
||||
*
|
||||
* This is used to implement the INSTALL(EXPORT) command.
|
||||
*/
|
||||
class cmExportInstallCMakeConfigGenerator : public cmExportFileGenerator
|
||||
{
|
||||
public:
|
||||
/** Construct with the export installer that will install the
|
||||
files. */
|
||||
cmExportInstallCMakeConfigGenerator(cmInstallExportGenerator* iegen);
|
||||
|
||||
/** Get the per-config file generated for each configuration. This
|
||||
maps from the configuration name to the file temporary location
|
||||
for installation. */
|
||||
std::map<std::string, std::string> const& GetConfigImportFiles()
|
||||
{
|
||||
return this->ConfigImportFiles;
|
||||
}
|
||||
|
||||
/** Get the temporary location of the config-agnostic C++ module file. */
|
||||
std::string GetCxxModuleFile() const;
|
||||
|
||||
/** Get the per-config C++ module file generated for each configuration.
|
||||
This maps from the configuration name to the file temporary location
|
||||
for installation. */
|
||||
std::map<std::string, std::string> const& GetConfigCxxModuleFiles()
|
||||
{
|
||||
return this->ConfigCxxModuleFiles;
|
||||
}
|
||||
|
||||
/** Get the per-config C++ module file generated for each configuration.
|
||||
This maps from the configuration name to the file temporary location
|
||||
for installation for each target in the export set. */
|
||||
std::map<std::string, std::vector<std::string>> const&
|
||||
GetConfigCxxModuleTargetFiles()
|
||||
{
|
||||
return this->ConfigCxxModuleTargetFiles;
|
||||
}
|
||||
|
||||
/** Compute the globbing expression used to load per-config import
|
||||
files from the main file. */
|
||||
std::string GetConfigImportFileGlob();
|
||||
|
||||
protected:
|
||||
// Implement virtual methods from the superclass.
|
||||
bool GenerateMainFile(std::ostream& os) override;
|
||||
void GenerateImportTargetsConfig(std::ostream& os, const std::string& config,
|
||||
std::string const& suffix) override;
|
||||
cmStateEnums::TargetType GetExportTargetType(
|
||||
cmTargetExport const* targetExport) const;
|
||||
void HandleMissingTarget(std::string& link_libs,
|
||||
cmGeneratorTarget const* depender,
|
||||
cmGeneratorTarget* dependee) override;
|
||||
|
||||
void ReplaceInstallPrefix(std::string& input) override;
|
||||
|
||||
void ComplainAboutMissingTarget(cmGeneratorTarget const* depender,
|
||||
cmGeneratorTarget const* dependee,
|
||||
std::vector<std::string> const& exportFiles);
|
||||
|
||||
std::pair<std::vector<std::string>, std::string> FindNamespaces(
|
||||
cmGlobalGenerator* gg, const std::string& name);
|
||||
|
||||
/** Generate the relative import prefix. */
|
||||
virtual void GenerateImportPrefix(std::ostream&);
|
||||
|
||||
/** Generate the relative import prefix. */
|
||||
virtual void LoadConfigFiles(std::ostream&);
|
||||
|
||||
virtual void CleanupTemporaryVariables(std::ostream&);
|
||||
|
||||
/** Generate a per-configuration file for the targets. */
|
||||
virtual bool GenerateImportFileConfig(const std::string& config);
|
||||
|
||||
/** Fill in properties indicating installed file locations. */
|
||||
void SetImportLocationProperty(const std::string& config,
|
||||
std::string const& suffix,
|
||||
cmInstallTargetGenerator* itgen,
|
||||
ImportPropertyMap& properties,
|
||||
std::set<std::string>& importedLocations);
|
||||
|
||||
std::string InstallNameDir(cmGeneratorTarget const* target,
|
||||
const std::string& config) override;
|
||||
|
||||
std::string GetFileSetDirectories(cmGeneratorTarget* gte, cmFileSet* fileSet,
|
||||
cmTargetExport* te) override;
|
||||
std::string GetFileSetFiles(cmGeneratorTarget* gte, cmFileSet* fileSet,
|
||||
cmTargetExport* te) override;
|
||||
|
||||
using cmExportFileGenerator::GetCxxModuleFile;
|
||||
|
||||
std::string GetCxxModulesDirectory() const override;
|
||||
void GenerateCxxModuleConfigInformation(std::string const&,
|
||||
std::ostream&) const override;
|
||||
bool GenerateImportCxxModuleConfigTargetInclusion(std::string const&,
|
||||
std::string const&);
|
||||
|
||||
cmExportSet* GetExportSet() const override
|
||||
{
|
||||
return this->IEGen->GetExportSet();
|
||||
}
|
||||
|
||||
cmInstallExportGenerator* IEGen;
|
||||
|
||||
// The import file generated for each configuration.
|
||||
std::map<std::string, std::string> ConfigImportFiles;
|
||||
// The C++ module property file generated for each configuration.
|
||||
std::map<std::string, std::string> ConfigCxxModuleFiles;
|
||||
// The C++ module property target files generated for each configuration.
|
||||
std::map<std::string, std::vector<std::string>> ConfigCxxModuleTargetFiles;
|
||||
};
|
||||
Reference in New Issue
Block a user