| /* 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; |
| } |
| } |
