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

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

#include "cmGeneratorExpressionNode.h"

#include <algorithm>

#include <cassert>

#include <cerrno>

#include <cstdlib>

#include <cstring>

#include <exception>

#include <functional>

#include <map>

#include <memory>

#include <set>

#include <sstream>

#include <stdexcept>

#include <unordered_map>

#include <utility>

#include <cm/iterator>

#include <cm/optional>

#include <cm/string_view>

#include <cmext/algorithm>

#include <cmext/string_view>

#include "cmsys/RegularExpression.hxx"

#include "cmsys/String.h"

#include "cmCMakePath.h"

#include "cmCMakeString.hxx"

#include "cmComputeLinkInformation.h"

#include "cmGenExContext.h"

#include "cmGenExEvaluation.h"

#include "cmGeneratorExpression.h"

#include "cmGeneratorExpressionDAGChecker.h"

#include "cmGeneratorExpressionEvaluator.h"

#include "cmGeneratorFileSet.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 "cmOutputConverter.h"

#include "cmPolicies.h"

#include "cmRange.h"

#include "cmSourceFile.h"

#include "cmStandardLevelResolver.h"

#include "cmState.h"

#include "cmStateSnapshot.h"

#include "cmStateTypes.h"

#include "cmStringAlgorithms.h"

#include "cmSystemTools.h"

#include "cmTarget.h"

#include "cmValue.h"

#include "cmake.h"

namespace {

bool HasKnownObjectFileLocation(cm::GenEx::Evaluation* eval,

                                GeneratorExpressionContent const* content,

                                std::string const& genex,

                                cmGeneratorTarget const* target)

{

  std::string reason;

  if (!eval->EvaluateForBuildsystem &&

      !target->Target->HasKnownObjectFileLocation(&reason)) {

    std::ostringstream e;

    e << "The evaluation of the " << genex

      << " generator expression "

         "is only suitable for consumption by CMake (limited"

      << reason

      << ").  "

         "It is not suitable for writing out elsewhere.";

    reportError(eval, content->GetOriginalExpression(), e.str());

    return false;

  }

  return true;

}

} // namespace

std::string cmGeneratorExpressionNode::EvaluateDependentExpression(

  std::string const& prop, cm::GenEx::Evaluation* eval,

  cmGeneratorTarget const* headTarget,

  cmGeneratorExpressionDAGChecker* dagChecker,

  cmGeneratorTarget const* currentTarget)

{

  cmGeneratorExpression ge(*eval->Context.LG->GetCMakeInstance(),

                           eval->Backtrace);

  std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop);

  cge->SetEvaluateForBuildsystem(eval->EvaluateForBuildsystem);

  cge->SetQuiet(eval->Quiet);

  std::string result =

    cge->Evaluate(eval->Context, dagChecker, headTarget, currentTarget);

  if (cge->GetHadContextSensitiveCondition()) {

    eval->HadContextSensitiveCondition = true;

  }

  if (cge->GetHadHeadSensitiveCondition()) {

    eval->HadHeadSensitiveCondition = true;

  }

  if (cge->GetHadLinkLanguageSensitiveCondition()) {

    eval->HadLinkLanguageSensitiveCondition = true;

  }

  return result;

}

static const struct ZeroNode : public cmGeneratorExpressionNode

{

  ZeroNode() {} // NOLINT(modernize-use-equals-default)

  bool GeneratesContent() const override { return false; }

  bool AcceptsArbitraryContentParameter() const override { return true; }

  std::string Evaluate(

    std::vector<std::string> const& /*parameters*/,

    cm::GenEx::Evaluation* /*eval*/,

    GeneratorExpressionContent const* /*content*/,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    return std::string();

  }

} zeroNode;

static const struct OneNode : public cmGeneratorExpressionNode

{

  OneNode() {} // NOLINT(modernize-use-equals-default)

  bool AcceptsArbitraryContentParameter() const override { return true; }

  std::string Evaluate(

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

    cm::GenEx::Evaluation* /*eval*/,

    GeneratorExpressionContent const* /*content*/,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    return parameters.front();

  }

} oneNode;

static const struct OneNode buildInterfaceNode;

static const struct ZeroNode installInterfaceNode;

static const struct OneNode buildLocalInterfaceNode;

struct BooleanOpNode : public cmGeneratorExpressionNode

{

  BooleanOpNode(char const* op_, char const* successVal_,

                char const* failureVal_)

    : op(op_)

    , successVal(successVal_)

    , failureVal(failureVal_)

  {

  }

  int NumExpectedParameters() const override { return OneOrMoreParameters; }

  bool ShouldEvaluateNextParameter(std::vector<std::string> const& parameters,

                                   std::string& def_value) const override

  {

    if (!parameters.empty() && parameters.back() == failureVal) {

      def_value = failureVal;

      return false;

    }

    return true;

  }

  std::string Evaluate(std::vector<std::string> const& parameters,

                       cm::GenEx::Evaluation* eval,

                       GeneratorExpressionContent const* content,

                       cmGeneratorExpressionDAGChecker*) const override

  {

    for (std::string const& param : parameters) {

      if (param == this->failureVal) {

        return this->failureVal;

      }

      if (param != this->successVal) {

        std::ostringstream e;

        e << "Parameters to $<" << this->op;

        e << "> must resolve to either '0' or '1'.";

        reportError(eval, content->GetOriginalExpression(), e.str());

        return std::string();

      }

    }

    return this->successVal;

  }

  char const *const op, *const successVal, *const failureVal;

};

static BooleanOpNode const andNode("AND", "1", "0"), orNode("OR", "0", "1");

static const struct NotNode : public cmGeneratorExpressionNode

{

  NotNode() {} // NOLINT(modernize-use-equals-default)

  std::string Evaluate(

    std::vector<std::string> const& parameters, cm::GenEx::Evaluation* eval,

    GeneratorExpressionContent const* content,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    if (parameters.front() != "0" && parameters.front() != "1") {

      reportError(

        eval, content->GetOriginalExpression(),

        "$<NOT> parameter must resolve to exactly one '0' or '1' value.");

      return std::string();

    }

    return parameters.front() == "0" ? "1" : "0";

  }

} notNode;

static const struct BoolNode : public cmGeneratorExpressionNode

{

  BoolNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 1; }

  std::string Evaluate(

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

    cm::GenEx::Evaluation* /*eval*/,

    GeneratorExpressionContent const* /*content*/,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    return !cmIsOff(parameters.front()) ? "1" : "0";

  }

} boolNode;

static const struct IfNode : public cmGeneratorExpressionNode

{

  IfNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 3; }

  bool ShouldEvaluateNextParameter(std::vector<std::string> const& parameters,

                                   std::string&) const override

  {

    return (parameters.empty() ||

            parameters[0] != cmStrCat(parameters.size() - 1, ""));

  }

  std::string Evaluate(std::vector<std::string> const& parameters,

                       cm::GenEx::Evaluation* eval,

                       GeneratorExpressionContent const* content,

                       cmGeneratorExpressionDAGChecker*) const override

  {

    if (parameters[0] != "1" && parameters[0] != "0") {

      reportError(eval, content->GetOriginalExpression(),

                  "First parameter to $<IF> must resolve to exactly one '0' "

                  "or '1' value.");

      return std::string();

    }

    return parameters[0] == "1" ? parameters[1] : parameters[2];

  }

} ifNode;

static const struct StrEqualNode : public cmGeneratorExpressionNode

{

  StrEqualNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 2; }

  std::string Evaluate(

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

    cm::GenEx::Evaluation* /*eval*/,

    GeneratorExpressionContent const* /*content*/,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    return cm::CMakeString{ parameters.front() }.Compare(

             cm::CMakeString::CompOperator::EQUAL, parameters[1])

      ? "1"

      : "0";

  }

} strEqualNode;

static const struct StrLessNode : public cmGeneratorExpressionNode

{

  StrLessNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 2; }

  std::string Evaluate(

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

    cm::GenEx::Evaluation* /*eval*/,

    GeneratorExpressionContent const* /*content*/,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    return cm::CMakeString{ parameters.front() }.Compare(

             cm::CMakeString::CompOperator::LESS, parameters[1])

      ? "1"

      : "0";

  }

} strLessNode;

static const struct StrLessEqualNode : public cmGeneratorExpressionNode

{

  StrLessEqualNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 2; }

  std::string Evaluate(

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

    cm::GenEx::Evaluation* /*eval*/,

    GeneratorExpressionContent const* /*content*/,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    return cm::CMakeString{ parameters.front() }.Compare(

             cm::CMakeString::CompOperator::LESS_EQUAL, parameters[1])

      ? "1"

      : "0";

  }

} strLessEqualNode;

static const struct StrGreaterNode : public cmGeneratorExpressionNode

{

  StrGreaterNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 2; }

  std::string Evaluate(

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

    cm::GenEx::Evaluation* /*eval*/,

    GeneratorExpressionContent const* /*content*/,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    return cm::CMakeString{ parameters.front() }.Compare(

             cm::CMakeString::CompOperator::GREATER, parameters[1])

      ? "1"

      : "0";

  }

} strGreaterNode;

static const struct StrGreaterEqualNode : public cmGeneratorExpressionNode

{

  StrGreaterEqualNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 2; }

  std::string Evaluate(

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

    cm::GenEx::Evaluation* /*eval*/,

    GeneratorExpressionContent const* /*content*/,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    return cm::CMakeString{ parameters.front() }.Compare(

             cm::CMakeString::CompOperator::GREATER_EQUAL, parameters[1])

      ? "1"

      : "0";

  }

} strGreaterEqualNode;

static const struct EqualNode : public cmGeneratorExpressionNode

{

  EqualNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 2; }

  std::string Evaluate(

    std::vector<std::string> const& parameters, cm::GenEx::Evaluation* eval,

    GeneratorExpressionContent const* content,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    long numbers[2];

    for (int i = 0; i < 2; ++i) {

      if (!ParameterToLong(parameters[i].c_str(), &numbers[i])) {

        reportError(eval, content->GetOriginalExpression(),

                    "$<EQUAL> parameter " + parameters[i] +

                      " is not a valid integer.");

        return {};

      }

    }

    return numbers[0] == numbers[1] ? "1" : "0";

  }

  static bool ParameterToLong(char const* param, long* outResult)

  {

    char const isNegative = param[0] == '-';

    int base = 0;

    if (cmHasLiteralPrefix(param, "0b") || cmHasLiteralPrefix(param, "0B")) {

      base = 2;

      param += 2;

    } else if (cmHasLiteralPrefix(param, "-0b") ||

               cmHasLiteralPrefix(param, "-0B") ||

               cmHasLiteralPrefix(param, "+0b") ||

               cmHasLiteralPrefix(param, "+0B")) {

      base = 2;

      param += 3;

    }

    char* pEnd;

    long result = strtol(param, &pEnd, base);

    if (pEnd == param || *pEnd != '\0' || errno == ERANGE) {

      return false;

    }

    if (isNegative && result > 0) {

      result *= -1;

    }

    *outResult = result;

    return true;

  }

} equalNode;

static const struct InListNode : public cmGeneratorExpressionNode

{

  InListNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 2; }

  std::string Evaluate(

    std::vector<std::string> const& parameters, cm::GenEx::Evaluation* eval,

    GeneratorExpressionContent const* /*content*/,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    cmList values;

    cmList checkValues;

    bool check = false;

    switch (eval->Context.LG->GetPolicyStatus(cmPolicies::CMP0085)) {

      case cmPolicies::WARN:

        if (parameters.front().empty()) {

          check = true;

          checkValues.assign(parameters[1], cmList::EmptyElements::Yes);

        }

        CM_FALLTHROUGH;

      case cmPolicies::OLD:

        values.assign(parameters[1]);

        if (check && values != checkValues) {

          std::ostringstream e;

          e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0085)

            << "\nSearch Item:\n  \"" << parameters.front()

            << "\"\nList:\n  \"" << parameters[1] << "\"\n";

          eval->Context.LG->GetCMakeInstance()->IssueMessage(

            MessageType ::AUTHOR_WARNING, e.str(), eval->Backtrace);

          return "0";

        }

        if (values.empty()) {

          return "0";

        }

        break;

      case cmPolicies::NEW:

        values.assign(parameters[1], cmList::EmptyElements::Yes);

        break;

    }

    return values.find(parameters.front()) != cmList::npos ? "1" : "0";

  }

} inListNode;

static const struct FilterNode : public cmGeneratorExpressionNode

{

  FilterNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 3; }

  std::string Evaluate(

    std::vector<std::string> const& parameters, cm::GenEx::Evaluation* eval,

    GeneratorExpressionContent const* content,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    if (parameters.size() != 3) {

      reportError(eval, content->GetOriginalExpression(),

                  "$<FILTER:...> expression requires three parameters");

      return {};

    }

    if (parameters[1] != "INCLUDE" && parameters[1] != "EXCLUDE") {

      reportError(

        eval, content->GetOriginalExpression(),

        "$<FILTER:...> second parameter must be either INCLUDE or EXCLUDE");

      return {};

    }

    try {

      return cmList{ parameters.front(), cmList::EmptyElements::Yes }

        .filter(parameters[2],

                parameters[1] == "EXCLUDE" ? cmList::FilterMode::EXCLUDE

                                           : cmList::FilterMode::INCLUDE)

        .to_string();

    } catch (std::invalid_argument&) {

      reportError(eval, content->GetOriginalExpression(),

                  "$<FILTER:...> failed to compile regex");

      return {};

    }

  }

} filterNode;

static const struct RemoveDuplicatesNode : public cmGeneratorExpressionNode

{

  RemoveDuplicatesNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 1; }

  std::string Evaluate(

    std::vector<std::string> const& parameters, cm::GenEx::Evaluation* eval,

    GeneratorExpressionContent const* content,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    if (parameters.size() != 1) {

      reportError(

        eval, content->GetOriginalExpression(),

        "$<REMOVE_DUPLICATES:...> expression requires one parameter");

    }

    return cmList{ parameters.front(), cmList::EmptyElements::Yes }

      .remove_duplicates()

      .to_string();

  }

} removeDuplicatesNode;

static const struct TargetExistsNode : public cmGeneratorExpressionNode

{

  TargetExistsNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 1; }

  std::string Evaluate(

    std::vector<std::string> const& parameters, cm::GenEx::Evaluation* eval,

    GeneratorExpressionContent const* content,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    if (parameters.size() != 1) {

      reportError(eval, content->GetOriginalExpression(),

                  "$<TARGET_EXISTS:...> expression requires one parameter");

      return std::string();

    }

    std::string const& targetName = parameters.front();

    if (targetName.empty() ||

        !cmGeneratorExpression::IsValidTargetName(targetName)) {

      reportError(eval, content->GetOriginalExpression(),

                  "$<TARGET_EXISTS:tgt> expression requires a non-empty "

                  "valid target name.");

      return std::string();

    }

    return eval->Context.LG->GetMakefile()->FindTargetToUse(targetName) ? "1"

                                                                        : "0";

  }

} targetExistsNode;

static const struct TargetNameIfExistsNode : public cmGeneratorExpressionNode

{

  TargetNameIfExistsNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 1; }

  std::string Evaluate(

    std::vector<std::string> const& parameters, cm::GenEx::Evaluation* eval,

    GeneratorExpressionContent const* content,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    if (parameters.size() != 1) {

      reportError(eval, content->GetOriginalExpression(),

                  "$<TARGET_NAME_IF_EXISTS:...> expression requires one "

                  "parameter");

      return std::string();

    }

    std::string const& targetName = parameters.front();

    if (targetName.empty() ||

        !cmGeneratorExpression::IsValidTargetName(targetName)) {

      reportError(eval, content->GetOriginalExpression(),

                  "$<TARGET_NAME_IF_EXISTS:tgt> expression requires a "

                  "non-empty valid target name.");

      return std::string();

    }

    return eval->Context.LG->GetMakefile()->FindTargetToUse(targetName)

      ? targetName

      : std::string();

  }

} targetNameIfExistsNode;

struct GenexEvaluator : public cmGeneratorExpressionNode

{

  GenexEvaluator() {} // NOLINT(modernize-use-equals-default)

protected:

  std::string EvaluateExpression(

    std::string const& genexOperator, std::string const& expression,

    cm::GenEx::Evaluation* eval, GeneratorExpressionContent const* content,

    cmGeneratorExpressionDAGChecker* dagCheckerParent) const

  {

    if (eval->HeadTarget) {

      cmGeneratorExpressionDAGChecker dagChecker{

        eval->HeadTarget, cmStrCat(genexOperator, ':', expression),

        content,          dagCheckerParent,

        eval->Context,    eval->Backtrace,

      };

      switch (dagChecker.Check()) {

        case cmGeneratorExpressionDAGChecker::SELF_REFERENCE:

        case cmGeneratorExpressionDAGChecker::CYCLIC_REFERENCE: {

          dagChecker.ReportError(eval, content->GetOriginalExpression());

          return std::string();

        }

        case cmGeneratorExpressionDAGChecker::ALREADY_SEEN:

        case cmGeneratorExpressionDAGChecker::DAG:

          break;

      }

      return this->EvaluateDependentExpression(

        expression, eval, eval->HeadTarget, &dagChecker, eval->CurrentTarget);

    }

    return this->EvaluateDependentExpression(

      expression, eval, eval->HeadTarget, dagCheckerParent,

      eval->CurrentTarget);

  }

};

static const struct TargetGenexEvalNode : public GenexEvaluator

{

  TargetGenexEvalNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 2; }

  bool AcceptsArbitraryContentParameter() const override { return true; }

  std::string Evaluate(

    std::vector<std::string> const& parameters, cm::GenEx::Evaluation* eval,

    GeneratorExpressionContent const* content,

    cmGeneratorExpressionDAGChecker* dagCheckerParent) const override

  {

    std::string const& targetName = parameters.front();

    if (targetName.empty() ||

        !cmGeneratorExpression::IsValidTargetName(targetName)) {

      reportError(eval, content->GetOriginalExpression(),

                  "$<TARGET_GENEX_EVAL:tgt, ...> expression requires a "

                  "non-empty valid target name.");

      return std::string();

    }

    auto const* target =

      eval->Context.LG->FindGeneratorTargetToUse(targetName);

    if (!target) {

      std::ostringstream e;

      e << "$<TARGET_GENEX_EVAL:tgt, ...> target \"" << targetName

        << "\" not found.";

      reportError(eval, content->GetOriginalExpression(), e.str());

      return std::string();

    }

    std::string const& expression = parameters[1];

    if (expression.empty()) {

      return expression;

    }

    // Replace the surrounding context with the named target.

    cm::GenEx::Evaluation targetEval(eval->Context, eval->Quiet, target,

                                     target, eval->EvaluateForBuildsystem,

                                     eval->Backtrace);

    return this->EvaluateExpression("TARGET_GENEX_EVAL", expression,

                                    &targetEval, content, dagCheckerParent);

  }

} targetGenexEvalNode;

static const struct GenexEvalNode : public GenexEvaluator

{

  GenexEvalNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return 1; }

  bool AcceptsArbitraryContentParameter() const override { return true; }

  std::string Evaluate(

    std::vector<std::string> const& parameters, cm::GenEx::Evaluation* eval,

    GeneratorExpressionContent const* content,

    cmGeneratorExpressionDAGChecker* dagCheckerParent) const override

  {

    std::string const& expression = parameters[0];

    if (expression.empty()) {

      return expression;

    }

    return this->EvaluateExpression("GENEX_EVAL", expression, eval, content,

                                    dagCheckerParent);

  }

} genexEvalNode;

static const struct LowerCaseNode : public cmGeneratorExpressionNode

{

  LowerCaseNode() {} // NOLINT(modernize-use-equals-default)

  bool AcceptsArbitraryContentParameter() const override { return true; }

  std::string Evaluate(

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

    cm::GenEx::Evaluation* /*eval*/,

    GeneratorExpressionContent const* /*content*/,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    return cmSystemTools::LowerCase(parameters.front());

  }

} lowerCaseNode;

static const struct UpperCaseNode : public cmGeneratorExpressionNode

{

  UpperCaseNode() {} // NOLINT(modernize-use-equals-default)

  bool AcceptsArbitraryContentParameter() const override { return true; }

  std::string Evaluate(

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

    cm::GenEx::Evaluation* /*eval*/,

    GeneratorExpressionContent const* /*content*/,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    return cmSystemTools::UpperCase(parameters.front());

  }

} upperCaseNode;

namespace {

template <typename Container>

class Range : public cmRange<typename Container::const_iterator>

{

private:

  using Base = cmRange<typename Container::const_iterator>;

public:

  using const_iterator = typename Container::const_iterator;

  using value_type = typename Container::value_type;

  using size_type = typename Container::size_type;

  using difference_type = typename Container::difference_type;

  using const_reference = typename Container::const_reference;

  Range(Container const& container)

    : Base(container.begin(), container.end())

  {

  }

  const_reference operator[](size_type pos) const

  {

    return *(this->begin() + pos);

  }

  const_reference front() const { return *this->begin(); }

  const_reference back() const { return *std::prev(this->end()); }

  Range& advance(difference_type amount) &

  {

    Base::advance(amount);

    return *this;

  }

  Range advance(difference_type amount) &&

  {

    Base::advance(amount);

    return std::move(*this);

  }

};

using Arguments = Range<std::vector<std::string>>;

bool CheckGenExParameters(cm::GenEx::Evaluation* eval,

                          GeneratorExpressionContent const* cnt,

                          cm::string_view genex, cm::string_view option,

                          std::size_t count, int required = 1,

                          bool exactly = true)

{

  if (static_cast<int>(count) < required ||

      (exactly && static_cast<int>(count) > required)) {

    std::string nbParameters;

    switch (required) {

      case 1:

        nbParameters = "one parameter";

        break;

      case 2:

        nbParameters = "two parameters";

        break;

      case 3:

        nbParameters = "three parameters";

        break;

      case 4:

        nbParameters = "four parameters";

        break;

      default:

        nbParameters = cmStrCat(required, " parameters");

    }

    reportError(eval, cnt->GetOriginalExpression(),

                cmStrCat("$<", genex, ':', option, "> expression requires ",

                         (exactly ? "exactly" : "at least"), ' ', nbParameters,

                         '.'));

    return false;

  }

  return true;

};

template <typename IndexType>

bool GetNumericArgument(std::string const& arg, IndexType& value)

{

  try {

    std::size_t pos;

    if (sizeof(IndexType) == sizeof(long)) {

      value = std::stol(arg, &pos);

    } else {

      value = std::stoll(arg, &pos);

    }

    if (pos != arg.length()) {

      // this is not a number

      return false;

    }

  } catch (std::invalid_argument const&) {

    return false;

  }

  return true;

}

template <typename IndexType>

bool GetNumericArguments(

  cm::GenEx::Evaluation* eval, GeneratorExpressionContent const* cnt,

  Arguments args, std::vector<IndexType>& indexes,

  cmList::ExpandElements expandElements = cmList::ExpandElements::No)

{

  using IndexRange = cmRange<Arguments::const_iterator>;

  IndexRange arguments(args.begin(), args.end());

  cmList list;

  if (expandElements == cmList::ExpandElements::Yes) {

    list = cmList{ args.begin(), args.end(), expandElements };

    arguments = IndexRange{ list.begin(), list.end() };

  }

  for (auto const& value : arguments) {

    IndexType index;

    if (!GetNumericArgument(value, index)) {

      reportError(eval, cnt->GetOriginalExpression(),

                  cmStrCat("index: \"", value, "\" is not a valid index"));

      return false;

    }

    indexes.push_back(index);

  }

  return true;

}

bool CheckPathParametersEx(cm::GenEx::Evaluation* eval,

                           GeneratorExpressionContent const* cnt,

                           cm::string_view option, std::size_t count,

                           int required = 1, bool exactly = true)

{

  return CheckGenExParameters(eval, cnt, "PATH"_s, option, count, required,

                              exactly);

}

bool CheckPathParameters(cm::GenEx::Evaluation* eval,

                         GeneratorExpressionContent const* cnt,

                         cm::string_view option, Arguments args,

                         int required = 1)

{

  return CheckPathParametersEx(eval, cnt, option, args.size(), required);

};

std::string ToString(bool isTrue)

{

  return isTrue ? "1" : "0";

};

}

static const struct PathNode : public cmGeneratorExpressionNode

{

  PathNode() {} // NOLINT(modernize-use-equals-default)

  int NumExpectedParameters() const override { return TwoOrMoreParameters; }

  bool AcceptsArbitraryContentParameter() const override { return true; }

  std::string Evaluate(

    std::vector<std::string> const& parameters, cm::GenEx::Evaluation* eval,

    GeneratorExpressionContent const* content,

    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override

  {

    static auto processList =

      [](std::string const& arg,

         std::function<void(std::string&)> transform) -> std::string {

      cmList list{ arg };

      std::for_each(list.begin(), list.end(), std::move(transform));

      return list.to_string();

    };

    static std::unordered_map<

      cm::string_view,

      std::function<std::string(cm::GenEx::Evaluation*,

                                GeneratorExpressionContent const*,

                                Arguments&)>>

      pathCommands{

        { "GET_ROOT_NAME"_s,

          [](cm::GenEx::Evaluation* ev, GeneratorExpressionContent const* cnt,

             Arguments& args) -> std::string {

            if (CheckPathParameters(ev, cnt, "GET_ROOT_NAME"_s, args) &&

                !args.front().empty()) {

              return processList(args.front(), [](std::string& value) {

                value = cmCMakePath{ value }.GetRootName().String();

              });

            }

            return std::string{};

          } },

        { "GET_ROOT_DIRECTORY"_s,

          [](cm::GenEx::Evaluation* ev, GeneratorExpressionContent const* cnt,

             Arguments& args) -> std::string {

            if (CheckPathParameters(ev, cnt, "GET_ROOT_DIRECTORY"_s, args) &&

                !args.front().empty()) {

              return processList(args.front(), [](std::string& value) {

                value = cmCMakePath{ value }.GetRootDirectory().String();

              });

            }

            return std::string{};

          } },

        { "GET_ROOT_PATH"_s,

          [](cm::GenEx::Evaluation* ev, GeneratorExpressionContent const* cnt,

             Arguments& args) -> std::string {

            if (CheckPathParameters(ev, cnt, "GET_ROOT_PATH"_s, args) &&

                !args.front().empty()) {

              return processList(args.front(), [](std::string& value) {

                value = cmCMakePath{ value }.GetRootPath().String();

              });

            }

            return std::string{};

          } },

        { "GET_FILENAME"_s,

          [](cm::GenEx::Evaluation* ev, GeneratorExpressionContent const* cnt,

             Arguments& args) -> std::string {

            if (CheckPathParameters(ev, cnt, "GET_FILENAME"_s, args) &&

                !args.front().empty()) {

              return processList(args.front(), [](std::string& value) {

                value = cmCMakePath{ value }.GetFileName().String();

              });

            }

            return std::string{};

          } },

        { "GET_EXTENSION"_s,

          [](cm::GenEx::Evaluation* ev, GeneratorExpressionContent const* cnt,

             Arguments& args) -> std::string {

            bool lastOnly = args.front() == "LAST_ONLY"_s;

            if (lastOnly) {

              args.advance(1);

            }

            if (CheckPathParametersEx(ev, cnt,

                                      lastOnly ? "GET_EXTENSION,LAST_ONLY"_s

                                               : "GET_EXTENSION"_s,