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

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

#include "cmInstallCommand.h"

#include <algorithm>

#include <cassert>

#include <cstddef>

#include <iterator>

#include <map>

#include <set>

#include <utility>

#include <cm/memory>

#include <cm/optional>

#include <cm/string_view>

#include <cmext/string_view>

#include "cmsys/Glob.hxx"

#include "cmArgumentParser.h"

#include "cmArgumentParserTypes.h"

#include "cmCMakePath.h"

#include "cmDiagnosticContext.h"

#include "cmDiagnostics.h"

#include "cmExecutionStatus.h"

#include "cmExperimental.h"

#include "cmExportSet.h"

#include "cmGeneratorExpression.h"

#include "cmGlobalGenerator.h"

#include "cmInstallAndroidMKExportGenerator.h"

#include "cmInstallCMakeConfigExportGenerator.h"

#include "cmInstallCommandArguments.h"

#include "cmInstallCxxModuleBmiGenerator.h"

#include "cmInstallDirectoryGenerator.h"

#include "cmInstallDirs.h"

#include "cmInstallFileSetGenerator.h"

#include "cmInstallFilesGenerator.h"

#include "cmInstallGenerator.h"

#include "cmInstallGetRuntimeDependenciesGenerator.h"

#include "cmInstallImportedRuntimeArtifactsGenerator.h"

#include "cmInstallPackageInfoExportGenerator.h"

#include "cmInstallRuntimeDependencySet.h"

#include "cmInstallRuntimeDependencySetGenerator.h"

#include "cmInstallSbomGenerator.h"

#include "cmInstallScriptGenerator.h"

#include "cmInstallTargetGenerator.h"

#include "cmList.h"

#include "cmMakefile.h"

#include "cmMessageType.h"

#include "cmPackageInfoArguments.h"

#include "cmPolicies.h"

#include "cmRange.h"

#include "cmRuntimeDependencyArchive.h"

#include "cmSbomArguments.h"

#include "cmStateTypes.h"

#include "cmStringAlgorithms.h"

#include "cmSubcommandTable.h"

#include "cmSystemTools.h"

#include "cmTarget.h"

#include "cmTargetExport.h"

#include "cmValue.h"

namespace {

struct RuntimeDependenciesArgs

{

  ArgumentParser::MaybeEmpty<std::vector<std::string>> Directories;

  ArgumentParser::MaybeEmpty<std::vector<std::string>> PreIncludeRegexes;

  ArgumentParser::MaybeEmpty<std::vector<std::string>> PreExcludeRegexes;

  ArgumentParser::MaybeEmpty<std::vector<std::string>> PostIncludeRegexes;

  ArgumentParser::MaybeEmpty<std::vector<std::string>> PostExcludeRegexes;

  ArgumentParser::MaybeEmpty<std::vector<std::string>> PostIncludeFiles;

  ArgumentParser::MaybeEmpty<std::vector<std::string>> PostExcludeFiles;

};

auto const RuntimeDependenciesArgHelper =

  cmArgumentParser<RuntimeDependenciesArgs>{}

    .Bind("DIRECTORIES"_s, &RuntimeDependenciesArgs::Directories)

    .Bind("PRE_INCLUDE_REGEXES"_s, &RuntimeDependenciesArgs::PreIncludeRegexes)

    .Bind("PRE_EXCLUDE_REGEXES"_s, &RuntimeDependenciesArgs::PreExcludeRegexes)

    .Bind("POST_INCLUDE_REGEXES"_s,

          &RuntimeDependenciesArgs::PostIncludeRegexes)

    .Bind("POST_EXCLUDE_REGEXES"_s,

          &RuntimeDependenciesArgs::PostExcludeRegexes)

    .Bind("POST_INCLUDE_FILES"_s, &RuntimeDependenciesArgs::PostIncludeFiles)

    .Bind("POST_EXCLUDE_FILES"_s, &RuntimeDependenciesArgs::PostExcludeFiles);

class Helper

{

public:

  Helper(cmExecutionStatus& status)

    : Status(status)

    , Makefile(&status.GetMakefile())

  {

    this->DefaultComponentName = this->Makefile->GetSafeDefinition(

      "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");

    if (this->DefaultComponentName == "<PROJECT_NAME>") {

      cmValue projectName = this->Makefile->GetDefinition("PROJECT_NAME");

      if (!projectName->empty()) {

        this->DefaultComponentName = projectName;

      } else {

        this->DefaultComponentName = "Unspecified";

      }

    }

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

      this->DefaultComponentName = "Unspecified";

    }

  }

  cmDiagnosticContext CaptureContext() const

  {

    return cmInstallGenerator::CaptureContext(this->Makefile);

  }

  void SetError(std::string const& err) { this->Status.SetError(err); }

  bool MakeFilesFullPath(char const* modeName,

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

                         std::vector<std::string>& absFiles);

  bool MakeFilesFullPath(char const* modeName, std::string const& basePath,

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

                         std::vector<std::string>& absFiles);

  std::string GetRuntimeDestination(

    cmInstallCommandArguments const* args) const;

  std::string GetArchiveDestination(

    cmInstallCommandArguments const* args) const;

  std::string GetLibraryDestination(

    cmInstallCommandArguments const* args) const;

  std::string GetCxxModulesBmiDestination(

    cmInstallCommandArguments const* args) const;

  std::string GetIncludeDestination(

    cmInstallCommandArguments const* args) const;

  std::string GetDestinationForType(cmInstallCommandArguments const* args,

                                    std::string const& type) const;

  cmExecutionStatus& Status;

  cmMakefile* Makefile;

  std::string DefaultComponentName;

};

std::unique_ptr<cmInstallTargetGenerator> CreateInstallTargetGenerator(

  cmTarget& target, cmInstallCommandArguments const& args, bool impLib,

  cmDiagnosticContext context, std::string const& destination,

  bool forceOpt = false, bool namelink = false)

{

  cmInstallGenerator::MessageLevel message =

    cmInstallGenerator::SelectMessageLevel(target.GetMakefile());

  target.SetHaveInstallRule(true);

  std::string const& component =

    namelink ? args.GetNamelinkComponent() : args.GetComponent();

  auto g = cm::make_unique<cmInstallTargetGenerator>(

    target.GetName(), destination, impLib, args.GetPermissions(),

    args.GetConfigurations(), component, message, args.GetExcludeFromAll(),

    args.GetOptional() || forceOpt, std::move(context));

  target.AddInstallGenerator(g.get());

  return g;

}

std::unique_ptr<cmInstallTargetGenerator> CreateInstallTargetGenerator(

  cmTarget& target, cmInstallCommandArguments const& args, bool impLib,

  cmDiagnosticContext context, bool forceOpt = false, bool namelink = false)

{

  return CreateInstallTargetGenerator(target, args, impLib, std::move(context),

                                      args.GetDestination(), forceOpt,

                                      namelink);

}

std::unique_ptr<cmInstallFilesGenerator> CreateInstallFilesGenerator(

  cmMakefile* mf, std::vector<std::string> const& absFiles,

  cmInstallCommandArguments const& args, bool programs,

  std::string const& destination)

{

  cmInstallGenerator::MessageLevel message =

    cmInstallGenerator::SelectMessageLevel(mf);

  return cm::make_unique<cmInstallFilesGenerator>(

    absFiles, destination, programs, args.GetPermissions(),

    args.GetConfigurations(), args.GetComponent(), message,

    args.GetExcludeFromAll(), args.GetRename(), args.GetOptional(),

    cmInstallGenerator::CaptureContext(mf));

}

std::unique_ptr<cmInstallFilesGenerator> CreateInstallFilesGenerator(

  cmMakefile* mf, std::vector<std::string> const& absFiles,

  cmInstallCommandArguments const& args, bool programs)

{

  return CreateInstallFilesGenerator(mf, absFiles, args, programs,

                                     args.GetDestination());

}

std::unique_ptr<cmInstallFileSetGenerator> CreateInstallFileSetGenerator(

  Helper& helper, cmTarget& target,

  cmInstallCommandFileSetArguments const& args)

{

  cmInstallGenerator::MessageLevel message =

    cmInstallGenerator::SelectMessageLevel(helper.Makefile);

  return cm::make_unique<cmInstallFileSetGenerator>(

    target.GetName(), args.GetFileSet(), args.GetDestination(),

    args.GetPermissions(), args.GetConfigurations(), args.GetComponent(),

    message, args.GetExcludeFromAll(), args.GetOptional(),

    helper.CaptureContext());

}

void AddInstallRuntimeDependenciesGenerator(

  Helper& helper, cmInstallRuntimeDependencySet* runtimeDependencySet,

  cmInstallCommandArguments const& runtimeArgs,

  cmInstallCommandArguments const& libraryArgs,

  cmInstallCommandArguments const& frameworkArgs,

  RuntimeDependenciesArgs runtimeDependenciesArgs, bool& installsRuntime,

  bool& installsLibrary, bool& installsFramework)

{

  bool dllPlatform =

    !helper.Makefile->GetSafeDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX").empty();

  bool apple =

    helper.Makefile->GetSafeDefinition("CMAKE_HOST_SYSTEM_NAME") == "Darwin";

  auto const& runtimeDependenciesArgsRef =

    dllPlatform ? runtimeArgs : libraryArgs;

  std::vector<std::string> configurations =

    runtimeDependenciesArgsRef.GetConfigurations();

  if (apple) {

    std::copy(frameworkArgs.GetConfigurations().begin(),

              frameworkArgs.GetConfigurations().end(),

              std::back_inserter(configurations));

  }

  // Create file(GET_RUNTIME_DEPENDENCIES) generator.

  auto getRuntimeDependenciesGenerator =

    cm::make_unique<cmInstallGetRuntimeDependenciesGenerator>(

      runtimeDependencySet, std::move(runtimeDependenciesArgs.Directories),

      std::move(runtimeDependenciesArgs.PreIncludeRegexes),

      std::move(runtimeDependenciesArgs.PreExcludeRegexes),

      std::move(runtimeDependenciesArgs.PostIncludeRegexes),

      std::move(runtimeDependenciesArgs.PostExcludeRegexes),

      std::move(runtimeDependenciesArgs.PostIncludeFiles),

      std::move(runtimeDependenciesArgs.PostExcludeFiles),

      runtimeDependenciesArgsRef.GetComponent(),

      apple ? frameworkArgs.GetComponent() : "", true, "_CMAKE_DEPS",

      "_CMAKE_RPATH", configurations,

      cmInstallGenerator::SelectMessageLevel(helper.Makefile),

      runtimeDependenciesArgsRef.GetExcludeFromAll() &&

        (apple ? frameworkArgs.GetExcludeFromAll() : true),

      helper.Makefile->GetBacktrace(),

      helper.Makefile->GetPolicyStatus(cmPolicies::CMP0207));

  helper.Makefile->AddInstallGenerator(

    std::move(getRuntimeDependenciesGenerator));

  // Create the library dependencies generator.

  auto libraryRuntimeDependenciesGenerator =

    cm::make_unique<cmInstallRuntimeDependencySetGenerator>(

      cmInstallRuntimeDependencySetGenerator::DependencyType::Library,

      runtimeDependencySet, std::vector<std::string>{}, true, std::string{},

      true, "_CMAKE_DEPS", "_CMAKE_RPATH", "_CMAKE_TMP",

      dllPlatform ? helper.GetRuntimeDestination(&runtimeArgs)

                  : helper.GetLibraryDestination(&libraryArgs),

      runtimeDependenciesArgsRef.GetConfigurations(),

      runtimeDependenciesArgsRef.GetComponent(),

      runtimeDependenciesArgsRef.GetPermissions(),

      cmInstallGenerator::SelectMessageLevel(helper.Makefile),

      runtimeDependenciesArgsRef.GetExcludeFromAll(), helper.CaptureContext());

  helper.Makefile->AddInstallGenerator(

    std::move(libraryRuntimeDependenciesGenerator));

  if (dllPlatform) {

    installsRuntime = true;

  } else {

    installsLibrary = true;

  }

  if (apple) {

    // Create the framework dependencies generator.

    auto frameworkRuntimeDependenciesGenerator =

      cm::make_unique<cmInstallRuntimeDependencySetGenerator>(

        cmInstallRuntimeDependencySetGenerator::DependencyType::Framework,

        runtimeDependencySet, std::vector<std::string>{}, true, std::string{},

        true, "_CMAKE_DEPS", "_CMAKE_RPATH", "_CMAKE_TMP",

        frameworkArgs.GetDestination(), frameworkArgs.GetConfigurations(),

        frameworkArgs.GetComponent(), frameworkArgs.GetPermissions(),

        cmInstallGenerator::SelectMessageLevel(helper.Makefile),

        frameworkArgs.GetExcludeFromAll(), helper.CaptureContext());

    helper.Makefile->AddInstallGenerator(

      std::move(frameworkRuntimeDependenciesGenerator));

    installsFramework = true;

  }

}

std::set<std::string> const allowedTypes{

  "BIN",         "SBIN",       "LIB",      "INCLUDE", "SYSCONF",

  "SHAREDSTATE", "LOCALSTATE", "RUNSTATE", "DATA",    "INFO",

  "LOCALE",      "MAN",        "DOC",      "LIBEXEC",

};

template <typename T>

bool AddBundleExecutable(Helper& helper,

                         cmInstallRuntimeDependencySet* runtimeDependencySet,

                         T&& bundleExecutable)

{

  if (!runtimeDependencySet->AddBundleExecutable(bundleExecutable)) {

    helper.SetError(

      "A runtime dependency set may only have one bundle executable.");

    return false;

  }

  return true;

}

Unexecuted instantiation: cmInstallCommand.cxx:bool (anonymous namespace)::AddBundleExecutable<cmInstallTargetGenerator*>((anonymous namespace)::Helper&, cmInstallRuntimeDependencySet*, cmInstallTargetGenerator*&&)

Unexecuted instantiation: cmInstallCommand.cxx:bool (anonymous namespace)::AddBundleExecutable<cmInstallImportedRuntimeArtifactsGenerator*>((anonymous namespace)::Helper&, cmInstallRuntimeDependencySet*, cmInstallImportedRuntimeArtifactsGenerator*&&)

void CheckAbsoluteDestination(Helper& helper, std::string const& destination)

{

  // Check for an absolute destination.

  if (cmGeneratorExpression::Find(destination) == std::string::npos &&

      cmSystemTools::FileIsFullPath(destination)) {

    helper.Makefile->IssueDiagnostic(

      cmDiagnostics::CMD_INSTALL_ABSOLUTE_DESTINATION,

      cmStrCat("INSTALL command given absolute DESTINATION path:\n  ",

               destination));

  }

}

bool HandleScriptMode(std::vector<std::string> const& args,

                      cmExecutionStatus& status)

{

  Helper helper(status);

  std::string component = helper.DefaultComponentName;

  int componentCount = 0;

  bool doingScript = false;

  bool doingCode = false;

  bool excludeFromAll = false;

  bool allComponents = false;

  // Scan the args once for COMPONENT. Only allow one.

  //

  for (size_t i = 0; i < args.size(); ++i) {

    if (args[i] == "COMPONENT" && i + 1 < args.size()) {

      ++componentCount;

      ++i;

      component = args[i];

    }

    if (args[i] == "EXCLUDE_FROM_ALL") {

      excludeFromAll = true;

    } else if (args[i] == "ALL_COMPONENTS") {

      allComponents = true;

    }

  }

  if (componentCount > 1) {

    status.SetError("given more than one COMPONENT for the SCRIPT or CODE "

                    "signature of the INSTALL command. "

                    "Use multiple INSTALL commands with one COMPONENT each.");

    return false;

  }

  if (allComponents && componentCount == 1) {

    status.SetError("ALL_COMPONENTS and COMPONENT are mutually exclusive");

    return false;

  }

  // Scan the args again, this time adding install generators each time we

  // encounter a SCRIPT or CODE arg:

  //

  for (std::string const& arg : args) {

    if (arg == "SCRIPT") {

      doingScript = true;

      doingCode = false;

    } else if (arg == "CODE") {

      doingScript = false;

      doingCode = true;

    } else if (arg == "COMPONENT") {

      doingScript = false;

      doingCode = false;

    } else if (doingScript) {

      doingScript = false;

      std::string script = arg;

      if (!cmHasLiteralPrefix(script, "$<INSTALL_PREFIX>")) {

        if (!cmSystemTools::FileIsFullPath(script)) {

          script =

            cmStrCat(helper.Makefile->GetCurrentSourceDirectory(), '/', arg);

        }

        if (cmSystemTools::FileIsDirectory(script)) {

          status.SetError("given a directory as value of SCRIPT argument.");

          return false;

        }

      }

      helper.Makefile->AddInstallGenerator(

        cm::make_unique<cmInstallScriptGenerator>(

          script, false, component, excludeFromAll, allComponents,

          helper.Makefile->GetBacktrace()));

    } else if (doingCode) {

      doingCode = false;

      std::string const& code = arg;

      helper.Makefile->AddInstallGenerator(

        cm::make_unique<cmInstallScriptGenerator>(

          code, true, component, excludeFromAll, allComponents,

          helper.Makefile->GetBacktrace()));

    }

  }

  if (doingScript) {

    status.SetError("given no value for SCRIPT argument.");

    return false;

  }

  if (doingCode) {

    status.SetError("given no value for CODE argument.");

    return false;

  }

  // Tell the global generator about any installation component names

  // specified.

  helper.Makefile->GetGlobalGenerator()->AddInstallComponent(component);

  return true;

}

bool HandleTargetsMode(std::vector<std::string> const& args,

                       cmExecutionStatus& status)

{

  Helper helper(status);

  // This is the TARGETS mode.

  std::vector<cmTarget*> targets;

  struct ArgVectors

  {

    ArgumentParser::MaybeEmpty<std::vector<std::string>> Archive;

    ArgumentParser::MaybeEmpty<std::vector<std::string>> Library;

    ArgumentParser::MaybeEmpty<std::vector<std::string>> Runtime;

    ArgumentParser::MaybeEmpty<std::vector<std::string>> Object;

    ArgumentParser::MaybeEmpty<std::vector<std::string>> Framework;

    ArgumentParser::MaybeEmpty<std::vector<std::string>> Bundle;

    ArgumentParser::MaybeEmpty<std::vector<std::string>> Includes;

    ArgumentParser::MaybeEmpty<std::vector<std::string>> PrivateHeader;

    ArgumentParser::MaybeEmpty<std::vector<std::string>> PublicHeader;

    ArgumentParser::MaybeEmpty<std::vector<std::string>> Resource;

    ArgumentParser::MaybeEmpty<std::vector<std::string>> CxxModulesBmi;

    std::vector<std::vector<std::string>> FileSets;

  };

  static auto const argHelper =

    cmArgumentParser<ArgVectors>{}

      .Bind("ARCHIVE"_s, &ArgVectors::Archive)

      .Bind("LIBRARY"_s, &ArgVectors::Library)

      .Bind("RUNTIME"_s, &ArgVectors::Runtime)

      .Bind("OBJECTS"_s, &ArgVectors::Object)

      .Bind("FRAMEWORK"_s, &ArgVectors::Framework)

      .Bind("BUNDLE"_s, &ArgVectors::Bundle)

      .Bind("INCLUDES"_s, &ArgVectors::Includes)

      .Bind("PRIVATE_HEADER"_s, &ArgVectors::PrivateHeader)

      .Bind("PUBLIC_HEADER"_s, &ArgVectors::PublicHeader)

      .Bind("RESOURCE"_s, &ArgVectors::Resource)

      .Bind("FILE_SET"_s, &ArgVectors::FileSets)

      .Bind("CXX_MODULES_BMI"_s, &ArgVectors::CxxModulesBmi);

  std::vector<std::string> genericArgVector;

  ArgVectors const argVectors = argHelper.Parse(args, &genericArgVector);

  // now parse the generic args (i.e. the ones not specialized on LIBRARY/

  // ARCHIVE, RUNTIME etc. (see above)

  // These generic args also contain the targets and the export stuff

  ArgumentParser::MaybeEmpty<std::vector<std::string>> targetList;

  std::string exports;

  cm::optional<ArgumentParser::MaybeEmpty<std::vector<std::string>>>

    runtimeDependenciesArgVector;

  std::string runtimeDependencySetArg;

  std::vector<std::string> unknownArgs;

  cmInstallCommandArguments genericArgs(helper.DefaultComponentName,

                                        *helper.Makefile);

  genericArgs.Bind("TARGETS"_s, targetList);

  genericArgs.Bind("EXPORT"_s, exports);

  genericArgs.Bind("RUNTIME_DEPENDENCIES"_s, runtimeDependenciesArgVector);

  genericArgs.Bind("RUNTIME_DEPENDENCY_SET"_s, runtimeDependencySetArg);

  genericArgs.Parse(genericArgVector, &unknownArgs);

  bool success = genericArgs.Finalize();

  RuntimeDependenciesArgs runtimeDependenciesArgs =

    runtimeDependenciesArgVector

    ? RuntimeDependenciesArgHelper.Parse(*runtimeDependenciesArgVector,

                                         &unknownArgs)

    : RuntimeDependenciesArgs();

  cmInstallCommandArguments archiveArgs(helper.DefaultComponentName,

                                        *helper.Makefile);

  cmInstallCommandArguments libraryArgs(helper.DefaultComponentName,

                                        *helper.Makefile);

  cmInstallCommandArguments runtimeArgs(helper.DefaultComponentName,

                                        *helper.Makefile);

  cmInstallCommandArguments objectArgs(helper.DefaultComponentName,

                                       *helper.Makefile);

  cmInstallCommandArguments frameworkArgs(helper.DefaultComponentName,

                                          *helper.Makefile);

  cmInstallCommandArguments bundleArgs(helper.DefaultComponentName,

                                       *helper.Makefile);

  cmInstallCommandArguments privateHeaderArgs(helper.DefaultComponentName,

                                              *helper.Makefile);

  cmInstallCommandArguments publicHeaderArgs(helper.DefaultComponentName,

                                             *helper.Makefile);

  cmInstallCommandArguments resourceArgs(helper.DefaultComponentName,

                                         *helper.Makefile);

  cmInstallCommandIncludesArgument includesArgs;

  std::vector<cmInstallCommandFileSetArguments> fileSetArgs(

    argVectors.FileSets.size(),

    { cmInstallCommandFileSetArguments(helper.DefaultComponentName,

                                       *helper.Makefile) });

  cmInstallCommandArguments cxxModuleBmiArgs(helper.DefaultComponentName,

                                             *helper.Makefile);

  // now parse the args for specific parts of the target (e.g. LIBRARY,

  // RUNTIME, ARCHIVE etc.

  archiveArgs.Parse(argVectors.Archive, &unknownArgs);

  libraryArgs.Parse(argVectors.Library, &unknownArgs);

  runtimeArgs.Parse(argVectors.Runtime, &unknownArgs);

  objectArgs.Parse(argVectors.Object, &unknownArgs);

  frameworkArgs.Parse(argVectors.Framework, &unknownArgs);

  bundleArgs.Parse(argVectors.Bundle, &unknownArgs);

  privateHeaderArgs.Parse(argVectors.PrivateHeader, &unknownArgs);

  publicHeaderArgs.Parse(argVectors.PublicHeader, &unknownArgs);

  resourceArgs.Parse(argVectors.Resource, &unknownArgs);

  includesArgs.Parse(&argVectors.Includes, &unknownArgs);

  cxxModuleBmiArgs.Parse(argVectors.CxxModulesBmi, &unknownArgs);

  for (std::size_t i = 0; i < argVectors.FileSets.size(); i++) {

    // We have to create a separate object for the parsing because

    // cmArgumentParser<void>::Bind() binds to a specific address, but the

    // objects in the vector can move around. So we parse in an object with a

    // fixed address and then copy the data into the vector.

    cmInstallCommandFileSetArguments fileSetArg(helper.DefaultComponentName,

                                                *helper.Makefile);

    fileSetArg.Parse(argVectors.FileSets[i], &unknownArgs);

    fileSetArgs[i] = std::move(fileSetArg);

  }

  if (!unknownArgs.empty()) {

    // Unknown argument.

    status.SetError(

      cmStrCat("TARGETS given unknown argument \"", unknownArgs[0], "\"."));

    return false;

  }

  // apply generic args

  archiveArgs.SetGenericArguments(&genericArgs);

  libraryArgs.SetGenericArguments(&genericArgs);

  runtimeArgs.SetGenericArguments(&genericArgs);

  objectArgs.SetGenericArguments(&genericArgs);

  frameworkArgs.SetGenericArguments(&genericArgs);

  bundleArgs.SetGenericArguments(&genericArgs);

  privateHeaderArgs.SetGenericArguments(&genericArgs);

  publicHeaderArgs.SetGenericArguments(&genericArgs);

  resourceArgs.SetGenericArguments(&genericArgs);

  for (auto& fileSetArg : fileSetArgs) {

    fileSetArg.SetGenericArguments(&genericArgs);

  }

  cxxModuleBmiArgs.SetGenericArguments(&genericArgs);

  success = success && archiveArgs.Finalize();

  success = success && libraryArgs.Finalize();

  success = success && runtimeArgs.Finalize();

  success = success && objectArgs.Finalize();

  success = success && frameworkArgs.Finalize();

  success = success && bundleArgs.Finalize();

  success = success && privateHeaderArgs.Finalize();

  success = success && publicHeaderArgs.Finalize();

  success = success && resourceArgs.Finalize();

  success = success && cxxModuleBmiArgs.Finalize();

  for (auto& fileSetArg : fileSetArgs) {

    success = success && fileSetArg.Finalize();

  }

  if (!success) {

    return false;

  }

  // Enforce argument rules too complex to specify for the

  // general-purpose parser.

  if (runtimeArgs.GetNamelinkOnly() || objectArgs.GetNamelinkOnly() ||

      frameworkArgs.GetNamelinkOnly() || bundleArgs.GetNamelinkOnly() ||

      privateHeaderArgs.GetNamelinkOnly() ||

      publicHeaderArgs.GetNamelinkOnly() || resourceArgs.GetNamelinkOnly() ||

      std::any_of(fileSetArgs.begin(), fileSetArgs.end(),

                  [](cmInstallCommandFileSetArguments const& fileSetArg)

                    -> bool { return fileSetArg.GetNamelinkOnly(); }) ||

      cxxModuleBmiArgs.GetNamelinkOnly()) {

    status.SetError(

      "TARGETS given NAMELINK_ONLY option not in LIBRARY or ARCHIVE group.  "

      "The NAMELINK_ONLY option may be specified only following LIBRARY or "

      "ARCHIVE.");

    return false;

  }

  if (runtimeArgs.GetNamelinkSkip() || objectArgs.GetNamelinkSkip() ||

      frameworkArgs.GetNamelinkSkip() || bundleArgs.GetNamelinkSkip() ||

      privateHeaderArgs.GetNamelinkSkip() ||

      publicHeaderArgs.GetNamelinkSkip() || resourceArgs.GetNamelinkSkip() ||

      std::any_of(fileSetArgs.begin(), fileSetArgs.end(),

                  [](cmInstallCommandFileSetArguments const& fileSetArg)

                    -> bool { return fileSetArg.GetNamelinkSkip(); }) ||

      cxxModuleBmiArgs.GetNamelinkSkip()) {

    status.SetError(

      "TARGETS given NAMELINK_SKIP option not in LIBRARY or ARCHIVE group.  "

      "The NAMELINK_SKIP option may be specified only following LIBRARY or "

      "ARCHIVE.");

    return false;

  }

  if (runtimeArgs.HasNamelinkComponent() ||

      objectArgs.HasNamelinkComponent() ||

      frameworkArgs.HasNamelinkComponent() ||

      bundleArgs.HasNamelinkComponent() ||

      privateHeaderArgs.HasNamelinkComponent() ||

      publicHeaderArgs.HasNamelinkComponent() ||

      resourceArgs.HasNamelinkComponent() ||

      std::any_of(fileSetArgs.begin(), fileSetArgs.end(),

                  [](cmInstallCommandFileSetArguments const& fileSetArg)

                    -> bool { return fileSetArg.HasNamelinkComponent(); }) ||

      cxxModuleBmiArgs.HasNamelinkComponent()) {

    status.SetError(

      "TARGETS given NAMELINK_COMPONENT option not in LIBRARY or ARCHIVE "

      "group.  The NAMELINK_COMPONENT option may be specified only following "

      "LIBRARY or ARCHIVE.");

    return false;

  }

  if (libraryArgs.GetNamelinkOnly() && libraryArgs.GetNamelinkSkip()) {

    status.SetError("TARGETS given NAMELINK_ONLY and NAMELINK_SKIP.  "

                    "At most one of these two options may be specified.");

    return false;

  }

  if (!genericArgs.GetType().empty() || !archiveArgs.GetType().empty() ||

      !libraryArgs.GetType().empty() || !runtimeArgs.GetType().empty() ||

      !objectArgs.GetType().empty() || !frameworkArgs.GetType().empty() ||

      !bundleArgs.GetType().empty() || !privateHeaderArgs.GetType().empty() ||

      !publicHeaderArgs.GetType().empty() || !resourceArgs.GetType().empty() ||

      std::any_of(fileSetArgs.begin(), fileSetArgs.end(),

                  [](cmInstallCommandFileSetArguments const& fileSetArg)

                    -> bool { return !fileSetArg.GetType().empty(); }) ||

      !cxxModuleBmiArgs.GetType().empty()) {

    status.SetError(

      "TARGETS given TYPE option. The TYPE option may only be specified in "

      " install(FILES) and install(DIRECTORIES).");

    return false;

  }

  if (std::any_of(fileSetArgs.begin(), fileSetArgs.end(),

                  [](cmInstallCommandFileSetArguments const& fileSetArg)

                    -> bool { return fileSetArg.GetFileSet().empty(); })) {

    status.SetError("TARGETS given FILE_SET option without file set name.");

    return false;

  }

  cmInstallRuntimeDependencySet* runtimeDependencySet = nullptr;

  if (runtimeDependenciesArgVector) {

    if (!runtimeDependencySetArg.empty()) {

      status.SetError("TARGETS cannot have both RUNTIME_DEPENDENCIES and "

                      "RUNTIME_DEPENDENCY_SET.");

      return false;

    }

    auto system = helper.Makefile->GetSafeDefinition("CMAKE_HOST_SYSTEM_NAME");

    if (!cmRuntimeDependencyArchive::PlatformSupportsRuntimeDependencies(

          system)) {

      status.SetError(

        cmStrCat("TARGETS RUNTIME_DEPENDENCIES is not supported on system \"",

                 system, '"'));

      return false;

    }

    if (helper.Makefile->IsOn("CMAKE_CROSSCOMPILING")) {

      status.SetError("TARGETS RUNTIME_DEPENDENCIES is not supported "

                      "when cross-compiling.");

      return false;

    }

    if (helper.Makefile->GetSafeDefinition("CMAKE_HOST_SYSTEM_NAME") ==

          "Darwin" &&

        frameworkArgs.GetDestination().empty()) {

      status.SetError(

        "TARGETS RUNTIME_DEPENDENCIES given no FRAMEWORK DESTINATION");

      return false;

    }

    runtimeDependencySet = helper.Makefile->GetGlobalGenerator()

                             ->CreateAnonymousRuntimeDependencySet();

  } else if (!runtimeDependencySetArg.empty()) {

    auto system = helper.Makefile->GetSafeDefinition("CMAKE_HOST_SYSTEM_NAME");

    if (!cmRuntimeDependencyArchive::PlatformSupportsRuntimeDependencies(

          system)) {

      status.SetError(cmStrCat(

        "TARGETS RUNTIME_DEPENDENCY_SET is not supported on system \"", system,

        '"'));

      return false;

    }

    runtimeDependencySet =

      helper.Makefile->GetGlobalGenerator()->GetNamedRuntimeDependencySet(

        runtimeDependencySetArg);

  }

  // Select the mode for installing symlinks to versioned shared libraries.

  cmInstallTargetGenerator::NamelinkModeType namelinkMode =

    cmInstallTargetGenerator::NamelinkModeNone;

  if (libraryArgs.GetNamelinkOnly()) {

    namelinkMode = cmInstallTargetGenerator::NamelinkModeOnly;

  } else if (libraryArgs.GetNamelinkSkip()) {

    namelinkMode = cmInstallTargetGenerator::NamelinkModeSkip;

  }

  // Select the mode for installing symlinks to versioned imported libraries.

  cmInstallTargetGenerator::NamelinkModeType importlinkMode =

    cmInstallTargetGenerator::NamelinkModeNone;

  if (archiveArgs.GetNamelinkOnly()) {

    importlinkMode = cmInstallTargetGenerator::NamelinkModeOnly;

  } else if (archiveArgs.GetNamelinkSkip()) {

    importlinkMode = cmInstallTargetGenerator::NamelinkModeSkip;

  }

  // Check if there is something to do.

  if (targetList.empty()) {

    return true;

  }

  for (std::string const& tgt : targetList) {

    if (helper.Makefile->IsAlias(tgt)) {

      status.SetError(

        cmStrCat("TARGETS given target \"", tgt, "\" which is an alias."));

      return false;

    }

    // Lookup this target in the current directory.

    cmTarget* target = helper.Makefile->FindLocalNonAliasTarget(tgt);

    if (!target) {

      // If no local target has been found, find it in the global scope.

      cmTarget* const globalTarget =

        helper.Makefile->GetGlobalGenerator()->FindTarget(

          tgt, { cmStateEnums::TargetDomain::NATIVE });

      if (globalTarget && !globalTarget->IsImported()) {

        target = globalTarget;

      }

    }

    if (target) {

      // Found the target.  Check its type.

      if (target->GetType() != cmStateEnums::EXECUTABLE &&

          target->GetType() != cmStateEnums::STATIC_LIBRARY &&

          target->GetType() != cmStateEnums::SHARED_LIBRARY &&

          target->GetType() != cmStateEnums::MODULE_LIBRARY &&

          target->GetType() != cmStateEnums::OBJECT_LIBRARY &&

          target->GetType() != cmStateEnums::INTERFACE_LIBRARY) {

        status.SetError(

          cmStrCat("TARGETS given target \"", tgt,

                   "\" which is not an executable, library, or module."));

        return false;

      }

      // Store the target in the list to be installed.

      targets.push_back(target);

    } else {

      // Did not find the target.

      status.SetError(

        cmStrCat("TARGETS given target \"", tgt, "\" which does not exist."));

      return false;

    }

  }

  // Keep track of whether we will be performing an installation of

  // any files of the given type.

  bool installsArchive = false;

  bool installsLibrary = false;

  bool installsNamelink = false;

  bool installsImportlink = false;

  bool installsRuntime = false;

  bool installsObject = false;

  bool installsFramework = false;

  bool installsBundle = false;

  bool installsPrivateHeader = false;

  bool installsPublicHeader = false;

  bool installsResource = false;

  std::vector<bool> installsFileSet(fileSetArgs.size(), false);

  bool installsCxxModuleBmi = false;

  // Generate install script code to install the given targets.

  for (cmTarget* ti : targets) {

    // Handle each target type.

    cmTarget& target = *ti;

    std::unique_ptr<cmInstallTargetGenerator> archiveGenerator;

    std::unique_ptr<cmInstallTargetGenerator> libraryGenerator;

    std::unique_ptr<cmInstallTargetGenerator> namelinkGenerator;

    std::unique_ptr<cmInstallTargetGenerator> importlinkGenerator;

    std::unique_ptr<cmInstallTargetGenerator> runtimeGenerator;

    std::unique_ptr<cmInstallTargetGenerator> objectGenerator;

    std::unique_ptr<cmInstallTargetGenerator> frameworkGenerator;

    std::unique_ptr<cmInstallTargetGenerator> bundleGenerator;

    std::unique_ptr<cmInstallFilesGenerator> privateHeaderGenerator;

    std::unique_ptr<cmInstallFilesGenerator> publicHeaderGenerator;

    std::unique_ptr<cmInstallFilesGenerator> resourceGenerator;

    std::vector<std::unique_ptr<cmInstallFileSetGenerator>> fileSetGenerators;

    std::unique_ptr<cmInstallCxxModuleBmiGenerator> cxxModuleBmiGenerator;

    // Avoid selecting default destinations for PUBLIC_HEADER and

    // PRIVATE_HEADER if any artifacts are specified.

    bool artifactsSpecified = false;

    // Track whether this is a namelink-only rule.

    bool namelinkOnly = false;

    auto addTargetExport = [&]() -> bool {

      // Add this install rule to an export if one was specified.

      if (!exports.empty()) {

        auto interfaceFileSets = target.GetAllInterfaceFileSets();

        if (std::any_of(

              interfaceFileSets.begin(), interfaceFileSets.end(),

              [=](std::string const& name) -> bool {

                return !std::any_of(

                  fileSetArgs.begin(), fileSetArgs.end(),

                  [=](cmInstallCommandFileSetArguments const& fileSetArg)

                    -> bool { return fileSetArg.GetFileSet() == name; });

              })) {

          status.SetError(cmStrCat("TARGETS target ", target.GetName(),

                                   " is exported but not all of its interface "

                                   "file sets are installed"));

          return false;

        }

        auto te = cm::make_unique<cmTargetExport>();

        te->TargetName = target.GetName();

        te->ArchiveGenerator = archiveGenerator.get();

        te->BundleGenerator = bundleGenerator.get();

        te->FrameworkGenerator = frameworkGenerator.get();

        te->HeaderGenerator = publicHeaderGenerator.get();

        te->LibraryGenerator = libraryGenerator.get();

        te->RuntimeGenerator = runtimeGenerator.get();

        te->ObjectsGenerator = objectGenerator.get();

        for (auto const& gen : fileSetGenerators) {

          te->FileSetGenerators[gen->GetFileSetName()] = gen.get();

        }

        te->CxxModuleBmiGenerator = cxxModuleBmiGenerator.get();

        target.AddInstallIncludeDirectories(

          *te, cmMakeRange(includesArgs.GetIncludeDirs()));

        te->NamelinkOnly = namelinkOnly;

        helper.Makefile->GetGlobalGenerator()

          ->GetExportSets()[exports]

          .AddTargetExport(std::move(te));

      }

      return true;

    };

    switch (target.GetType()) {

      case cmStateEnums::SHARED_LIBRARY: {

        // Shared libraries are handled differently on DLL and non-DLL

        // platforms.  All windows platforms are DLL platforms including

        // cygwin.  Currently no other platform is a DLL platform.

        if (target.IsDLLPlatform()) {

          // When in namelink only mode skip all libraries on Windows.

          if (namelinkMode == cmInstallTargetGenerator::NamelinkModeOnly) {

            namelinkOnly = true;

            if (!addTargetExport()) {

              return false;

            }

            continue;

          }

          // This is a DLL platform.

          if (!archiveArgs.GetDestination().empty()) {

            // The import library uses the ARCHIVE properties.

            archiveGenerator = CreateInstallTargetGenerator(

              target, archiveArgs, true, helper.CaptureContext());

            artifactsSpecified = true;

          }

          if (!runtimeArgs.GetDestination().empty()) {

            // The DLL uses the RUNTIME properties.

            runtimeGenerator = CreateInstallTargetGenerator(

              target, runtimeArgs, false, helper.CaptureContext());

            artifactsSpecified = true;

          }

          if (!archiveGenerator && !runtimeGenerator) {

            archiveGenerator = CreateInstallTargetGenerator(

              target, archiveArgs, true, helper.CaptureContext(),

              helper.GetArchiveDestination(nullptr));

            runtimeGenerator = CreateInstallTargetGenerator(

              target, runtimeArgs, false, helper.CaptureContext(),

              helper.GetRuntimeDestination(nullptr));

          }

          if (runtimeDependencySet && runtimeGenerator) {

            runtimeDependencySet->AddLibrary(runtimeGenerator.get());

          }

        } else {

          // This is a non-DLL platform.

          // If it is marked with FRAMEWORK property use the FRAMEWORK set of

          // INSTALL properties. Otherwise, use the LIBRARY properties.

          if (target.IsFrameworkOnApple()) {

            // When in namelink only mode skip frameworks.

            if (namelinkMode == cmInstallTargetGenerator::NamelinkModeOnly) {

              namelinkOnly = true;

              if (!addTargetExport()) {

                return false;

              }

              continue;

            }

            // Use the FRAMEWORK properties.

            if (!frameworkArgs.GetDestination().empty()) {

              frameworkGenerator = CreateInstallTargetGenerator(

                target, frameworkArgs, false, helper.CaptureContext());

            } else {

              status.SetError(

                cmStrCat("TARGETS given no FRAMEWORK DESTINATION for shared "

                         "library FRAMEWORK target \"",

                         target.GetName(), "\"."));

              return false;