[WIP] JSON generator
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index 7031d5a..146ef36 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -181,12 +181,16 @@
cmExportBuildAndroidMKGenerator.cxx
cmExportBuildFileGenerator.h
cmExportBuildFileGenerator.cxx
+ cmExportBuildJSONGenerator.h
+ cmExportBuildJSONGenerator.cxx
cmExportFileGenerator.h
cmExportFileGenerator.cxx
cmExportInstallAndroidMKGenerator.h
cmExportInstallAndroidMKGenerator.cxx
cmExportInstallFileGenerator.h
cmExportInstallFileGenerator.cxx
+ cmExportInstallJSONGenerator.h
+ cmExportInstallJSONGenerator.cxx
cmExportTryCompileFileGenerator.h
cmExportTryCompileFileGenerator.cxx
cmExportSet.h
diff --git a/Source/cmExportBuildJSONGenerator.cxx b/Source/cmExportBuildJSONGenerator.cxx
new file mode 100644
index 0000000..4b7918e
--- /dev/null
+++ b/Source/cmExportBuildJSONGenerator.cxx
@@ -0,0 +1,298 @@
+/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+ file Copyright.txt or https://cmake.org/licensing for details. */
+#include "cmExportBuildJSONGenerator.h"
+
+#include <algorithm>
+#include <memory> // IWYU pragma: keep
+#include <numeric>
+#include <sstream>
+#include <utility>
+
+#include "cmExportSet.h"
+#include "cmGeneratorExpression.h"
+#include "cmGeneratorTarget.h"
+#include "cmLinkItem.h"
+#include "cmGlobalGenerator.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmPolicies.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmake.h"
+
+cmExportBuildJSONGenerator::cmExportBuildJSONGenerator()
+{
+ this->LG = nullptr;
+ this->ExportSet = nullptr;
+}
+
+void cmExportBuildJSONGenerator::Compute(cmLocalGenerator* lg)
+{
+ this->LG = lg;
+ if (this->ExportSet) {
+ this->ExportSet->Compute(lg);
+ }
+}
+
+bool cmExportBuildJSONGenerator::GenerateMainFile(std::ostream& os)
+{
+ {
+ std::string expectedTargets;
+ std::string sep;
+ std::vector<std::string> targets;
+ this->GetTargets(targets);
+ for (std::string const& tei : targets) {
+ cmGeneratorTarget* te = this->LG->FindGeneratorTargetToUse(tei);
+ expectedTargets += sep + this->Namespace + te->GetExportName();
+ sep = " ";
+ if (this->ExportedTargets.insert(te).second) {
+ this->Exports.push_back(te);
+ } else {
+ std::ostringstream e;
+ e << "given target \"" << te->GetName() << "\" more than once.";
+ this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
+ cmake::FATAL_ERROR, e.str(),
+ this->LG->GetMakefile()->GetBacktrace());
+ return false;
+ }
+ }
+ }
+
+ std::vector<std::string> missingTargets;
+
+ os << "{\n"
+ << " \"targets\": {\n";
+
+ // Create all the imported targets.
+ for (auto i = this->Exports.begin(); i != this->Exports.end(); ++i) {
+ cmGeneratorTarget* gte = *i;
+
+ this->GenerateImportTargetCode(os, gte);
+
+ gte->Target->AppendBuildInterfaceIncludes();
+
+ ImportPropertyMap properties;
+
+ this->PopulateInterfaceProperty("INTERFACE_INCLUDE_DIRECTORIES", gte,
+ cmGeneratorExpression::BuildInterface,
+ properties, missingTargets);
+ this->PopulateInterfaceProperty("INTERFACE_SOURCES", gte,
+ cmGeneratorExpression::BuildInterface,
+ properties, missingTargets);
+ this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", gte,
+ cmGeneratorExpression::BuildInterface,
+ properties, missingTargets);
+ this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", gte,
+ cmGeneratorExpression::BuildInterface,
+ properties, missingTargets);
+ this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", gte,
+ cmGeneratorExpression::BuildInterface,
+ properties, missingTargets);
+ this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gte,
+ cmGeneratorExpression::BuildInterface,
+ properties, missingTargets);
+ this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", gte,
+ properties);
+ const bool newCMP0022Behavior =
+ gte->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
+ gte->GetPolicyStatusCMP0022() != cmPolicies::OLD;
+ if (newCMP0022Behavior) {
+ this->PopulateInterfaceLinkLibrariesProperty(
+ gte, cmGeneratorExpression::BuildInterface, properties,
+ missingTargets);
+ }
+ this->PopulateCompatibleInterfaceProperties(gte, properties);
+
+ this->GenerateInterfaceProperties(gte, os, properties);
+
+ os << " }";
+ if (i != this->Exports.end() - 1)
+ os << ",";
+ os << "\n";
+ }
+ os << " }\n";
+
+ // Generate import file content for each configuration.
+ for (std::string const& c : this->Configurations) {
+ this->GenerateImportConfig(os, c, missingTargets);
+ }
+
+ this->GenerateMissingTargetsCheckCode(os, missingTargets);
+
+ os << "}\n";
+
+ return true;
+}
+
+void cmExportBuildJSONGenerator::GenerateImportTargetCode(
+ std::ostream& os, const cmGeneratorTarget* target)
+{
+ std::string targetName = this->Namespace;
+ targetName += target->GetExportName();
+ os << " \"" << targetName << "\": {\n";
+ std::string path =
+ cmSystemTools::ConvertToOutputPath(target->GetFullPath().c_str());
+ os << " \"output\": \"" << path << "\",\n";
+}
+
+void cmExportBuildJSONGenerator::GenerateImportPropertyCode(
+ std::ostream& os, const std::string&, cmGeneratorTarget const*,
+ ImportPropertyMap const& properties)
+{
+ for (auto const& property : properties) {
+ if (property.first == "IMPORTED_SONAME") {
+ } else if (property.first == "IMPORTED_LINK_INTERFACE_LANGUAGES") {
+ } else if (property.first == "IMPORTED_LOCATION") {
+ }
+ os << " " << property.first << " " << (property.second) << "\n";
+ }
+}
+
+void cmExportBuildJSONGenerator::GenerateMissingTargetsCheckCode(
+ std::ostream&, const std::vector<std::string>&)
+{
+}
+
+void cmExportBuildJSONGenerator::GenerateInterfaceProperties(
+ const cmGeneratorTarget* target, std::ostream& os,
+ const ImportPropertyMap& properties)
+{
+ std::string config;
+ if (!this->Configurations.empty()) {
+ config = this->Configurations[0];
+ }
+ cmExportBuildJSONGenerator::GenerateInterfaceProperties(
+ target, os, properties, cmExportBuildJSONGenerator::BUILD, config);
+}
+
+void cmExportBuildJSONGenerator::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 == cmExportBuildJSONGenerator::BUILD) {
+ w << "export(TARGETS ... JSON) called with policy CMP0022";
+ } else {
+ w << "install(JSON ...) 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(cmake::AUTHOR_WARNING, w.str());
+ }
+ if (!properties.empty()) {
+ 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") {
+ // need to look at list in pi->second and see if static or shared
+ // FindTargetToLink
+ // target->GetLocalGenerator()->FindGeneratorTargetToUse()
+ // then add to LOCAL_CPPFLAGS
+ std::vector<std::string> libraries;
+ cmSystemTools::ExpandListArgument(property.second, libraries);
+ std::vector<std::string> deps;
+ std::vector<std::string> staticLibs;
+ std::vector<std::string> sharedLibs;
+ std::vector<std::string> ldlibs;
+ for (std::string const& lib : libraries) {
+ cmGeneratorTarget* gt =
+ target->GetLocalGenerator()->FindGeneratorTargetToUse(lib);
+ if (gt) {
+ deps.push_back(lib);
+ if (gt->GetType() == cmStateEnums::SHARED_LIBRARY ||
+ gt->GetType() == cmStateEnums::MODULE_LIBRARY) {
+ sharedLibs.push_back(lib);
+ } else {
+ staticLibs.push_back(lib);
+ }
+ } else {
+ // evaluate any generator expressions with the current
+ // build type of the makefile
+ cmGeneratorExpression ge;
+ std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(lib);
+ std::string evaluated =
+ cge->Evaluate(target->GetLocalGenerator(), config);
+ bool relpath = false;
+ if (type == cmExportBuildJSONGenerator::INSTALL) {
+ relpath = lib.substr(0, 3) == "../";
+ }
+ // 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(evaluated) || evaluated.substr(0, 2) == "-l" || relpath) {
+ ldlibs.push_back(evaluated);
+ // if it is not a path and does not have a -l then add -l
+ } else if (!evaluated.empty()) {
+ ldlibs.push_back("-l" + evaluated);
+ }
+ }
+ }
+ auto join = [](std::string &ss, std::string &s) {
+ return ss.empty() ? s : ss + "\", \"" + s;
+ };
+ if (!deps.empty()) {
+ std::string str = std::accumulate(std::begin(deps), std::end(deps), std::string(), join);
+ os << " \"deps\": [\"" << str << "\"],\n";
+ }
+ //if (!sharedLibs.empty()) {
+ // std::string str = std::accumulate(std::begin(sharedLibs), std::end(sharedLibs), std::string(), join);
+ // os << " \"shared_libraries\": [\"" << str << "\"],\n";
+ //}
+ //if (!staticLibs.empty()) {
+ // std::string str = std::accumulate(std::begin(staticLibs), std::end(staticLibs), std::string(), join);
+ // os << " \"static_libraries\": [\"" << str << "\"],\n";
+ //}
+ if (!ldlibs.empty()) {
+ std::string str = std::accumulate(std::begin(ldlibs), std::end(ldlibs), std::string(), join);
+ os << " \"libs\": [\"" << str << "\"],\n";
+ }
+ } else if (property.first == "INTERFACE_INCLUDE_DIRECTORIES") {
+ std::string includes = property.second;
+ std::vector<std::string> includeList;
+ cmSystemTools::ExpandListArgument(includes, includeList);
+ auto join = [](std::string &ss, std::string &s) {
+ return ss.empty() ? s : ss + "\", \"" + s;
+ };
+ std::string str = std::accumulate(std::begin(includeList), std::end(includeList), std::string(), join);
+ os << " \"include_dirs\": [\"" << str << "\"],\n";
+ } else {
+ os << "# " << property.first << " " << (property.second) << "\n";
+ }
+ }
+ }
+
+ if (target->GetType() == cmStateEnums::STATIC_LIBRARY) {
+ cmLinkImplementation const* li = target->GetLinkImplementation(config);
+ if (std::find(li->Languages.begin(), li->Languages.end(), "CXX") !=
+ li->Languages.end()) {
+ }
+ }
+
+ switch (target->GetType()) {
+ case cmStateEnums::SHARED_LIBRARY:
+ os << " \"target_type\": \"shared_library\"\n";
+ break;
+ case cmStateEnums::MODULE_LIBRARY:
+ os << " \"target_type\": \"module_library\"\n";
+ break;
+ case cmStateEnums::STATIC_LIBRARY:
+ os << " \"target_type\": \"static_library\"\n";
+ break;
+ case cmStateEnums::EXECUTABLE:
+ os << " \"target_type\": \"executable\"\n";
+ break;
+ case cmStateEnums::UTILITY:
+ case cmStateEnums::OBJECT_LIBRARY:
+ case cmStateEnums::GLOBAL_TARGET:
+ case cmStateEnums::INTERFACE_LIBRARY:
+ case cmStateEnums::UNKNOWN_LIBRARY:
+ break;
+ }
+}
diff --git a/Source/cmExportBuildJSONGenerator.h b/Source/cmExportBuildJSONGenerator.h
new file mode 100644
index 0000000..e957a7c
--- /dev/null
+++ b/Source/cmExportBuildJSONGenerator.h
@@ -0,0 +1,75 @@
+/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+ file Copyright.txt or https://cmake.org/licensing for details. */
+#ifndef cmExportBuildJSONGenerator_h
+#define cmExportBuildJSONGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+#include "cmExportBuildFileGenerator.h"
+#include "cmExportFileGenerator.h"
+
+class cmGeneratorTarget;
+
+/** \class cmExportBuildJSONGenerator
+ * \brief Generate a file exporting targets from a build tree.
+ *
+ * cmExportBuildJSONGenerator generates a file exporting targets from
+ * a build tree. This exports the targets to the JSON format that is
+ * intended to be consumed by other tools.
+ *
+ * This is used to implement the EXPORT() command.
+ */
+class cmExportBuildJSONGenerator : public cmExportBuildFileGenerator
+{
+public:
+ cmExportBuildJSONGenerator();
+ // this is so cmExportInstallJSONGenerator 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);
+
+ void Compute(cmLocalGenerator* lg);
+
+protected:
+ // Implement virtual methods from the superclass.
+ bool GenerateMainFile(std::ostream& os) override;
+ void GeneratePolicyHeaderCode(std::ostream&) override {}
+ void GeneratePolicyFooterCode(std::ostream&) override {}
+ void GenerateImportHeaderCode(std::ostream&, const std::string&) override {};
+ void GenerateImportFooterCode(std::ostream&) override {};
+ void GenerateImportTargetCode(std::ostream& os,
+ const cmGeneratorTarget* target) override;
+ void GenerateImportPropertyCode(
+ std::ostream& os, const std::string& config,
+ cmGeneratorTarget const* target,
+ ImportPropertyMap const& properties) override;
+ void GenerateImportedFileChecksCode(
+ std::ostream&, cmGeneratorTarget*,
+ ImportPropertyMap const&, const std::set<std::string>&) override {};
+ void GenerateImportedFileCheckLoop(std::ostream&) override {};
+ void GenerateMissingTargetsCheckCode(
+ std::ostream& os, const std::vector<std::string>& missingTargets) override;
+ void GenerateExpectedTargetsCode(
+ std::ostream&, const std::string&) override {};
+
+ void GenerateImportTargetsConfig(
+ std::ostream&, const std::string&, std::string const&,
+ std::vector<std::string>&) override {};
+ void GenerateInterfaceProperties(
+ cmGeneratorTarget const* target, std::ostream& os,
+ const ImportPropertyMap& properties) override;
+};
+
+#endif
diff --git a/Source/cmExportCommand.cxx b/Source/cmExportCommand.cxx
index 9913129..e92cfcb 100644
--- a/Source/cmExportCommand.cxx
+++ b/Source/cmExportCommand.cxx
@@ -8,6 +8,7 @@
#include "cmExportBuildAndroidMKGenerator.h"
#include "cmExportBuildFileGenerator.h"
+#include "cmExportBuildJSONGenerator.h"
#include "cmExportSetMap.h"
#include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h"
@@ -34,6 +35,7 @@
, Filename(&Helper, "FILE", &ArgumentGroup)
, ExportOld(&Helper, "EXPORT_LINK_INTERFACE_LIBRARIES", &ArgumentGroup)
, AndroidMKFile(&Helper, "ANDROID_MK")
+ , JSONFile(&Helper, "JSON")
{
this->ExportSet = nullptr;
}
@@ -72,6 +74,11 @@
fname = this->AndroidMKFile.GetString();
android = true;
}
+ bool json = false;
+ if (this->JSONFile.WasFound()) {
+ fname = this->JSONFile.GetString();
+ json = true;
+ }
if (!this->Filename.WasFound() && fname.empty()) {
if (args[0] != "EXPORT") {
this->SetError("FILE <filename> option missing.");
@@ -187,6 +194,8 @@
cmExportBuildFileGenerator* ebfg = nullptr;
if (android) {
ebfg = new cmExportBuildAndroidMKGenerator;
+ } else if (json) {
+ ebfg = new cmExportBuildJSONGenerator;
} else {
ebfg = new cmExportBuildFileGenerator;
}
diff --git a/Source/cmExportCommand.h b/Source/cmExportCommand.h
index a5c6751..4c7d1d7 100644
--- a/Source/cmExportCommand.h
+++ b/Source/cmExportCommand.h
@@ -46,6 +46,7 @@
cmCAString Filename;
cmCAEnabler ExportOld;
cmCAString AndroidMKFile;
+ cmCAString JSONFile;
cmExportSet* ExportSet;
diff --git a/Source/cmExportInstallJSONGenerator.cxx b/Source/cmExportInstallJSONGenerator.cxx
new file mode 100644
index 0000000..8ad4f89
--- /dev/null
+++ b/Source/cmExportInstallJSONGenerator.cxx
@@ -0,0 +1,232 @@
+/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+ file Copyright.txt or https://cmake.org/licensing for details. */
+#include "cmExportInstallJSONGenerator.h"
+
+#include <ostream>
+#include <stddef.h>
+
+#include "cmExportBuildJSONGenerator.h"
+#include "cmExportSet.h"
+#include "cmGeneratorTarget.h"
+#include "cmInstallExportGenerator.h"
+#include "cmInstallTargetGenerator.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmTargetExport.h"
+
+cmExportInstallJSONGenerator::cmExportInstallJSONGenerator(
+ cmInstallExportGenerator* iegen)
+ : cmExportInstallFileGenerator(iegen)
+{
+}
+
+bool cmExportInstallJSONGenerator::GenerateMainFile(std::ostream& os)
+{
+ std::vector<cmTargetExport*> allTargets;
+ {
+ std::string expectedTargets;
+ std::string sep;
+ for (cmTargetExport* te :
+ *this->IEGen->GetExportSet()->GetTargetExports()) {
+ expectedTargets += sep + this->Namespace + te->Target->GetExportName();
+ sep = " ";
+ if (this->ExportedTargets.insert(te->Target).second) {
+ allTargets.push_back(te);
+ } else {
+ std::ostringstream e;
+ e << "install(EXPORT \"" << this->IEGen->GetExportSet()->GetName()
+ << "\" ...) "
+ << "includes target \"" << te->Target->GetName()
+ << "\" more than once in the export set.";
+ cmSystemTools::Error(e.str().c_str());
+ return false;
+ }
+ }
+ }
+
+ std::vector<std::string> missingTargets;
+
+ os << "{\n"
+ << " \"targets\": {\n";
+
+ bool requiresConfigFiles = false;
+ // Create all the imported targets.
+ for (auto i = allTargets.begin(); i != allTargets.end(); ++i) {
+ cmTargetExport* te = *i;
+ cmGeneratorTarget* gt = te->Target;
+
+ requiresConfigFiles =
+ requiresConfigFiles || gt->GetType() != cmStateEnums::INTERFACE_LIBRARY;
+
+ this->GenerateImportTargetCode(os, gt);
+
+ ImportPropertyMap properties;
+
+ this->PopulateIncludeDirectoriesInterface(
+ te, cmGeneratorExpression::InstallInterface, properties, missingTargets);
+ this->PopulateSourcesInterface(te, cmGeneratorExpression::InstallInterface,
+ properties, missingTargets);
+ this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", gt,
+ cmGeneratorExpression::InstallInterface,
+ properties, missingTargets);
+ this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", gt,
+ cmGeneratorExpression::InstallInterface,
+ properties, missingTargets);
+ this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", gt,
+ cmGeneratorExpression::InstallInterface,
+ properties, missingTargets);
+ this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", gt,
+ cmGeneratorExpression::InstallInterface,
+ properties, missingTargets);
+ this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gt,
+ cmGeneratorExpression::InstallInterface,
+ properties, missingTargets);
+
+ const bool newCMP0022Behavior =
+ gt->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
+ gt->GetPolicyStatusCMP0022() != cmPolicies::OLD;
+ if (newCMP0022Behavior) {
+ this->PopulateInterfaceLinkLibrariesProperty(
+ gt, cmGeneratorExpression::InstallInterface, properties,
+ missingTargets);
+ }
+
+ this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", gt,
+ properties);
+
+ this->PopulateCompatibleInterfaceProperties(gt, properties);
+
+ this->GenerateInterfaceProperties(gt, os, properties);
+
+ os << " }";
+ if (i != allTargets.end() - 1)
+ os << ",";
+ os << "\n";
+ }
+ os << " }\n";
+
+ this->LoadConfigFiles(os);
+
+ this->CleanupTemporaryVariables(os);
+ this->GenerateImportedFileCheckLoop(os);
+
+ bool result = true;
+ // 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, missingTargets)) {
+ result = false;
+ }
+ }
+ }
+
+ this->GenerateMissingTargetsCheckCode(os, missingTargets);
+
+ os << "}\n";
+
+ return result;
+}
+
+void cmExportInstallJSONGenerator::GenerateImportHeaderCode(
+ std::ostream& os, const std::string&)
+{
+ std::string installDir = this->IEGen->GetDestination();
+ for (cmTargetExport* te : *this->IEGen->GetExportSet()->GetTargetExports()) {
+ // Collect import properties for this target.
+ if (te->Target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+ continue;
+ }
+ std::string dest;
+ if (te->LibraryGenerator) {
+ dest = te->LibraryGenerator->GetDestination("");
+ }
+ if (te->ArchiveGenerator) {
+ dest = te->ArchiveGenerator->GetDestination("");
+ }
+ te->Target->Target->SetProperty("__dest", dest.c_str());
+ }
+}
+
+void cmExportInstallJSONGenerator::GenerateImportFooterCode(std::ostream&)
+{
+}
+
+void cmExportInstallJSONGenerator::GenerateImportTargetCode(
+ std::ostream& os, const cmGeneratorTarget* target)
+{
+ std::string targetName = this->Namespace;
+ targetName += target->GetExportName();
+ os << " \"" << targetName << "\": {\n";
+ os << " \"output\": \"";
+ os << target->Target->GetProperty("__dest") << "/";
+ std::string config;
+ if (!this->Configurations.empty()) {
+ config = this->Configurations[0];
+ }
+ os << target->GetFullName(config) << "\",\n";
+}
+
+void cmExportInstallJSONGenerator::GenerateExpectedTargetsCode(
+ std::ostream&, const std::string&)
+{
+}
+
+void cmExportInstallJSONGenerator::GenerateImportPropertyCode(
+ std::ostream&, const std::string&, cmGeneratorTarget const*,
+ ImportPropertyMap const&)
+{
+}
+
+void cmExportInstallJSONGenerator::GenerateMissingTargetsCheckCode(
+ std::ostream&, const std::vector<std::string>&)
+{
+}
+
+void cmExportInstallJSONGenerator::GenerateInterfaceProperties(
+ cmGeneratorTarget const* target, std::ostream& os,
+ const ImportPropertyMap& properties)
+{
+ std::string config;
+ if (!this->Configurations.empty()) {
+ config = this->Configurations[0];
+ }
+ cmExportBuildJSONGenerator::GenerateInterfaceProperties(
+ target, os, properties, cmExportBuildJSONGenerator::INSTALL, config);
+}
+
+void cmExportInstallJSONGenerator::LoadConfigFiles(std::ostream&)
+{
+}
+
+void cmExportInstallJSONGenerator::GenerateImportPrefix(std::ostream&)
+{
+}
+
+void cmExportInstallJSONGenerator::GenerateRequiredCMakeVersion(
+ std::ostream&, const char*)
+{
+}
+
+void cmExportInstallJSONGenerator::CleanupTemporaryVariables(
+ std::ostream&)
+{
+}
+
+void cmExportInstallJSONGenerator::GenerateImportedFileCheckLoop(
+ std::ostream&)
+{
+}
+
+void cmExportInstallJSONGenerator::GenerateImportedFileChecksCode(
+ std::ostream&, cmGeneratorTarget*, ImportPropertyMap const&,
+ const std::set<std::string>&)
+{
+}
+
+bool cmExportInstallJSONGenerator::GenerateImportFileConfig(
+ const std::string&, std::vector<std::string>&)
+{
+ return true;
+}
diff --git a/Source/cmExportInstallJSONGenerator.h b/Source/cmExportInstallJSONGenerator.h
new file mode 100644
index 0000000..5f0568f
--- /dev/null
+++ b/Source/cmExportInstallJSONGenerator.h
@@ -0,0 +1,72 @@
+/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+ file Copyright.txt or https://cmake.org/licensing for details. */
+#ifndef cmExportInstallJSONGenerator_h
+#define cmExportInstallJSONGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "cmExportFileGenerator.h"
+#include "cmExportInstallFileGenerator.h"
+
+class cmGeneratorTarget;
+class cmInstallExportGenerator;
+
+/** \class cmExportInstallJSONGenerator
+ * \brief Generate a file exporting targets from an install tree.
+ *
+ * cmExportInstallJSONGenerator generates files exporting targets from
+ * install an installation tree. The files are placed in a temporary
+ * location for installation by cmInstallExportGenerator. The file format
+ * is for the ndk build system and is a makefile fragment specifing prebuilt
+ * libraries to the ndk build system.
+ *
+ * This is used to implement the INSTALL(EXPORT_JSON) command.
+ */
+class cmExportInstallJSONGenerator : public cmExportInstallFileGenerator
+{
+public:
+ /** Construct with the export installer that will install the
+ files. */
+ cmExportInstallJSONGenerator(cmInstallExportGenerator* iegen);
+
+protected:
+ // Implement virtual methods from the superclass.
+ bool GenerateMainFile(std::ostream& os) override;
+ 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,
+ const cmGeneratorTarget* target) override;
+ void GenerateExpectedTargetsCode(
+ std::ostream& os, const std::string& expectedTargets) override;
+ void GenerateImportPropertyCode(
+ std::ostream& os, const std::string& config,
+ cmGeneratorTarget const* target,
+ ImportPropertyMap const& properties) override;
+ void GenerateMissingTargetsCheckCode(
+ std::ostream& os, const std::vector<std::string>& missingTargets) override;
+ void GenerateInterfaceProperties(
+ cmGeneratorTarget const* target, std::ostream& os,
+ const ImportPropertyMap& properties) override;
+ void GenerateImportPrefix(std::ostream& os) override;
+ void LoadConfigFiles(std::ostream&) override;
+ void GenerateRequiredCMakeVersion(std::ostream& os,
+ const char* versionString) override;
+ void CleanupTemporaryVariables(std::ostream&) override;
+ void GenerateImportedFileCheckLoop(std::ostream& os) override;
+ void GenerateImportedFileChecksCode(
+ std::ostream& os, cmGeneratorTarget* target,
+ ImportPropertyMap const& properties,
+ const std::set<std::string>& importedLocations) override;
+ bool GenerateImportFileConfig(const std::string& config,
+ std::vector<std::string>&) override;
+};
+
+#endif
diff --git a/Source/cmInstallCommand.cxx b/Source/cmInstallCommand.cxx
index 685fc67..9f2aac5 100644
--- a/Source/cmInstallCommand.cxx
+++ b/Source/cmInstallCommand.cxx
@@ -102,6 +102,9 @@
if (mode == "EXPORT_ANDROID_MK") {
return this->HandleExportAndroidMKMode(args);
}
+ if (mode == "EXPORT_JSON") {
+ return this->HandleExportJSONMode(args);
+ }
// Unknown mode.
std::string e = "called with unknown mode ";
@@ -1247,7 +1250,7 @@
exportSet, ica.GetDestination().c_str(), ica.GetPermissions().c_str(),
ica.GetConfigurations(), ica.GetComponent().c_str(), message,
ica.GetExcludeFromAll(), fname.c_str(), name_space.GetCString(),
- exportOld.IsEnabled(), true);
+ exportOld.IsEnabled(), true, false);
this->Makefile->AddInstallGenerator(exportGenerator);
return true;
@@ -1258,6 +1261,112 @@
#endif
}
+bool cmInstallCommand::HandleExportJSONMode(
+ std::vector<std::string> const& args)
+{
+#ifdef CMAKE_BUILD_WITH_CMAKE
+ // This is the EXPORT mode.
+ cmInstallCommandArguments ica(this->DefaultComponentName);
+ cmCAString exp(&ica.Parser, "EXPORT_JSON");
+ cmCAString name_space(&ica.Parser, "NAMESPACE", &ica.ArgumentGroup);
+ cmCAEnabler exportOld(&ica.Parser, "EXPORT_LINK_INTERFACE_LIBRARIES",
+ &ica.ArgumentGroup);
+ cmCAString filename(&ica.Parser, "FILE", &ica.ArgumentGroup);
+ exp.Follows(nullptr);
+
+ ica.ArgumentGroup.Follows(&exp);
+ std::vector<std::string> unknownArgs;
+ ica.Parse(&args, &unknownArgs);
+
+ if (!unknownArgs.empty()) {
+ // Unknown argument.
+ std::ostringstream e;
+ e << args[0] << " given unknown argument \"" << unknownArgs[0] << "\".";
+ this->SetError(e.str());
+ return false;
+ }
+
+ if (!ica.Finalize()) {
+ return false;
+ }
+
+ // Make sure there is a destination.
+ if (ica.GetDestination().empty()) {
+ // A destination is required.
+ std::ostringstream e;
+ e << args[0] << " given no DESTINATION!";
+ this->SetError(e.str());
+ return false;
+ }
+
+ // Check the file name.
+ std::string fname = filename.GetString();
+ if (fname.find_first_of(":/\\") != std::string::npos) {
+ std::ostringstream e;
+ e << args[0] << " given invalid export file name \"" << fname << "\". "
+ << "The FILE argument may not contain a path. "
+ << "Specify the path in the DESTINATION argument.";
+ this->SetError(e.str());
+ return false;
+ }
+
+ // Check the file extension.
+ if (!fname.empty() &&
+ cmSystemTools::GetFilenameLastExtension(fname) != ".json") {
+ std::ostringstream e;
+ e << args[0] << " given invalid export file name \"" << fname << "\". "
+ << "The FILE argument must specify a name ending in \".json\".";
+ this->SetError(e.str());
+ return false;
+ }
+ if (fname.find_first_of(":/\\") != std::string::npos) {
+ std::ostringstream e;
+ e << args[0] << " given export name \"" << exp.GetString() << "\". "
+ << "This name cannot be safely converted to a file name. "
+ << "Specify a different export name or use the FILE option to set "
+ << "a file name explicitly.";
+ this->SetError(e.str());
+ return false;
+ }
+
+ // Construct the file name.
+ if (fname.empty()) {
+ fname = exp.GetString();
+ fname += ".json";
+
+ if (fname.find_first_of(":/\\") != std::string::npos) {
+ std::ostringstream e;
+ e << args[0] << " given export name \"" << exp.GetString() << "\". "
+ << "This name cannot be safely converted to a file name. "
+ << "Specify a different export name or use the FILE option to set "
+ << "a file name explicitly.";
+ this->SetError(e.str());
+ return false;
+ }
+ }
+
+ cmExportSet* exportSet =
+ this->Makefile->GetGlobalGenerator()->GetExportSets()[exp.GetString()];
+
+ cmInstallGenerator::MessageLevel message =
+ cmInstallGenerator::SelectMessageLevel(this->Makefile);
+
+ // Create the export install generator.
+ cmInstallExportGenerator* exportGenerator = new cmInstallExportGenerator(
+ exportSet, ica.GetDestination().c_str(), ica.GetPermissions().c_str(),
+ ica.GetConfigurations(), ica.GetComponent().c_str(), message,
+ ica.GetExcludeFromAll(), fname.c_str(), name_space.GetCString(),
+ exportOld.IsEnabled(), false, true);
+ this->Makefile->AddInstallGenerator(exportGenerator);
+
+ return true;
+#else
+ static_cast<void>(args);
+ this->SetError("EXPORT_JSON not supported in bootstrap cmake");
+ return false;
+#endif
+}
+
bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args)
{
// This is the EXPORT mode.
@@ -1361,7 +1470,7 @@
exportSet, ica.GetDestination().c_str(), ica.GetPermissions().c_str(),
ica.GetConfigurations(), ica.GetComponent().c_str(), message,
ica.GetExcludeFromAll(), fname.c_str(), name_space.GetCString(),
- exportOld.IsEnabled(), false);
+ exportOld.IsEnabled(), false, false);
this->Makefile->AddInstallGenerator(exportGenerator);
return true;
diff --git a/Source/cmInstallCommand.h b/Source/cmInstallCommand.h
index 8bd0159..b42a291 100644
--- a/Source/cmInstallCommand.h
+++ b/Source/cmInstallCommand.h
@@ -40,6 +40,7 @@
bool HandleDirectoryMode(std::vector<std::string> const& args);
bool HandleExportMode(std::vector<std::string> const& args);
bool HandleExportAndroidMKMode(std::vector<std::string> const& args);
+ bool HandleExportJSONMode(std::vector<std::string> const& args);
bool MakeFilesFullPath(const char* modeName,
const std::vector<std::string>& relFiles,
std::vector<std::string>& absFiles);
diff --git a/Source/cmInstallExportGenerator.cxx b/Source/cmInstallExportGenerator.cxx
index fdd231c..d8c778f 100644
--- a/Source/cmInstallExportGenerator.cxx
+++ b/Source/cmInstallExportGenerator.cxx
@@ -10,6 +10,9 @@
#include "cmExportInstallAndroidMKGenerator.h"
#endif
#include "cmExportInstallFileGenerator.h"
+#ifdef CMAKE_BUILD_WITH_CMAKE
+#include "cmExportInstallJSONGenerator.h"
+#endif
#include "cmExportSet.h"
#include "cmInstallType.h"
#include "cmLocalGenerator.h"
@@ -20,7 +23,8 @@
cmExportSet* exportSet, const char* destination,
const char* file_permissions, std::vector<std::string> const& configurations,
const char* component, MessageLevel message, bool exclude_from_all,
- const char* filename, const char* name_space, bool exportOld, bool android)
+ const char* filename, const char* name_space, bool exportOld, bool android,
+ bool json)
: cmInstallGenerator(destination, configurations, component, message,
exclude_from_all)
, ExportSet(exportSet)
@@ -34,6 +38,10 @@
#ifdef CMAKE_BUILD_WITH_CMAKE
this->EFGen = new cmExportInstallAndroidMKGenerator(this);
#endif
+ } else if (json) {
+#ifdef CMAKE_BUILD_WITH_CMAKE
+ this->EFGen = new cmExportInstallJSONGenerator(this);
+#endif
} else {
this->EFGen = new cmExportInstallFileGenerator(this);
}
diff --git a/Source/cmInstallExportGenerator.h b/Source/cmInstallExportGenerator.h
index d23cf06..2d22fec 100644
--- a/Source/cmInstallExportGenerator.h
+++ b/Source/cmInstallExportGenerator.h
@@ -29,7 +29,7 @@
const char* component, MessageLevel message,
bool exclude_from_all, const char* filename,
const char* name_space, bool exportOld,
- bool android);
+ bool android, bool json);
~cmInstallExportGenerator() override;
cmExportSet* GetExportSet() { return this->ExportSet; }
diff --git a/Tests/RunCMake/JSON/CMakeLists.txt b/Tests/RunCMake/JSON/CMakeLists.txt
new file mode 100644
index 0000000..576787a
--- /dev/null
+++ b/Tests/RunCMake/JSON/CMakeLists.txt
@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.5)
+project(${RunCMake_TEST} NONE) # or languages needed
+include(${RunCMake_TEST}.cmake)
diff --git a/Tests/RunCMake/JSON/JSON-check.cmake b/Tests/RunCMake/JSON/JSON-check.cmake
new file mode 100644
index 0000000..ae723a4
--- /dev/null
+++ b/Tests/RunCMake/JSON/JSON-check.cmake
@@ -0,0 +1,30 @@
+# This file does a regex file compare on the generated
+# Android.mk files from the AndroidMK test
+
+macro(compare_file_to_expected file expected_file)
+ file(READ "${file}" JSON)
+ # clean up new lines
+ string(REGEX REPLACE "\r\n" "\n" JSON "${JSON}")
+ string(REGEX REPLACE "\n+$" "" JSON "${JSON}")
+ # read in the expected regex file
+ file(READ "${expected_file}" expected)
+ # clean up new lines
+ string(REGEX REPLACE "\r\n" "\n" expected "${expected}")
+ string(REGEX REPLACE "\n+$" "" expected "${expected}")
+ # compare the file to the expected regex and if there is not a match
+ # put an error message in RunCMake_TEST_FAILED
+ if(NOT "${JSON}" MATCHES "${expected}")
+ set(RunCMake_TEST_FAILED
+ "${file} does not match ${expected_file}:
+
+JSON contents = [\n${JSON}\n]
+Expected = [\n${expected}\n]")
+ endif()
+endmacro()
+
+compare_file_to_expected(
+ "${RunCMake_BINARY_DIR}/JSON-build/myexp.json"
+ "${RunCMake_TEST_SOURCE_DIR}/expectedBuildJSON.txt")
+compare_file_to_expected(
+ "${RunCMake_BINARY_DIR}/JSON-build/CMakeFiles/Export/share/myexp.json"
+ "${RunCMake_TEST_SOURCE_DIR}/expectedInstallJSON.txt")
diff --git a/Tests/RunCMake/JSON/JSON.cmake b/Tests/RunCMake/JSON/JSON.cmake
new file mode 100644
index 0000000..4e3b5c4
--- /dev/null
+++ b/Tests/RunCMake/JSON/JSON.cmake
@@ -0,0 +1,11 @@
+project(build)
+set(CMAKE_BUILD_TYPE Debug)
+add_library(foo foo.cxx)
+add_library(car foo.cxx)
+add_library(bar bar.c)
+add_library(dog foo.cxx)
+target_link_libraries(foo car bar dog debug -lm)
+export(TARGETS bar dog car foo JSON
+ ${build_BINARY_DIR}/myexp.json)
+install(TARGETS bar dog car foo DESTINATION lib EXPORT myexp)
+install(EXPORT_JSON myexp DESTINATION share)
diff --git a/Tests/RunCMake/JSON/RunCMakeTest.cmake b/Tests/RunCMake/JSON/RunCMakeTest.cmake
new file mode 100644
index 0000000..2156eee
--- /dev/null
+++ b/Tests/RunCMake/JSON/RunCMakeTest.cmake
@@ -0,0 +1,2 @@
+include(RunCMake)
+run_cmake(JSON)
diff --git a/Tests/RunCMake/JSON/bar.c b/Tests/RunCMake/JSON/bar.c
new file mode 100644
index 0000000..e1f4df6
--- /dev/null
+++ b/Tests/RunCMake/JSON/bar.c
@@ -0,0 +1,3 @@
+void bar(void)
+{
+}
diff --git a/Tests/RunCMake/JSON/expectedBuildJSON.txt b/Tests/RunCMake/JSON/expectedBuildJSON.txt
new file mode 100644
index 0000000..bbf67a5
--- /dev/null
+++ b/Tests/RunCMake/JSON/expectedBuildJSON.txt
@@ -0,0 +1,26 @@
+LOCAL_PATH.*call my-dir.*
+include.*CLEAR_VARS.*
+LOCAL_MODULE.*bar
+LOCAL_SRC_FILES.*bar.*
+include.*PREBUILT_STATIC_LIBRARY.*
+.*
+include.*CLEAR_VARS.*
+LOCAL_MODULE.*dog
+LOCAL_SRC_FILES.*.*dog.*
+LOCAL_HAS_CPP := true
+include.*PREBUILT_STATIC_LIBRARY.*
+.*
+include.*CLEAR_VARS.*
+LOCAL_MODULE.*car
+LOCAL_SRC_FILES.*.*car.*
+LOCAL_HAS_CPP := true
+include.*PREBUILT_STATIC_LIBRARY.*
+.*
+include.*CLEAR_VARS.*
+LOCAL_MODULE.*foo
+LOCAL_SRC_FILES.*.*foo.*
+LOCAL_CPP_FEATURES.*rtti exceptions
+LOCAL_STATIC_LIBRARIES.*car bar dog
+LOCAL_EXPORT_LDLIBS := -lm
+LOCAL_HAS_CPP := true
+include.*PREBUILT_STATIC_LIBRARY.*
diff --git a/Tests/RunCMake/JSON/expectedInstallJSON.txt b/Tests/RunCMake/JSON/expectedInstallJSON.txt
new file mode 100644
index 0000000..3515fb9
--- /dev/null
+++ b/Tests/RunCMake/JSON/expectedInstallJSON.txt
@@ -0,0 +1,28 @@
+LOCAL_PATH.*call my-dir.*
+_IMPORT_PREFIX.*LOCAL_PATH./../..
+
+include.*CLEAR_VARS.*
+LOCAL_MODULE.*bar
+LOCAL_SRC_FILES.*_IMPORT_PREFIX./lib.*bar.*
+include.*PREBUILT_STATIC_LIBRARY.*
+
+include.*CLEAR_VARS.
+LOCAL_MODULE.*dog
+LOCAL_SRC_FILES.*_IMPORT_PREFIX./lib.*dog.*
+LOCAL_HAS_CPP := true
+include.*PREBUILT_STATIC_LIBRARY.*
+
+include.*CLEAR_VARS.*
+LOCAL_MODULE.*car
+LOCAL_SRC_FILES.*_IMPORT_PREFIX./lib.*car.*
+LOCAL_HAS_CPP := true
+include.*PREBUILT_STATIC_LIBRARY.*
+
+include.*CLEAR_VARS.*
+LOCAL_MODULE.*foo
+LOCAL_SRC_FILES.*_IMPORT_PREFIX\)/lib.*foo.*
+LOCAL_CPP_FEATURES.*rtti exceptions
+LOCAL_STATIC_LIBRARIES.*car bar dog
+LOCAL_EXPORT_LDLIBS := -lm
+LOCAL_HAS_CPP := true
+include.*PREBUILT_STATIC_LIBRARY.*
diff --git a/Tests/RunCMake/JSON/foo.cxx b/Tests/RunCMake/JSON/foo.cxx
new file mode 100644
index 0000000..3695dc9
--- /dev/null
+++ b/Tests/RunCMake/JSON/foo.cxx
@@ -0,0 +1,3 @@
+void foo()
+{
+}
