/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying

   file LICENSE.rst or https://cmake.org/licensing for details.  */

#include "cmComputeLinkInformation.h"

#include <algorithm>

#include <cctype>

#include <sstream>

#include <utility>

#include <cm/memory>

#include <cm/optional>

#include <cm/string_view>

#include <cmext/algorithm>

#include <cmext/string_view>

#include "cmComputeLinkDepends.h"

#include "cmGeneratorTarget.h"

#include "cmGlobalGenerator.h"

#include "cmLinkItem.h"

#include "cmList.h"

#include "cmListFileCache.h"

#include "cmLocalGenerator.h"

#include "cmMakefile.h"

#include "cmMessageType.h"

#include "cmOrderDirectories.h"

#include "cmPlaceholderExpander.h"

#include "cmSourceFile.h"

#include "cmState.h"

#include "cmStateTypes.h"

#include "cmStringAlgorithms.h"

#include "cmSystemTools.h"

#include "cmTarget.h"

#include "cmValue.h"

#include "cmXcFramework.h"

#include "cmake.h"

// #define CM_COMPUTE_LINK_INFO_DEBUG

/*

Notes about linking on various platforms:

------------------------------------------------------------------------------

Linux, FreeBSD, macOS, Sun, Windows:

Linking to libraries using the full path works fine.

------------------------------------------------------------------------------

On AIX, more work is needed.

  The "-bnoipath" option is needed.  From "man ld":

    Note: If you specify a shared object, or an archive file

    containing a shared object, with an absolute or relative path

    name, instead of with the -lName flag, the path name is

    included in the import file ID string in the loader section of

    the output file. You can override this behavior with the

    -bnoipath option.

      noipath

        For shared objects listed on the command-line, rather than

        specified with the -l flag, use a null path component when

        listing the shared object in the loader section of the

        output file. A null path component is always used for

        shared objects specified with the -l flag. This option

        does not affect the specification of a path component by

        using a line beginning with #! in an import file. The

        default is the ipath option.

  This prevents the full path specified on the compile line from being

  compiled directly into the binary.

  By default the linker places -L paths in the embedded runtime path.

  In order to implement CMake's RPATH interface correctly, we need the

  -blibpath:Path option.  From "man ld":

      libpath:Path

        Uses Path as the library path when writing the loader section

        of the output file. Path is neither checked for validity nor

        used when searching for libraries specified by the -l flag.

        Path overrides any library paths generated when the -L flag is

        used.

        If you do not specify any -L flags, or if you specify the

        nolibpath option, the default library path information is

        written in the loader section of the output file. The default

        library path information is the value of the LIBPATH

        environment variable if it is defined, and /usr/lib:/lib,

        otherwise.

  We can pass -Wl,-blibpath:/usr/lib:/lib always to avoid the -L stuff

  and not break when the user sets LIBPATH.  Then if we want to add an

  rpath we insert it into the option before /usr/lib.

------------------------------------------------------------------------------

On HP-UX, more work is needed.  There are differences between

versions.

ld: 92453-07 linker linker ld B.10.33 990520

  Linking with a full path works okay for static and shared libraries.

  The linker seems to always put the full path to where the library

  was found in the binary whether using a full path or -lfoo syntax.

  Transitive link dependencies work just fine due to the full paths.

  It has the "-l:libfoo.sl" option.  The +nodefaultrpath is accepted

  but not documented and does not seem to do anything.  There is no

  +forceload option.

ld: 92453-07 linker ld HP Itanium(R) B.12.41  IPF/IPF

  Linking with a full path works okay for static libraries.

  Linking with a full path works okay for shared libraries.  However

  dependent (transitive) libraries of those linked directly must be

  either found with an rpath stored in the direct dependencies or

  found in -L paths as if they were specified with "-l:libfoo.sl"

  (really "-l:<soname>").  The search matches that of the dynamic

  loader but only with -L paths.  In other words, if we have an

  executable that links to shared library bar which links to shared

  library foo, the link line for the exe must contain

    /dir/with/bar/libbar.sl -L/dir/with/foo

  It does not matter whether the exe wants to link to foo directly or

  whether /dir/with/foo/libfoo.sl is listed.  The -L path must still

  be present.  It should match the runtime path computed for the

  executable taking all directly and transitively linked libraries

  into account.

  The "+nodefaultrpath" option should be used to avoid getting -L

  paths in the rpath unless we add our own rpath with +b.  This means

  that skip-build-rpath should use this option.

  See documentation in "man ld", "man dld.so", and

  http://docs.hp.com/en/B2355-90968/creatingandusinglibraries.htm

    +[no]defaultrpath

      +defaultrpath is the default.  Include any paths that are

      specified with -L in the embedded path, unless you specify the

      +b option.  If you use +b, only the path list specified by +b is

      in the embedded path.

      The +nodefaultrpath option removes all library paths that were

      specified with the -L option from the embedded path.  The linker

      searches the library paths specified by the -L option at link

      time.  At run time, the only library paths searched are those

      specified by the environment variables LD_LIBRARY_PATH and

      SHLIB_PATH, library paths specified by the +b linker option, and

      finally the default library paths.

    +rpathfirst

      This option will cause the paths specified in RPATH (embedded

      path) to be used before the paths specified in LD_LIBRARY_PATH

      or SHLIB_PATH, in searching for shared libraries.  This changes

      the default search order of LD_LIBRARY_PATH, SHLIB_PATH, and

      RPATH (embedded path).

------------------------------------------------------------------------------

Notes about dependent (transitive) shared libraries:

On non-Windows systems shared libraries may have transitive

dependencies.  In order to support LINK_INTERFACE_LIBRARIES we must

support linking to a shared library without listing all the libraries

to which it links.  Some linkers want to be able to find the

transitive dependencies (dependent libraries) of shared libraries

listed on the command line.

  - On Windows, DLLs are not directly linked, and the import libraries

    have no transitive dependencies.

  - On Mac OS X 10.5 and above transitive dependencies are not needed.

  - On Mac OS X 10.4 and below we need to actually list the dependencies.

    Otherwise when using -isysroot for universal binaries it cannot

    find the dependent libraries.  Listing them on the command line

    tells the linker where to find them, but unfortunately also links

    the library.

  - On HP-UX, the linker wants to find the transitive dependencies of

    shared libraries in the -L paths even if the dependent libraries

    are given on the link line.

  - On AIX the transitive dependencies are not needed.

  - On SGI, the linker wants to find the transitive dependencies of

    shared libraries in the -L paths if they are not given on the link

    line.  Transitive linking can be disabled using the options

      -no_transitive_link -Wl,-no_transitive_link

    which disable it.  Both options must be given when invoking the

    linker through the compiler.

  - On Sun, the linker wants to find the transitive dependencies of

    shared libraries in the -L paths if they are not given on the link

    line.

  - On Linux, FreeBSD, and QNX:

    The linker wants to find the transitive dependencies of shared

    libraries in the "-rpath-link" paths option if they have not been

    given on the link line.  The option is like rpath but just for

    link time:

      -Wl,-rpath-link,"/path1:/path2"

For -rpath-link, we need a separate runtime path ordering pass

including just the dependent libraries that are not linked.

For -L paths on non-HP, we can do the same thing as with rpath-link

but put the results in -L paths.  The paths should be listed at the

end to avoid conflicting with user search paths (?).

For -L paths on HP, we should do a runtime path ordering pass with

all libraries, both linked and non-linked.  Even dependent

libraries that are also linked need to be listed in -L paths.

In our implementation we add all dependent libraries to the runtime

path computation.  Then the auto-generated RPATH will find everything.

------------------------------------------------------------------------------

Notes about shared libraries with not builtin soname:

Some UNIX shared libraries may be created with no builtin soname.  On

some platforms such libraries cannot be linked using the path to their

location because the linker will copy the path into the field used to

find the library at runtime.

  Apple:    ../libfoo.dylib  ==>  libfoo.dylib  # ok, uses install_name

  SGI:      ../libfoo.so     ==>  libfoo.so     # ok

  AIX:      ../libfoo.so     ==>  libfoo.so     # ok

  Linux:    ../libfoo.so     ==>  ../libfoo.so  # bad

  HP-UX:    ../libfoo.so     ==>  ../libfoo.so  # bad

  Sun:      ../libfoo.so     ==>  ../libfoo.so  # bad

  FreeBSD:  ../libfoo.so     ==>  ../libfoo.so  # bad

In order to link these libraries we need to use the old-style split

into -L.. and -lfoo options.  This should be fairly safe because most

problems with -lfoo options were related to selecting shared libraries

instead of static but in this case we want the shared lib.  Link

directory ordering needs to be done to make sure these shared

libraries are found first.  There should be very few restrictions

because this need be done only for shared libraries without soname-s.

*/

cmComputeLinkInformation::cmComputeLinkInformation(

  cmGeneratorTarget const* target, std::string const& config)

  // Store context information.

  : Target(target)

  , Makefile(target->Target->GetMakefile())

  , GlobalGenerator(target->GetLocalGenerator()->GetGlobalGenerator())

  , CMakeInstance(this->GlobalGenerator->GetCMakeInstance())

  // The configuration being linked.

  , Config(config)

{

  // Check whether to recognize OpenBSD-style library versioned names.

  this->IsOpenBSD = this->Makefile->GetState()->GetGlobalPropertyAsBool(

    "FIND_LIBRARY_USE_OPENBSD_VERSIONING");

  // Allocate internals.

  this->OrderLinkerSearchPath = cm::make_unique<cmOrderDirectories>(

    this->GlobalGenerator, target, "linker search path");

  this->OrderRuntimeSearchPath = cm::make_unique<cmOrderDirectories>(

    this->GlobalGenerator, target, "runtime search path");

  // Get the language used for linking this target.

  this->LinkLanguage = this->Target->GetLinkerLanguage(config);

  if (this->LinkLanguage.empty()) {

    // The Compute method will do nothing, so skip the rest of the

    // initialization.

    return;

  }

  // Check whether we should skip dependencies on shared library files.

  this->LinkDependsNoShared =

    this->Target->GetPropertyAsBool("LINK_DEPENDS_NO_SHARED");

  // On platforms without import libraries there may be a special flag

  // to use when creating a plugin (module) that obtains symbols from

  // the program that will load it.

  if (!this->Target->IsDLLPlatform() &&

      this->Target->GetType() == cmStateEnums::MODULE_LIBRARY) {

    std::string loader_flag_var =

      cmStrCat("CMAKE_SHARED_MODULE_LOADER_", this->LinkLanguage, "_FLAG");

    this->LoaderFlag = this->Makefile->GetDefinition(loader_flag_var);

  }

  // Get options needed to link libraries.

  if (cmValue flag = this->Makefile->GetDefinition(

        cmStrCat("CMAKE_", this->LinkLanguage, "_LINK_LIBRARY_FLAG"))) {

    this->LibLinkFlag = *flag;

  } else {

    this->LibLinkFlag =

      this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_FLAG");

  }

  if (cmValue flag = this->Makefile->GetDefinition(

        cmStrCat("CMAKE_", this->LinkLanguage, "_LINK_LIBRARY_FILE_FLAG"))) {

    this->LibLinkFileFlag = *flag;

  } else {

    this->LibLinkFileFlag =

      this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_FILE_FLAG");

  }

  if (cmValue suffix = this->Makefile->GetDefinition(

        cmStrCat("CMAKE_", this->LinkLanguage, "_LINK_LIBRARY_SUFFIX"))) {

    this->LibLinkSuffix = *suffix;

  } else {

    this->LibLinkSuffix =

      this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_SUFFIX");

  }

  if (cmValue flag = this->Makefile->GetDefinition(

        cmStrCat("CMAKE_", this->LinkLanguage, "_LINK_OBJECT_FILE_FLAG"))) {

    this->ObjLinkFileFlag = *flag;

  } else {

    this->ObjLinkFileFlag =

      this->Makefile->GetSafeDefinition("CMAKE_LINK_OBJECT_FILE_FLAG");

  }

  // Get options needed to specify RPATHs.

  this->RuntimeUseChrpath = false;

  if (this->Target->GetType() != cmStateEnums::STATIC_LIBRARY) {

    char const* tType = ((this->Target->GetType() == cmStateEnums::EXECUTABLE)

                           ? "EXECUTABLE"

                           : "SHARED_LIBRARY");

    std::string rtVar =

      cmStrCat("CMAKE_", tType, "_RUNTIME_", this->LinkLanguage, "_FLAG");

    std::string rtSepVar = cmStrCat(rtVar, "_SEP");

    this->RuntimeFlag = this->Makefile->GetSafeDefinition(rtVar);

    this->RuntimeSep = this->Makefile->GetSafeDefinition(rtSepVar);

    this->RuntimeAlways = (this->Makefile->GetSafeDefinition(

      "CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH"));

    this->RuntimeUseChrpath = this->Target->IsChrpathUsed(config);

    // Get options needed to help find dependent libraries.

    std::string rlVar =

      cmStrCat("CMAKE_", tType, "_RPATH_LINK_", this->LinkLanguage, "_FLAG");

    this->RPathLinkFlag = this->Makefile->GetSafeDefinition(rlVar);

  }

  // Check if we need to include the runtime search path at link time.

  {

    std::string var = cmStrCat("CMAKE_SHARED_LIBRARY_LINK_",

                               this->LinkLanguage, "_WITH_RUNTIME_PATH");

    this->LinkWithRuntimePath = this->Makefile->IsOn(var);

  }

  // Define some Feature descriptors to handle standard library and object link

  if (!this->GetLibLinkFileFlag().empty()) {

    this->LibraryFeatureDescriptors.emplace(

      "__CMAKE_LINK_LIBRARY",

      LibraryFeatureDescriptor{

        "__CMAKE_LINK_LIBRARY",

        cmStrCat(this->GetLibLinkFileFlag(), "<LIBRARY>") });

  }

  if (!this->GetObjLinkFileFlag().empty()) {

    this->LibraryFeatureDescriptors.emplace(

      "__CMAKE_LINK_OBJECT",

      LibraryFeatureDescriptor{

        "__CMAKE_LINK_OBJECT",

        cmStrCat(this->GetObjLinkFileFlag(), "<LIBRARY>") });

  }

  if (!this->LoaderFlag->empty()) {

    // Define a Feature descriptor for the link of an executable with exports

    this->LibraryFeatureDescriptors.emplace(

      "__CMAKE_LINK_EXECUTABLE",

      LibraryFeatureDescriptor{ "__CMAKE_LINK_EXECUTABLE",

                                cmStrCat(*this->LoaderFlag, "<LIBRARY>") });

  }

  // To link framework using a full path

  this->LibraryFeatureDescriptors.emplace(

    "__CMAKE_LINK_FRAMEWORK",

    LibraryFeatureDescriptor{ "__CMAKE_LINK_FRAMEWORK", "<LIBRARY>" });

  // To link xcframework using a full path

  this->LibraryFeatureDescriptors.emplace(

    "__CMAKE_LINK_XCFRAMEWORK",

    LibraryFeatureDescriptor{ "__CMAKE_LINK_XCFRAMEWORK", "<LIBRARY>" });

  // Check the platform policy for missing soname case.

  this->NoSONameUsesPath =

    this->Makefile->IsOn("CMAKE_PLATFORM_USES_PATH_WHEN_NO_SONAME");

  // Get link type information.

  this->ComputeLinkTypeInfo();

  // Setup the link item parser.

  this->ComputeItemParserInfo();

  // Setup framework support.

  this->ComputeFrameworkInfo();

  // Choose a mode for dealing with shared library dependencies.

  this->SharedDependencyMode = SharedDepModeNone;

  if (this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_FILES")) {

    this->SharedDependencyMode = SharedDepModeLink;

  } else if (this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_DIRS")) {

    this->SharedDependencyMode = SharedDepModeLibDir;

  } else if (!this->RPathLinkFlag.empty()) {

    this->SharedDependencyMode = SharedDepModeDir;

    this->OrderDependentRPath = cm::make_unique<cmOrderDirectories>(

      this->GlobalGenerator, target, "dependent library path");

  }

  // Add the search path entries requested by the user to path ordering.

  std::vector<std::string> directories;

  this->Target->GetLinkDirectories(directories, config, this->LinkLanguage);

  this->OrderLinkerSearchPath->AddUserDirectories(directories);

  this->OrderRuntimeSearchPath->AddUserDirectories(directories);

  // Set up the implicit link directories.

  this->LoadImplicitLinkInfo();

  this->OrderLinkerSearchPath->SetImplicitDirectories(this->ImplicitLinkDirs);

  this->OrderRuntimeSearchPath->SetImplicitDirectories(this->ImplicitLinkDirs);

  if (this->OrderDependentRPath) {

    this->OrderDependentRPath->SetImplicitDirectories(this->ImplicitLinkDirs);

    this->OrderDependentRPath->AddLanguageDirectories(this->RuntimeLinkDirs);

  }

}

cmComputeLinkInformation::~cmComputeLinkInformation() = default;

namespace {

std::string const& DEFAULT = cmComputeLinkDepends::LinkEntry::DEFAULT;

}

void cmComputeLinkInformation::AppendValues(

  std::string& result, std::vector<BT<std::string>>& values)

{

  for (BT<std::string>& p : values) {

    if (result.empty()) {

      result.append(" ");

    }

    result.append(p.Value);

  }

}

cmComputeLinkInformation::ItemVector const&

cmComputeLinkInformation::GetItems() const

{

  return this->Items;

}

std::vector<std::string> const& cmComputeLinkInformation::GetDirectories()

  const

{

  return this->OrderLinkerSearchPath->GetOrderedDirectories();

}

std::vector<BT<std::string>>

cmComputeLinkInformation::GetDirectoriesWithBacktraces()

{

  std::vector<BT<std::string>> directoriesWithBacktraces;

  std::vector<BT<std::string>> targetLinkDirectories =

    this->Target->GetLinkDirectories(this->Config, this->LinkLanguage);

  std::vector<std::string> const& orderedDirectories = this->GetDirectories();

  for (std::string const& dir : orderedDirectories) {

    auto result = std::find(targetLinkDirectories.begin(),

                            targetLinkDirectories.end(), dir);

    if (result != targetLinkDirectories.end()) {

      directoriesWithBacktraces.emplace_back(std::move(*result));

    } else {

      directoriesWithBacktraces.emplace_back(dir);

    }

  }

  return directoriesWithBacktraces;

}

std::string cmComputeLinkInformation::GetRPathLinkString() const

{

  // If there is no separate linker runtime search flag (-rpath-link)

  // there is no reason to compute a string.

  if (!this->OrderDependentRPath) {

    return "";

  }

  // Construct the linker runtime search path. These MUST NOT contain tokens

  // such as $ORIGIN, see https://sourceware.org/bugzilla/show_bug.cgi?id=16936

  return cmJoin(this->OrderDependentRPath->GetOrderedDirectories(), ":");

}

std::vector<std::string> const& cmComputeLinkInformation::GetDepends() const

{

  return this->Depends;

}

std::vector<std::string> const& cmComputeLinkInformation::GetFrameworkPaths()

  const

{

  return this->FrameworkPaths;

}

std::set<std::string> const&

cmComputeLinkInformation::GetFrameworkPathsEmitted() const

{

  return this->FrameworkPathsEmitted;

}

std::vector<std::string> const&

cmComputeLinkInformation::GetXcFrameworkHeaderPaths() const

{

  return this->XcFrameworkHeaderPaths;

}

std::set<cmGeneratorTarget const*> const&

cmComputeLinkInformation::GetSharedLibrariesLinked() const

{

  return this->SharedLibrariesLinked;

}

std::vector<cmGeneratorTarget const*> const&

cmComputeLinkInformation::GetExternalObjectTargets() const

{

  return this->ExternalObjectTargets;

}

bool cmComputeLinkInformation::Compute()

{

  // Skip targets that do not link or have link-like information consumers may

  // need (namely modules).

  if (!(this->Target->GetType() == cmStateEnums::EXECUTABLE ||

        this->Target->GetType() == cmStateEnums::SHARED_LIBRARY ||

        this->Target->GetType() == cmStateEnums::MODULE_LIBRARY ||

        this->Target->GetType() == cmStateEnums::STATIC_LIBRARY ||

        (this->Target->CanCompileSources() &&

         (this->Target->HaveCxxModuleSupport(this->Config) ==

            cmGeneratorTarget::Cxx20SupportLevel::Supported ||

          this->Target->HaveFortranSources())))) {

    return false;

  }

  // We require a link language for the target.

  if (this->LinkLanguage.empty()) {

    cmSystemTools::Error(

      "CMake can not determine linker language for target: " +

      this->Target->GetName());

    return false;

  }

  LinkLibrariesStrategy strategy = LinkLibrariesStrategy::REORDER_MINIMALLY;

  if (cmValue s = this->Target->GetProperty("LINK_LIBRARIES_STRATEGY")) {

    if (*s == "REORDER_MINIMALLY"_s) {

      strategy = LinkLibrariesStrategy::REORDER_MINIMALLY;

    } else if (*s == "REORDER_FREELY"_s) {

      strategy = LinkLibrariesStrategy::REORDER_FREELY;

    } else {

      this->CMakeInstance->IssueMessage(

        MessageType::FATAL_ERROR,

        cmStrCat("LINK_LIBRARIES_STRATEGY value '", *s,

                 "' is not recognized."),

        this->Target->GetBacktrace());

      return false;

    }

  }

  // Compute the ordered link line items.

  cmComputeLinkDepends cld(this->Target, this->Config, this->LinkLanguage,

                           strategy);

  cmComputeLinkDepends::EntryVector const& linkEntries = cld.Compute();

  FeatureDescriptor const* currentFeature = nullptr;

  // Add the link line items.

  for (cmComputeLinkDepends::LinkEntry const& linkEntry : linkEntries) {

    if (linkEntry.Kind == cmComputeLinkDepends::LinkEntry::Group) {

      auto const& groupFeature = this->GetGroupFeature(linkEntry.Feature);

      if (groupFeature.Supported) {

        if (linkEntry.Item.Value == "</LINK_GROUP>" && currentFeature) {

          // emit feature suffix, if any

          if (!currentFeature->Suffix.empty()) {

            this->Items.emplace_back(

              BT<std::string>{ currentFeature->Suffix,

                               this->Items.back().Value.Backtrace },

              ItemIsPath::No);

          }

          currentFeature = nullptr;

        }

        this->Items.emplace_back(

          BT<std::string>{ linkEntry.Item.Value == "<LINK_GROUP>"

                             ? groupFeature.Prefix

                             : groupFeature.Suffix,

                           linkEntry.Item.Backtrace },

          ItemIsPath::No);

      }

      continue;

    }

    if (currentFeature && linkEntry.Feature != currentFeature->Name) {

      // emit feature suffix, if any

      if (!currentFeature->Suffix.empty()) {

        this->Items.emplace_back(

          BT<std::string>{ currentFeature->Suffix,

                           this->Items.back().Value.Backtrace },

          ItemIsPath::No);

      }

      currentFeature = nullptr;

    }

    if (linkEntry.Feature != DEFAULT &&

        (!currentFeature || linkEntry.Feature != currentFeature->Name)) {

      if (!this->AddLibraryFeature(linkEntry.Feature)) {

        continue;

      }

      currentFeature = this->FindLibraryFeature(linkEntry.Feature);

      // emit feature prefix, if any

      if (!currentFeature->Prefix.empty()) {

        this->Items.emplace_back(

          BT<std::string>{ currentFeature->Prefix, linkEntry.Item.Backtrace },

          ItemIsPath::No);

      }

    }

    if (linkEntry.Kind == cmComputeLinkDepends::LinkEntry::SharedDep) {

      this->AddSharedDepItem(linkEntry);

    } else {

      this->AddItem(linkEntry);

    }

  }

  if (currentFeature) {

    // emit feature suffix, if any

    if (!currentFeature->Suffix.empty()) {

      this->Items.emplace_back(

        BT<std::string>{ currentFeature->Suffix,

                         this->Items.back().Value.Backtrace },

        ItemIsPath::No);

    }

  }

  // Restore the target link type so the correct system runtime

  // libraries are found.

  cmValue lss = this->Target->GetProperty("LINK_SEARCH_END_STATIC");

  if (lss.IsOn()) {

    this->SetCurrentLinkType(LinkStatic);

  } else {

    this->SetCurrentLinkType(this->StartLinkType);

  }

  // Add implicit language runtime libraries and directories.

  this->AddImplicitLinkInfo();

  // Record targets referenced by $<TARGET_OBJECTS:...> sources.

  this->AddExternalObjectTargets();

  return true;

}

namespace {

void FinalizeFeatureFormat(std::string& format, std::string const& activeTag,

                           std::string const& otherTag)

{

  auto pos = format.find(otherTag);

  if (pos != std::string::npos) {

    format.erase(pos, format.find('}', pos) - pos + 1);

  }

  pos = format.find(activeTag);

  if (pos != std::string::npos) {

    format.erase(pos, activeTag.length());

    pos = format.find('}', pos);

    if (pos != std::string::npos) {

      format.erase(pos, 1);

    }

  }

}

bool IsValidFeatureFormat(std::string const& format)

{

  return format.find("<LIBRARY>") != std::string::npos ||

    format.find("<LIB_ITEM>") != std::string::npos ||

    format.find("<LINK_ITEM>") != std::string::npos;

}

class FeaturePlaceHolderExpander : public cmPlaceholderExpander

{

public:

  FeaturePlaceHolderExpander(std::string const* library,

                             std::string const* libItem = nullptr,

                             std::string const* linkItem = nullptr)

    : Library(library)

    , LibItem(libItem)

    , LinkItem(linkItem)

  {

  }

private:

  std::string ExpandVariable(std::string const& variable) override

  {

    if (this->Library && variable == "LIBRARY") {

      return *this->Library;

    }

    if (this->LibItem && variable == "LIB_ITEM") {

      return *this->LibItem;

    }

    if (this->LinkItem && variable == "LINK_ITEM") {

      return *this->LinkItem;

    }

    return variable;

  }

  std::string const* Library = nullptr;

  std::string const* LibItem = nullptr;

  std::string const* LinkItem = nullptr;

};

}

cmComputeLinkInformation::FeatureDescriptor::FeatureDescriptor(

  std::string name, std::string itemFormat)

  : Name(std::move(name))

  , Supported(true)

  , ItemPathFormat(std::move(itemFormat))

  , ItemNameFormat(this->ItemPathFormat)

{

}

cmComputeLinkInformation::FeatureDescriptor::FeatureDescriptor(

  std::string name, std::string itemPathFormat, std::string itemNameFormat)

  : Name(std::move(name))

  , Supported(true)

  , ItemPathFormat(std::move(itemPathFormat))

  , ItemNameFormat(std::move(itemNameFormat))

{

}

cmComputeLinkInformation::FeatureDescriptor::FeatureDescriptor(

  std::string name, std::string prefix, std::string itemPathFormat,

  std::string itemNameFormat, std::string suffix)

  : Name(std::move(name))

  , Supported(true)

  , Prefix(std::move(prefix))

  , Suffix(std::move(suffix))

  , ItemPathFormat(std::move(itemPathFormat))

  , ItemNameFormat(std::move(itemNameFormat))

{

}

cmComputeLinkInformation::FeatureDescriptor::FeatureDescriptor(

  std::string name, std::string prefix, std::string suffix, bool)

  : Name(std::move(name))

  , Supported(true)

  , Prefix(std::move(prefix))

  , Suffix(std::move(suffix))

{

}

std::string cmComputeLinkInformation::FeatureDescriptor::GetDecoratedItem(

  std::string const& library, ItemIsPath isPath) const

{

  auto format =

    isPath == ItemIsPath::Yes ? this->ItemPathFormat : this->ItemNameFormat;

  // replace <LIBRARY>, <LIB_ITEM> and <LINK_ITEM> patterns with library path

  FeaturePlaceHolderExpander expander(&library, &library, &library);

  return expander.ExpandVariables(format);

}

std::string cmComputeLinkInformation::FeatureDescriptor::GetDecoratedItem(

  std::string const& library, std::string const& libItem,

  std::string const& linkItem, ItemIsPath isPath) const

{

  auto format =

    isPath == ItemIsPath::Yes ? this->ItemPathFormat : this->ItemNameFormat;

  // replace <LIBRARY>, <LIB_ITEM> and <LINK_ITEM> patterns

  FeaturePlaceHolderExpander expander(&library, &libItem, &linkItem);

  return expander.ExpandVariables(format);

}

cmComputeLinkInformation::LibraryFeatureDescriptor::LibraryFeatureDescriptor(

  std::string name, std::string itemFormat)

  : FeatureDescriptor(std::move(name), std::move(itemFormat))

{

}

cmComputeLinkInformation::LibraryFeatureDescriptor::LibraryFeatureDescriptor(

  std::string name, std::string itemPathFormat, std::string itemNameFormat)

  : FeatureDescriptor(std::move(name), std::move(itemPathFormat),

                      std::move(itemNameFormat))

{

}

cmComputeLinkInformation::LibraryFeatureDescriptor::LibraryFeatureDescriptor(

  std::string name, std::string prefix, std::string itemPathFormat,

  std::string itemNameFormat, std::string suffix)

  : FeatureDescriptor(std::move(name), std::move(prefix),

                      std::move(itemPathFormat), std::move(itemNameFormat),

                      std::move(suffix))

{

}

bool cmComputeLinkInformation::AddLibraryFeature(std::string const& feature)

{

  auto it = this->LibraryFeatureDescriptors.find(feature);

  if (it != this->LibraryFeatureDescriptors.end()) {

    return it->second.Supported;

  }

  auto featureName =

    cmStrCat("CMAKE_", this->LinkLanguage, "_LINK_LIBRARY_USING_", feature);

  cmValue featureSupported =

    this->Makefile->GetDefinition(cmStrCat(featureName, "_SUPPORTED"));

  if (!featureSupported) {

    // language specific variable is not defined, fallback to the more generic

    // one

    featureName = cmStrCat("CMAKE_LINK_LIBRARY_USING_", feature);

    featureSupported =

      this->Makefile->GetDefinition(cmStrCat(featureName, "_SUPPORTED"));

  }

  if (!featureSupported.IsOn()) {

    this->LibraryFeatureDescriptors.emplace(feature, FeatureDescriptor{});

    this->CMakeInstance->IssueMessage(

      MessageType::FATAL_ERROR,

      cmStrCat(

        "Feature '", feature,

        "', specified through generator-expression '$<LINK_LIBRARY>' to "

        "link target '",

        this->Target->GetName(), "', is not supported for the '",

        this->LinkLanguage, "' link language."),

      this->Target->GetBacktrace());

    return false;

  }

  cmValue langFeature = this->Makefile->GetDefinition(featureName);

  if (!langFeature) {

    this->LibraryFeatureDescriptors.emplace(feature, FeatureDescriptor{});

    this->CMakeInstance->IssueMessage(

      MessageType::FATAL_ERROR,

      cmStrCat(

        "Feature '", feature,

        "', specified through generator-expression '$<LINK_LIBRARY>' to "

        "link target '",

        this->Target->GetName(), "', is not defined for the '",

        this->LinkLanguage, "' link language."),

      this->Target->GetBacktrace());

    return false;

  }

  auto items = cmExpandListWithBacktrace(

    *langFeature, this->Target->GetBacktrace(), cmList::EmptyElements::Yes);

  if ((items.size() == 1 && !IsValidFeatureFormat(items.front().Value)) ||

      (items.size() == 3 && !IsValidFeatureFormat(items[1].Value))) {

    this->LibraryFeatureDescriptors.emplace(feature, FeatureDescriptor{});

    this->CMakeInstance->IssueMessage(

      MessageType::FATAL_ERROR,

      cmStrCat("Feature '", feature, "', specified by variable '", featureName,

               "', is malformed (\"<LIBRARY>\", \"<LIB_ITEM>\", or "

               "\"<LINK_ITEM>\" patterns "

               "are missing) and cannot be used to link target '",

               this->Target->GetName(), "'."),

      this->Target->GetBacktrace());

    return false;

  }

  // now, handle possible "PATH{}" and "NAME{}" patterns

  if (items.size() == 1) {

    items.push_back(items.front());

    FinalizeFeatureFormat(items[0].Value, "PATH{", "NAME{");

    FinalizeFeatureFormat(items[1].Value, "NAME{", "PATH{");

  } else if (items.size() == 3) {

    items.insert(items.begin() + 1, items[1]);

    FinalizeFeatureFormat(items[1].Value, "PATH{", "NAME{");

    FinalizeFeatureFormat(items[2].Value, "NAME{", "PATH{");

  } else {

    this->LibraryFeatureDescriptors.emplace(feature, FeatureDescriptor{});

    this->CMakeInstance->IssueMessage(

      MessageType::FATAL_ERROR,

      cmStrCat("Feature '", feature, "', specified by variable '", featureName,

               "', is malformed (wrong number of elements) and cannot be used "

               "to link target '",

               this->Target->GetName(), "'."),

      this->Target->GetBacktrace());

    return false;

  }

  if ((items.size() == 2 && !IsValidFeatureFormat(items[0].Value)) ||

      (items.size() == 4 && !IsValidFeatureFormat(items[1].Value))) {

    // PATH{} has wrong format

    this->LibraryFeatureDescriptors.emplace(feature, FeatureDescriptor{});

    this->CMakeInstance->IssueMessage(

      MessageType::FATAL_ERROR,

      cmStrCat("Feature '", feature, "', specified by variable '", featureName,

               "', is malformed (\"<LIBRARY>\", \"<LIB_ITEM>\", or "

               "\"<LINK_ITEM>\" patterns "

               "are missing for \"PATH{}\" alternative) and cannot be used to "

               "link target '",

               this->Target->GetName(), "'."),

      this->Target->GetBacktrace());

    return false;

  }

  if ((items.size() == 2 && !IsValidFeatureFormat(items[1].Value)) ||

      (items.size() == 4 && !IsValidFeatureFormat(items[2].Value))) {

    // NAME{} has wrong format

    this->LibraryFeatureDescriptors.emplace(feature, FeatureDescriptor{});

    this->CMakeInstance->IssueMessage(

      MessageType::FATAL_ERROR,

      cmStrCat("Feature '", feature, "', specified by variable '", featureName,

               "', is malformed (\"<LIBRARY>\", \"<LIB_ITEM>\", or "

               "\"<LINK_ITEM>\" patterns "

               "are missing for \"NAME{}\" alternative) and cannot be used to "

               "link target '",

               this->Target->GetName(), "'."),

      this->Target->GetBacktrace());

    return false;

  }

  // replace LINKER: pattern

  this->Target->ResolveLinkerWrapper(items, this->LinkLanguage, true);

  if (items.size() == 2) {

    this->LibraryFeatureDescriptors.emplace(

      feature,

      LibraryFeatureDescriptor{ feature, items[0].Value, items[1].Value });

  } else {

    this->LibraryFeatureDescriptors.emplace(

      feature,

      LibraryFeatureDescriptor{ feature, items[0].Value, items[1].Value,

                                items[2].Value, items[3].Value });

  }

  return true;

}

cmComputeLinkInformation::FeatureDescriptor const&

cmComputeLinkInformation::GetLibraryFeature(std::string const& feature) const

{

  return this->LibraryFeatureDescriptors.find(feature)->second;

}

cmComputeLinkInformation::FeatureDescriptor const*

cmComputeLinkInformation::FindLibraryFeature(std::string const& feature) const

{

  auto it = this->LibraryFeatureDescriptors.find(feature);

  if (it == this->LibraryFeatureDescriptors.end()) {

    return nullptr;

  }

  return &it->second;

}