cmList: CMake list implementation

Fixes: #24548

Source/CMakeLists.txt

@@ -333,6 +333,8 @@ add_library(
   cmLinkLineComputer.h
   cmLinkLineDeviceComputer.cxx
   cmLinkLineDeviceComputer.h
+  cmList.h
+  cmList.cxx
   cmListFileCache.cxx
   cmListFileCache.h
   cmLocalCommonGenerator.cxx

Source/cmAlgorithms.h

@@ -95,7 +95,7 @@ typename Range::const_iterator cmRemoveIndices(Range& r, InputRange const& rem)
 }
 
 template <typename Range, typename MatchRange>
-typename Range::const_iterator cmRemoveMatching(Range& r, MatchRange const& m)
+auto cmRemoveMatching(Range& r, MatchRange const& m) -> decltype(r.begin())
 {
   return std::remove_if(r.begin(), r.end(),
                         ContainerAlgorithms::BinarySearcher<MatchRange>(m));

Source/cmList.cxx

@@ -0,0 +1,996 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmList.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <iterator>
+#include <set>
+#include <stdexcept>
+#include <utility>
+
+#include <cm/memory>
+
+#include "cmsys/RegularExpression.hxx"
+
+#include "cmAlgorithms.h"
+#include "cmGeneratorExpression.h"
+#include "cmRange.h"
+#include "cmStringAlgorithms.h"
+#include "cmStringReplaceHelper.h"
+#include "cmSystemTools.h"
+
+cm::string_view cmList::element_separator{ ";" };
+
+cmList cmList::sublist(size_type pos, size_type length) const
+{
+  if (pos >= this->Values.size()) {
+    throw std::out_of_range(cmStrCat(
+      "begin index: ", pos, " is out of range 0 - ", this->Values.size() - 1));
+  }
+
+  size_type count = (length == npos || pos + length > this->size())
+    ? this->size()
+    : pos + length;
+  return this->sublist(this->begin() + pos, this->begin() + count);
+}
+
+cmList::size_type cmList::find(cm::string_view value) const
+{
+  auto res = std::find(this->Values.begin(), this->Values.end(), value);
+  if (res == this->Values.end()) {
+    return npos;
+  }
+
+  return std::distance(this->Values.begin(), res);
+}
+
+cmList& cmList::remove_duplicates()
+{
+  auto newEnd = cmRemoveDuplicates(this->Values);
+  this->Values.erase(newEnd, this->Values.end());
+
+  return *this;
+}
+
+namespace {
+class MatchesRegex
+{
+public:
+  MatchesRegex(cmsys::RegularExpression& regex, cmList::FilterMode mode)
+    : Regex(regex)
+    , IncludeMatches(mode == cmList::FilterMode::INCLUDE)
+  {
+  }
+
+  bool operator()(const std::string& target)
+  {
+    return this->Regex.find(target) ^ this->IncludeMatches;
+  }
+
+private:
+  cmsys::RegularExpression& Regex;
+  const bool IncludeMatches;
+};
+}
+
+cmList& cmList::filter(cm::string_view pattern, FilterMode mode)
+{
+  cmsys::RegularExpression regex(std::string{ pattern });
+  if (!regex.is_valid()) {
+    throw std::invalid_argument(cmStrCat("invalid regex: ", pattern));
+  }
+
+  auto it = std::remove_if(this->Values.begin(), this->Values.end(),
+                           MatchesRegex{ regex, mode });
+  this->Values.erase(it, this->Values.end());
+
+  return *this;
+}
+
+namespace {
+class StringSorter
+{
+protected:
+  using StringFilter = std::function<std::string(const std::string&)>;
+
+  using OrderMode = cmList::SortConfiguration::OrderMode;
+  using CompareMethod = cmList::SortConfiguration::CompareMethod;
+  using CaseSensitivity = cmList::SortConfiguration::CaseSensitivity;
+
+  StringFilter GetCompareFilter(CompareMethod compare)
+  {
+    return (compare == CompareMethod::FILE_BASENAME)
+      ? cmSystemTools::GetFilenameName
+      : nullptr;
+  }
+
+  StringFilter GetCaseFilter(CaseSensitivity sensitivity)
+  {
+    return (sensitivity == CaseSensitivity::INSENSITIVE)
+      ? cmSystemTools::LowerCase
+      : nullptr;
+  }
+
+  using ComparisonFunction =
+    std::function<bool(const std::string&, const std::string&)>;
+  ComparisonFunction GetComparisonFunction(CompareMethod compare)
+  {
+    if (compare == CompareMethod::NATURAL) {
+      return std::function<bool(const std::string&, const std::string&)>(
+        [](const std::string& x, const std::string& y) {
+          return cmSystemTools::strverscmp(x, y) < 0;
+        });
+    }
+    return std::function<bool(const std::string&, const std::string&)>(
+      [](const std::string& x, const std::string& y) { return x < y; });
+  }
+
+public:
+  StringSorter(cmList::SortConfiguration const& config)
+    : Filters{ this->GetCompareFilter(config.Compare),
+               this->GetCaseFilter(config.Case) }
+    , SortMethod(this->GetComparisonFunction(config.Compare))
+    , Descending(config.Order == OrderMode::DESCENDING)
+  {
+  }
+
+  std::string ApplyFilter(const std::string& argument)
+  {
+    std::string result = argument;
+    for (auto const& filter : this->Filters) {
+      if (filter != nullptr) {
+        result = filter(result);
+      }
+    }
+    return result;
+  }
+
+  bool operator()(const std::string& a, const std::string& b)
+  {
+    std::string af = this->ApplyFilter(a);
+    std::string bf = this->ApplyFilter(b);
+    bool result;
+    if (this->Descending) {
+      result = this->SortMethod(bf, af);
+    } else {
+      result = this->SortMethod(af, bf);
+    }
+    return result;
+  }
+
+private:
+  StringFilter Filters[2] = { nullptr, nullptr };
+  ComparisonFunction SortMethod;
+  bool Descending;
+};
+}
+
+cmList::SortConfiguration::SortConfiguration() = default;
+
+cmList& cmList::sort(const SortConfiguration& cfg)
+{
+  SortConfiguration config{ cfg };
+
+  if (config.Order == SortConfiguration::OrderMode::DEFAULT) {
+    config.Order = SortConfiguration::OrderMode::ASCENDING;
+  }
+  if (config.Compare == SortConfiguration::CompareMethod::DEFAULT) {
+    config.Compare = SortConfiguration::CompareMethod::STRING;
+  }
+  if (config.Case == SortConfiguration::CaseSensitivity::DEFAULT) {
+    config.Case = SortConfiguration::CaseSensitivity::SENSITIVE;
+  }
+
+  if ((config.Compare == SortConfiguration::CompareMethod::STRING) &&
+      (config.Case == SortConfiguration::CaseSensitivity::SENSITIVE) &&
+      (config.Order == SortConfiguration::OrderMode::ASCENDING)) {
+    std::sort(this->Values.begin(), this->Values.end());
+  } else {
+    StringSorter sorter(config);
+    std::sort(this->Values.begin(), this->Values.end(), sorter);
+  }
+
+  return *this;
+}
+
+namespace {
+using transform_type = std::function<std::string(const std::string&)>;
+using transform_error = cmList::transform_error;
+
+class TransformSelector : public cmList::TransformSelector
+{
+public:
+  ~TransformSelector() override = default;
+
+  std::string Tag;
+
+  const std::string& GetTag() override { return this->Tag; }
+
+  virtual bool Validate(std::size_t count = 0) = 0;
+
+  virtual bool InSelection(const std::string&) = 0;
+
+  virtual void Transform(cmList::container_type& list,
+                         const transform_type& transform)
+  {
+    std::transform(list.begin(), list.end(), list.begin(), transform);
+  }
+
+protected:
+  TransformSelector(std::string&& tag)
+    : Tag(std::move(tag))
+  {
+  }
+};
+
+class TransformNoSelector : public TransformSelector
+{
+public:
+  TransformNoSelector()
+    : TransformSelector("NO SELECTOR")
+  {
+  }
+
+  bool Validate(std::size_t) override { return true; }
+
+  bool InSelection(const std::string&) override { return true; }
+};
+class TransformSelectorRegex : public TransformSelector
+{
+public:
+  TransformSelectorRegex(const std::string& regex)
+    : TransformSelector("REGEX")
+    , Regex(regex)
+  {
+  }
+  TransformSelectorRegex(std::string&& regex)
+    : TransformSelector("REGEX")
+    , Regex(regex)
+  {
+  }
+
+  bool Validate(std::size_t) override { return this->Regex.is_valid(); }
+
+  bool InSelection(const std::string& value) override
+  {
+    return this->Regex.find(value);
+  }
+
+  cmsys::RegularExpression Regex;
+};
+class TransformSelectorIndexes : public TransformSelector
+{
+public:
+  std::vector<index_type> Indexes;
+
+  bool InSelection(const std::string&) override { return true; }
+
+  void Transform(std::vector<std::string>& list,
+                 const transform_type& transform) override
+  {
+    this->Validate(list.size());
+
+    for (auto index : this->Indexes) {
+      list[index] = transform(list[index]);
+    }
+  }
+
+protected:
+  TransformSelectorIndexes(std::string&& tag)
+    : TransformSelector(std::move(tag))
+  {
+  }
+  TransformSelectorIndexes(std::string&& tag, std::vector<int> const& indexes)
+    : TransformSelector(std::move(tag))
+    , Indexes(indexes)
+  {
+  }
+  TransformSelectorIndexes(std::string&& tag, std::vector<int>&& indexes)
+    : TransformSelector(std::move(tag))
+    , Indexes(indexes)
+  {
+  }
+
+  int NormalizeIndex(index_type index, std::size_t count)
+  {
+    if (index < 0) {
+      index = static_cast<index_type>(count) + index;
+    }
+    if (index < 0 || count <= static_cast<std::size_t>(index)) {
+      throw transform_error(cmStrCat(
+        "sub-command TRANSFORM, selector ", this->Tag, ", index: ", index,
+        " out of range (-", count, ", ", count - 1, ")."));
+    }
+    return index;
+  }
+};
+class TransformSelectorAt : public TransformSelectorIndexes
+{
+public:
+  TransformSelectorAt(std::vector<index_type> const& indexes)
+    : TransformSelectorIndexes("AT", indexes)
+  {
+  }
+  TransformSelectorAt(std::vector<index_type>&& indexes)
+    : TransformSelectorIndexes("AT", std::move(indexes))
+  {
+  }
+
+  bool Validate(std::size_t count) override
+  {
+    decltype(this->Indexes) indexes;
+
+    for (auto index : this->Indexes) {
+      indexes.push_back(this->NormalizeIndex(index, count));
+    }
+    this->Indexes = std::move(indexes);
+
+    return true;
+  }
+};
+class TransformSelectorFor : public TransformSelectorIndexes
+{
+public:
+  TransformSelectorFor(int start, int stop, int step)
+    : TransformSelectorIndexes("FOR")
+    , Start(start)
+    , Stop(stop)
+    , Step(step)
+  {
+  }
+
+  bool Validate(std::size_t count) override
+  {
+    this->Start = this->NormalizeIndex(this->Start, count);
+    this->Stop = this->NormalizeIndex(this->Stop, count);
+
+    // Does stepping move us further from the end?
+    if (this->Start > this->Stop) {
+      throw transform_error(
+        cmStrCat("sub-command TRANSFORM, selector FOR "
+                 "expects <start> to be no greater than <stop> (",
+                 this->Start, " > ", this->Stop, ")"));
+    }
+
+    // compute indexes
+    auto size = (this->Stop - this->Start + 1) / this->Step;
+    if ((this->Stop - this->Start + 1) % this->Step != 0) {
+      size += 1;
+    }
+
+    this->Indexes.resize(size);
+    auto start = this->Start;
+    auto step = this->Step;
+    std::generate(this->Indexes.begin(), this->Indexes.end(),
+                  [&start, step]() -> int {
+                    auto r = start;
+                    start += step;
+                    return r;
+                  });
+
+    return true;
+  }
+
+private:
+  index_type Start, Stop, Step;
+};
+
+class TransformAction
+{
+public:
+  virtual ~TransformAction() = default;
+
+  void Initialize(TransformSelector* selector) { this->Selector = selector; }
+  virtual void Initialize(TransformSelector*, const std::string&) {}
+  virtual void Initialize(TransformSelector*, const std::string&,
+                          const std::string&)
+  {
+  }
+  virtual void Initialize(TransformSelector* selector,
+                          const std::vector<std::string>&)
+  {
+    this->Initialize(selector);
+  }
+
+  virtual std::string operator()(const std::string& s) = 0;
+
+protected:
+  TransformSelector* Selector;
+};
+class TransformActionAppend : public TransformAction
+{
+public:
+  using TransformAction::Initialize;
+
+  void Initialize(TransformSelector* selector,
+                  const std::string& append) override
+  {
+    TransformAction::Initialize(selector);
+    this->Append = append;
+  }
+  void Initialize(TransformSelector* selector,
+                  const std::vector<std::string>& append) override
+  {
+    this->Initialize(selector, append.front());
+  }
+
+  std::string operator()(const std::string& s) override
+  {
+    if (this->Selector->InSelection(s)) {
+      return cmStrCat(s, this->Append);
+    }
+
+    return s;
+  }
+
+private:
+  std::string Append;
+};
+class TransformActionPrepend : public TransformAction
+{
+public:
+  using TransformAction::Initialize;
+
+  void Initialize(TransformSelector* selector,
+                  const std::string& prepend) override
+  {
+    TransformAction::Initialize(selector);
+    this->Prepend = prepend;
+  }
+  void Initialize(TransformSelector* selector,
+                  const std::vector<std::string>& prepend) override
+  {
+    this->Initialize(selector, prepend.front());
+  }
+
+  std::string operator()(const std::string& s) override
+  {
+    if (this->Selector->InSelection(s)) {
+      return cmStrCat(this->Prepend, s);
+    }
+
+    return s;
+  }
+
+private:
+  std::string Prepend;
+};
+class TransformActionToUpper : public TransformAction
+{
+public:
+  std::string operator()(const std::string& s) override
+  {
+    if (this->Selector->InSelection(s)) {
+      return cmSystemTools::UpperCase(s);
+    }
+
+    return s;
+  }
+};
+class TransformActionToLower : public TransformAction
+{
+public:
+  std::string operator()(const std::string& s) override
+  {
+    if (this->Selector->InSelection(s)) {
+      return cmSystemTools::LowerCase(s);
+    }
+
+    return s;
+  }
+};
+class TransformActionStrip : public TransformAction
+{
+public:
+  std::string operator()(const std::string& s) override
+  {
+    if (this->Selector->InSelection(s)) {
+      return cmTrimWhitespace(s);
+    }
+
+    return s;
+  }
+};
+class TransformActionGenexStrip : public TransformAction
+{
+public:
+  std::string operator()(const std::string& s) override
+  {
+    if (this->Selector->InSelection(s)) {
+      return cmGeneratorExpression::Preprocess(
+        s, cmGeneratorExpression::StripAllGeneratorExpressions);
+    }
+
+    return s;
+  }
+};
+class TransformActionReplace : public TransformAction
+{
+public:
+  using TransformAction::Initialize;
+
+  void Initialize(TransformSelector* selector, const std::string& regex,
+                  const std::string& replace) override
+  {
+    TransformAction::Initialize(selector);
+    this->ReplaceHelper =
+      cm::make_unique<cmStringReplaceHelper>(regex, replace);
+
+    if (!this->ReplaceHelper->IsRegularExpressionValid()) {
+      throw transform_error(
+        cmStrCat("sub-command TRANSFORM, action REPLACE: Failed to compile "
+                 "regex \"",
+                 regex, "\"."));
+    }
+    if (!this->ReplaceHelper->IsReplaceExpressionValid()) {
+      throw transform_error(cmStrCat("sub-command TRANSFORM, action REPLACE: ",
+                                     this->ReplaceHelper->GetError(), "."));
+    }
+  }
+  void Initialize(TransformSelector* selector,
+                  const std::vector<std::string>& args) override
+  {
+    this->Initialize(selector, args[0], args[1]);
+  }
+
+  std::string operator()(const std::string& s) override
+  {
+    if (this->Selector->InSelection(s)) {
+      // Scan through the input for all matches.
+      std::string output;
+
+      if (!this->ReplaceHelper->Replace(s, output)) {
+        throw transform_error(
+          cmStrCat("sub-command TRANSFORM, action REPLACE: ",
+                   this->ReplaceHelper->GetError(), "."));
+      }
+
+      return output;
+    }
+
+    return s;
+  }
+
+private:
+  std::unique_ptr<cmStringReplaceHelper> ReplaceHelper;
+};
+
+// Descriptor of action
+// Arity: number of arguments required for the action
+// Transform: Object implementing the action
+struct ActionDescriptor
+{
+  ActionDescriptor(cmList::TransformAction action)
+    : Action(action)
+  {
+  }
+  ActionDescriptor(cmList::TransformAction action, std::string name,
+                   std::size_t arity,
+                   std::unique_ptr<TransformAction> transform)
+    : Action(action)
+    , Name(std::move(name))
+    , Arity(arity)
+    , Transform(std::move(transform))
+  {
+  }
+
+  operator cmList::TransformAction() const { return this->Action; }
+
+  cmList::TransformAction Action;
+  std::string Name;
+  std::size_t Arity = 0;
+  std::unique_ptr<TransformAction> Transform;
+};
+
+// Build a set of supported actions.
+using ActionDescriptorSet = std::set<
+  ActionDescriptor,
+  std::function<bool(cmList::TransformAction, cmList::TransformAction)>>;
+
+ActionDescriptorSet Descriptors([](cmList::TransformAction x,
+                                   cmList::TransformAction y) {
+  return x < y;
+});
+
+ActionDescriptorSet::iterator TransformConfigure(
+  cmList::TransformAction action,
+  std::unique_ptr<cmList::TransformSelector>& selector, std::size_t arity)
+{
+  if (Descriptors.empty()) {
+    Descriptors.emplace(cmList::TransformAction::APPEND, "APPEND", 1,
+                        cm::make_unique<TransformActionAppend>());
+    Descriptors.emplace(cmList::TransformAction::PREPEND, "PREPEND", 1,
+                        cm::make_unique<TransformActionPrepend>());
+    Descriptors.emplace(cmList::TransformAction::TOUPPER, "TOUPPER", 0,
+                        cm::make_unique<TransformActionToUpper>());
+    Descriptors.emplace(cmList::TransformAction::TOLOWER, "TOLOWER", 0,
+                        cm::make_unique<TransformActionToLower>());
+    Descriptors.emplace(cmList::TransformAction::STRIP, "STRIP", 0,
+                        cm::make_unique<TransformActionStrip>());
+    Descriptors.emplace(cmList::TransformAction::GENEX_STRIP, "GENEX_STRIP", 0,
+                        cm::make_unique<TransformActionGenexStrip>());
+    Descriptors.emplace(cmList::TransformAction::REPLACE, "REPLACE", 2,
+                        cm::make_unique<TransformActionReplace>());
+  }
+
+  auto descriptor = Descriptors.find(action);
+  if (descriptor == Descriptors.end()) {
+    throw transform_error(cmStrCat(" sub-command TRANSFORM, ",
+                                   std::to_string(static_cast<int>(action)),
+                                   " invalid action."));
+  }
+
+  if (descriptor->Arity != arity) {
+    throw transform_error(cmStrCat("sub-command TRANSFORM, action ",
+                                   descriptor->Name, " expects ",
+                                   descriptor->Arity, " argument(s)."));
+  }
+  if (!selector) {
+    selector = cm::make_unique<TransformNoSelector>();
+  }
+
+  return descriptor;
+}
+}
+
+std::unique_ptr<cmList::TransformSelector> cmList::TransformSelector::NewAT(
+  std::initializer_list<index_type> indexes)
+{
+  return cm::make_unique<TransformSelectorAt>(
+    std::vector<index_type>{ indexes.begin(), indexes.end() });
+  ;
+}
+std::unique_ptr<cmList::TransformSelector> cmList::TransformSelector::NewAT(
+  std::vector<index_type> const& indexes)
+{
+  return cm::make_unique<TransformSelectorAt>(indexes);
+}
+std::unique_ptr<cmList::TransformSelector> cmList::TransformSelector::NewAT(
+  std::vector<index_type>&& indexes)
+{
+  return cm::make_unique<TransformSelectorAt>(std::move(indexes));
+}
+
+std::unique_ptr<cmList::TransformSelector> cmList::TransformSelector::NewFOR(
+  std::initializer_list<index_type> indexes)
+{
+  if (indexes.size() < 2 || indexes.size() > 3) {
+    throw transform_error("sub-command TRANSFORM, selector FOR "
+                          "expects 2 or 3 arguments");
+  }
+  if (indexes.size() == 3 && *(indexes.begin() + 2) < 0) {
+    throw transform_error("sub-command TRANSFORM, selector FOR expects "
+                          "positive numeric value for <step>.");
+  }
+
+  return cm::make_unique<TransformSelectorFor>(
+    *indexes.begin(), *(indexes.begin() + 1),
+    indexes.size() == 3 ? *(indexes.begin() + 2) : 1);
+}
+std::unique_ptr<cmList::TransformSelector> cmList::TransformSelector::NewFOR(
+  std::vector<index_type> const& indexes)
+{
+  if (indexes.size() < 2 || indexes.size() > 3) {
+    throw transform_error("sub-command TRANSFORM, selector FOR "
+                          "expects 2 or 3 arguments");
+  }
+  if (indexes.size() == 3 && indexes[2] < 0) {
+    throw transform_error("sub-command TRANSFORM, selector FOR expects "
+                          "positive numeric value for <step>.");
+  }
+
+  return cm::make_unique<TransformSelectorFor>(
+    indexes[0], indexes[1], indexes.size() == 3 ? indexes[2] : 1);
+}
+std::unique_ptr<cmList::TransformSelector> cmList::TransformSelector::NewFOR(
+  std::vector<index_type>&& indexes)
+{
+  if (indexes.size() < 2 || indexes.size() > 3) {
+    throw transform_error("sub-command TRANSFORM, selector FOR "
+                          "expects 2 or 3 arguments");
+  }
+  if (indexes.size() == 3 && indexes[2] < 0) {
+    throw transform_error("sub-command TRANSFORM, selector FOR expects "
+                          "positive numeric value for <step>.");
+  }
+
+  return cm::make_unique<TransformSelectorFor>(
+    indexes[0], indexes[1], indexes.size() == 3 ? indexes[2] : 1);
+}
+
+std::unique_ptr<cmList::TransformSelector> cmList::TransformSelector::NewREGEX(
+  std::string const& regex)
+{
+  std::unique_ptr<::TransformSelector> selector =
+    cm::make_unique<TransformSelectorRegex>(regex);
+  if (!selector->Validate()) {
+    throw transform_error(
+      cmStrCat("sub-command TRANSFORM, selector REGEX failed to compile "
+               "regex \"",
+               regex, "\"."));
+  }
+  // weird construct to please all compilers
+  return std::unique_ptr<cmList::TransformSelector>(selector.release());
+}
+std::unique_ptr<cmList::TransformSelector> cmList::TransformSelector::NewREGEX(
+  std::string&& regex)
+{
+  std::unique_ptr<::TransformSelector> selector =
+    cm::make_unique<TransformSelectorRegex>(std::move(regex));
+  if (!selector->Validate()) {
+    throw transform_error(
+      cmStrCat("sub-command TRANSFORM, selector REGEX failed to compile "
+               "regex \"",
+               regex, "\"."));
+  }
+  // weird construct to please all compilers
+  return std::unique_ptr<cmList::TransformSelector>(selector.release());
+}
+
+cmList& cmList::transform(TransformAction action,
+                          std::unique_ptr<TransformSelector> selector)
+{
+  auto descriptor = TransformConfigure(action, selector, 0);
+
+  descriptor->Transform->Initialize(
+    static_cast<::TransformSelector*>(selector.get()));
+
+  static_cast<::TransformSelector&>(*selector).Transform(
+    this->Values, [&descriptor](const std::string& s) -> std::string {
+      return (*descriptor->Transform)(s);
+    });
+
+  return *this;
+}
+
+cmList& cmList::transform(TransformAction action, std::string const& arg,
+                          std::unique_ptr<TransformSelector> selector)
+{
+  auto descriptor = TransformConfigure(action, selector, 1);
+
+  descriptor->Transform->Initialize(
+    static_cast<::TransformSelector*>(selector.get()), arg);
+
+  static_cast<::TransformSelector&>(*selector).Transform(
+    this->Values, [&descriptor](const std::string& s) -> std::string {
+      return (*descriptor->Transform)(s);
+    });
+
+  return *this;
+}
+
+cmList& cmList::transform(TransformAction action, std::string const& arg1,
+                          std::string const& arg2,
+                          std::unique_ptr<TransformSelector> selector)
+{
+  auto descriptor = TransformConfigure(action, selector, 2);
+
+  descriptor->Transform->Initialize(
+    static_cast<::TransformSelector*>(selector.get()), arg1, arg2);
+
+  static_cast<::TransformSelector&>(*selector).Transform(
+    this->Values, [&descriptor](const std::string& s) -> std::string {
+      return (*descriptor->Transform)(s);
+    });
+
+  return *this;
+}
+
+cmList& cmList::transform(TransformAction action,
+                          std::vector<std::string> const& args,
+                          std::unique_ptr<TransformSelector> selector)
+{
+  auto descriptor = TransformConfigure(action, selector, args.size());
+
+  descriptor->Transform->Initialize(
+    static_cast<::TransformSelector*>(selector.get()), args);
+
+  static_cast<::TransformSelector&>(*selector).Transform(
+    this->Values, [&descriptor](const std::string& s) -> std::string {
+      return (*descriptor->Transform)(s);
+    });
+
+  return *this;
+}
+
+std::string cmList::join(cm::string_view glue) const
+{
+  return cmJoin(this->Values, glue);
+}
+
+std::string& cmList::append(cm::string_view value, std::string& list)
+{
+  if (list.empty()) {
+    list = std::string(value);
+  } else {
+    list += cmStrCat(cmList::element_separator, value);
+  }
+
+  return list;
+}
+
+std::string& cmList::prepend(cm::string_view value, std::string& list)
+{
+  if (list.empty()) {
+    list = std::string(value);
+  } else {
+    list.insert(0, cmStrCat(value, cmList::element_separator));
+  }
+
+  return list;
+}
+
+cmList::size_type cmList::ComputeIndex(index_type pos, bool boundCheck) const
+{
+  if (boundCheck) {
+    if (this->Values.empty()) {
+      throw std::out_of_range(
+        cmStrCat("index: ", pos, " out of range (0, 0)"));
+    }
+
+    if (!this->Values.empty()) {
+      auto length = this->Values.size();
+      if (pos < 0) {
+        pos = static_cast<index_type>(length) + pos;
+      }
+      if (pos < 0 || length <= static_cast<size_type>(pos)) {
+        throw std::out_of_range(cmStrCat("index: ", pos, " out of range (-",
+                                         this->Values.size(), ", ",
+                                         this->Values.size() - 1, ")"));
+      }
+    }
+    return pos;
+  }
+
+  return pos < 0 ? this->Values.size() + pos : pos;
+}
+cmList::size_type cmList::ComputeInsertIndex(index_type pos,
+                                             bool boundCheck) const
+{
+  if (boundCheck) {
+    if (this->Values.empty() && pos != 0) {
+      throw std::out_of_range(
+        cmStrCat("index: ", pos, " out of range (0, 0)"));
+    }
+
+    if (!this->Values.empty()) {
+      auto length = this->Values.size();
+      if (pos < 0) {
+        pos = static_cast<index_type>(length) + pos;
+      }
+      if (pos < 0 || length < static_cast<size_type>(pos)) {
+        throw std::out_of_range(cmStrCat("index: ", pos, " out of range (-",
+                                         this->Values.size(), ", ",
+                                         this->Values.size(), ")"));
+      }
+    }
+    return pos;
+  }
+
+  return pos < 0 ? this->Values.size() + pos : pos;
+}
+
+cmList cmList::GetItems(std::vector<index_type>&& indexes) const
+{
+  cmList listItems;
+
+  for (auto index : indexes) {
+    listItems.emplace_back(this->at(index));
+  }
+
+  return listItems;
+}
+
+cmList& cmList::RemoveItems(std::vector<index_type>&& indexes)
+{
+  if (indexes.empty()) {
+    return *this;
+  }
+
+  // compute all indexes
+  std::vector<size_type> idx(indexes.size());
+  std::transform(
+    indexes.cbegin(), indexes.cend(), idx.begin(),
+    [this](const index_type& index) { return this->ComputeIndex(index); });
+
+  std::sort(idx.begin(), idx.end(),
+            [](size_type l, size_type r) { return l > r; });
+  auto newEnd = std::unique(idx.begin(), idx.end());
+  idx.erase(newEnd, idx.end());
+
+  for (auto index : idx) {
+    this->erase(this->begin() + index);
+  }
+
+  return *this;
+}
+
+cmList& cmList::RemoveItems(std::vector<std::string>&& items)
+{
+  std::sort(items.begin(), items.end());
+  auto last = std::unique(items.begin(), items.end());
+  auto first = items.begin();
+
+  auto newEnd = cmRemoveMatching(this->Values, cmMakeRange(first, last));
+  this->Values.erase(newEnd, this->Values.end());
+
+  return *this;
+}
+
+cmList::container_type::iterator cmList::Insert(
+  container_type::const_iterator pos, std::string&& value,
+  container_type& container, ExpandElements expandElements,
+  EmptyElements emptyElements)
+{
+  auto delta = std::distance(container.cbegin(), pos);
+  auto insertPos = container.begin() + delta;
+
+  if (expandElements == ExpandElements::Yes) {
+    // If argument is empty, it is an empty list.
+    if (emptyElements == EmptyElements::No && value.empty()) {
+      return insertPos;
+    }
+
+    // if there are no ; in the name then just copy the current string
+    if (value.find(';') == std::string::npos) {
+      return container.insert(insertPos, std::move(value));
+    }
+
+    std::string newValue;
+    // Break the string at non-escaped semicolons not nested in [].
+    int squareNesting = 0;
+    auto last = value.begin();
+    auto const cend = value.end();
+    for (auto c = last; c != cend; ++c) {
+      switch (*c) {
+        case '\\': {
+          // We only want to allow escaping of semicolons.  Other
+          // escapes should not be processed here.
+          auto cnext = c + 1;
+          if ((cnext != cend) && *cnext == ';') {
+            newValue.append(last, c);
+            // Skip over the escape character
+            last = cnext;
+            c = cnext;
+          }
+        } break;
+        case '[': {
+          ++squareNesting;
+        } break;
+        case ']': {
+          --squareNesting;
+        } break;
+        case ';': {
+          // brackets.
+          if (squareNesting == 0) {
+            newValue.append(last, c);
+            // Skip over the semicolon
+            last = c + 1;
+            if (!newValue.empty() || emptyElements == EmptyElements::Yes) {
+              // Add the last argument.
+              insertPos = container.insert(insertPos, newValue);
+              insertPos++;
+              newValue.clear();
+            }
+          }
+        } break;
+        default: {
+          // Just append this character.
+        } break;
+      }
+    }
+    newValue.append(last, cend);
+    if (!newValue.empty() || emptyElements == EmptyElements::Yes) {
+      // Add the last argument.
+      container.insert(insertPos, std::move(newValue));
+    }
+  } else if (!value.empty() || emptyElements == EmptyElements::Yes) {
+    return container.insert(insertPos, std::move(value));
+  }
+  return container.begin() + delta;
+}

Tests/CMakeLib/CMakeLists.txt

@@ -30,6 +30,7 @@ set(CMakeLib_TESTS
   testCMExtMemory.cxx
   testCMExtAlgorithm.cxx
   testCMExtEnumSet.cxx
+  testList.cxx
   )
 if (CMake_TEST_FILESYSTEM_PATH OR NOT CMake_HAVE_CXX_FILESYSTEM)
   list(APPEND CMakeLib_TESTS testCMFilesystemPath.cxx)

Tests/CMakeLib/testList.cxx

@@ -0,0 +1,995 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <cm/string_view>
+
+#include "cmList.h"
+
+namespace {
+
+void checkResult(bool success)
+{
+  if (!success) {
+    std::cout << " => failed";
+  }
+  std::cout << std::endl;
+}
+
+bool testConstructors()
+{
+  std::cout << "testConstructors()";
+
+  bool result = true;
+
+  {
+    cmList list;
+    if (!list.empty() || list != cmList{}) {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "aa;bb" };
+    if (list.size() != 2 || list.to_string() != "aa;bb") {
+      result = false;
+    }
+  }
+  {
+    cmList list1{ "aa", "bb" };
+    cmList list2("aa;bb");
+
+    if (list1.size() != 2 || list2.size() != 2 || list1 != list2) {
+      result = false;
+    }
+    if (list1.to_string() != "aa;bb") {
+      result = false;
+    }
+    if (list1.to_string() != list2.to_string()) {
+      result = false;
+    }
+  }
+  {
+    std::vector<std::string> v{ "aa", "bb", "cc" };
+    cmList list(v.begin(), v.end());
+    if (list.size() != 3 || list.to_string() != "aa;bb;cc") {
+      result = false;
+    }
+  }
+  {
+    std::vector<std::string> values{ "aa;bb", "cc", "dd;ee" };
+    cmList list1(values.begin(), values.end());
+    cmList list2(values.begin(), values.end(), cmList::ExpandElements::No);
+
+    if (list1.size() != 5 || list1.to_string() != "aa;bb;cc;dd;ee") {
+      result = false;
+    }
+    if (list2.size() != 3 || list2.to_string() != "aa;bb;cc;dd;ee") {
+      result = false;
+    }
+  }
+  {
+    std::vector<std::string> values{ "aa;bb;;cc", "", "dd;ee" };
+    cmList list1(values.begin(), values.end(), cmList::ExpandElements::No,
+                 cmList::EmptyElements::No);
+    cmList list2(values.begin(), values.end(), cmList::ExpandElements::No,
+                 cmList::EmptyElements::Yes);
+    cmList list3(values.begin(), values.end(), cmList::ExpandElements::Yes,
+                 cmList::EmptyElements::No);
+    cmList list4(values.begin(), values.end(), cmList::ExpandElements::Yes,
+                 cmList::EmptyElements::Yes);
+
+    if (list1.size() != 2 || list1.to_string() != "aa;bb;;cc;dd;ee") {
+      result = false;
+    }
+    if (list2.size() != 3 || list2.to_string() != "aa;bb;;cc;;dd;ee") {
+      result = false;
+    }
+    if (list3.size() != 5 || list3.to_string() != "aa;bb;cc;dd;ee") {
+      result = false;
+    }
+    if (list4.size() != 7 || list4.to_string() != "aa;bb;;cc;;dd;ee") {
+      result = false;
+    }
+  }
+  {
+    std::vector<std::string> values{ "aa;bb", "cc", "dd;ee" };
+    cmList list1(values);
+    cmList list2(values, cmList::ExpandElements::No);
+
+    if (list1.size() != 5 || list1.to_string() != "aa;bb;cc;dd;ee") {
+      result = false;
+    }
+    if (list2.size() != 3 || list2.to_string() != "aa;bb;cc;dd;ee") {
+      result = false;
+    }
+  }
+  {
+    std::vector<std::string> values{ "aa", "bb", "cc", "dd", "ee" };
+    cmList list(std::move(values));
+
+    if (list.size() != 5 || list.to_string() != "aa;bb;cc;dd;ee") {
+      result = false;
+    }
+    if (!values.empty()) {
+      result = false;
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+
+bool testAssign()
+{
+  std::cout << "testAssign()";
+
+  bool result = true;
+
+  {
+    cmList list1{ "aa", "bb" };
+    cmList list2{ "cc", "dd" };
+
+    list2 = list1;
+    if (list1.size() != 2 || list2.size() != 2 || list1 != list2) {
+      result = false;
+    }
+    if (list1.to_string() != "aa;bb") {
+      result = false;
+    }
+    if (list1.to_string() != list2.to_string()) {
+      result = false;
+    }
+  }
+  {
+    cmList list1{ "aa", "bb" };
+    cmList list2{ "cc", "dd" };
+
+    list2 = std::move(list1);
+    if (!list1.empty() || list2.size() != 2) {
+      result = false;
+    }
+    if (list2.to_string() != "aa;bb") {
+      result = false;
+    }
+  }
+  {
+    std::vector<std::string> v{ "aa", "bb" };
+    cmList list{ "cc", "dd" };
+
+    list = std::move(v);
+    if (!v.empty() || list.size() != 2) {
+      result = false;
+    }
+    if (list.to_string() != "aa;bb") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "cc", "dd" };
+
+    list = "aa;bb";
+    if (list.size() != 2) {
+      result = false;
+    }
+    if (list.to_string() != "aa;bb") {
+      result = false;
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+
+bool testConversions()
+{
+  std::cout << "testConversions()";
+
+  bool result = true;
+
+  {
+    cmList list("a;b;c");
+    std::string s = list.to_string();
+
+    if (s != "a;b;c") {
+      result = false;
+    }
+  }
+  {
+    cmList list("a;b;c");
+    std::vector<std::string> v = list;
+
+    if (list.size() != 3 || v.size() != 3) {
+      result = false;
+    }
+  }
+  {
+    cmList list("a;b;c");
+    std::vector<std::string> v = std::move(list);
+
+    // Microsoft compiler is not able to handle correctly the move semantics
+    // so the initial list is not moved, so do not check its size...
+    if (v.size() != 3) {
+      result = false;
+    }
+  }
+  {
+    cmList list("a;b;c");
+    std::vector<std::string> v;
+
+    // compiler is not able to select the cmList conversion operator
+    // and the std::vector assignment operator using the move semantics
+    // v = std::move(list);
+    v = std::move(list.data());
+
+    if (!list.empty() || v.size() != 3) {
+      result = false;
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+
+bool testAccess()
+{
+  std::cout << "testAccess()";
+
+  bool result = true;
+
+  {
+    cmList list{ "a", "b", "c" };
+    if (list.at(1) != "b") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "a", "b", "c" };
+    if (list.at(-3) != "a") {
+      result = false;
+    }
+  }
+  {
+    try {
+      cmList list{ "a", "b", "c" };
+      if (list.at(4) != "a") {
+        result = false;
+      }
+    } catch (std::out_of_range&) {
+    }
+  }
+  {
+    try {
+      cmList list{ "a", "b", "c" };
+      if (list.at(-4) != "a") {
+        result = false;
+      }
+    } catch (std::out_of_range&) {
+    }
+  }
+  {
+    cmList list{ "a", "b", "c", "d", "e" };
+    auto sublist = list.sublist(list.begin() + 1, list.begin() + 3);
+    if (sublist.size() != 2 || sublist != cmList{ "b", "c" }) {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "a", "b", "c", "d", "e" };
+    auto sublist = list.sublist(1, 2);
+    if (sublist.size() != 2 || sublist != cmList{ "b", "c" }) {
+      result = false;
+    }
+
+    sublist = list.sublist(1, cmList::npos);
+    if (sublist.size() != 4 || sublist != cmList{ "b", "c", "d", "e" }) {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "a", "b", "c", "d", "e", "f" };
+    auto sublist = list.get_items({ 1, 3, 5 });
+    if (sublist.size() != 3 || sublist != cmList{ "b", "d", "f" }) {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "a", "b", "c", "d", "e", "f" };
+    auto sublist = list.get_items({ 1, -3, 5, -3 });
+    if (sublist.size() != 4 || sublist != cmList{ "b", "d", "f", "d" }) {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "a", "b", "c", "d", "e", "f" };
+    try {
+      if (list.get_items({ 1, -3, 5, -3, 10 }).size() != 5) {
+        result = false;
+      }
+    } catch (std::out_of_range&) {
+    }
+  }
+  {
+    cmList list{ "a", "b", "c", "d", "e", "f" };
+
+    if (list.find("b") != 1) {
+      result = false;
+    }
+    if (list.find("x") != cmList::npos) {
+      result = false;
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+
+bool testModifiers()
+{
+  std::cout << "testModifiers()";
+
+  bool result = true;
+
+  {
+    cmList list{ "1;2;3;4;5" };
+
+    auto it = list.insert(list.begin() + 2, "6;7;8");
+    if (list.size() != 8 || list.to_string() != "1;2;6;7;8;3;4;5") {
+      result = false;
+    }
+    if (*it != "6") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "1;2;3;4;5" };
+
+    auto it =
+      list.insert(list.begin() + 2, "6;7;8", cmList::ExpandElements::No);
+    if (list.size() != 6 || list.to_string() != "1;2;6;7;8;3;4;5") {
+      result = false;
+    }
+    if (*it != "6;7;8") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "1;2;3;4;5" };
+    cmList v{ "6", "7", "8" };
+
+    auto it = list.insert(list.begin() + 2, v);
+    if (list.size() != 8 || list.to_string() != "1;2;6;7;8;3;4;5") {
+      result = false;
+    }
+    if (*it != "6") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "1;2;3;4;5" };
+    cmList v{ "6", "7", "8" };
+
+    auto it = list.insert(list.begin() + 2, std::move(v));
+    if (list.size() != 8 || list.to_string() != "1;2;6;7;8;3;4;5") {
+      result = false;
+    }
+    if (*it != "6") {
+      result = false;
+    }
+
+    if (!v.empty()) {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "1;2;3;4;5" };
+    std::vector<std::string> v{ "6", "7", "8" };
+
+    auto it = list.insert(list.begin() + 2, v);
+    if (list.size() != 8 || list.to_string() != "1;2;6;7;8;3;4;5") {
+      result = false;
+    }
+    if (*it != "6") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "1;2;3;4;5" };
+    std::vector<std::string> v{ "6;7", "8" };
+
+    auto it = list.insert(list.begin() + 2, v);
+    if (list.size() != 8 || list.to_string() != "1;2;6;7;8;3;4;5") {
+      result = false;
+    }
+    if (*it != "6") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "1;2;3;4;5" };
+    std::vector<std::string> v{ "6;7", "8" };
+
+    auto it = list.insert(list.begin() + 2, v, cmList::ExpandElements::No);
+    if (list.size() != 7 || list.to_string() != "1;2;6;7;8;3;4;5") {
+      result = false;
+    }
+    if (*it != "6;7") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "1;2;3;4;5" };
+    std::vector<std::string> v{ "6;;7", "8" };
+
+    auto it = list.insert(list.begin() + 2, v);
+    if (list.size() != 8 || list.to_string() != "1;2;6;7;8;3;4;5") {
+      result = false;
+    }
+    if (*it != "6") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "1;2;3;4;5" };
+    std::vector<std::string> v{ "6;;7", "8" };
+
+    auto it = list.insert(list.begin() + 2, v, cmList::EmptyElements::Yes);
+    if (list.size() != 9 || list.to_string() != "1;2;6;;7;8;3;4;5") {
+      result = false;
+    }
+    if (*it != "6") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "1;2;3;4;5" };
+    std::vector<std::string> v{ "6", "7", "8" };
+
+    auto it = list.insert(list.begin() + 2, std::move(v));
+    if (list.size() != 8 || list.to_string() != "1;2;6;7;8;3;4;5") {
+      result = false;
+    }
+    if (*it != "6") {
+      result = false;
+    }
+
+    if (!v.empty()) {
+      result = false;
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+
+bool testRemoveItems()
+{
+  std::cout << "testRemoveItems()";
+
+  bool result = true;
+
+  {
+    cmList list("a;b;c;d;e;f;g;h");
+
+    list.remove_items({ 1, 3, 5 });
+
+    if (list.size() != 5 || list.to_string() != "a;c;e;g;h") {
+      result = false;
+    }
+  }
+  {
+    cmList list("a;b;c;b;a;d;e;f");
+
+    list.remove_items({ "a", "b", "h" });
+
+    if (list.size() != 4 || list.to_string() != "c;d;e;f") {
+      result = false;
+    }
+  }
+  {
+    cmList list("a;b;c;d;e;f;g;h");
+    std::vector<cmList::index_type> remove{ 1, 3, 5 };
+
+    list.remove_items(remove.begin(), remove.end());
+
+    if (list.size() != 5 || list.to_string() != "a;c;e;g;h") {
+      result = false;
+    }
+  }
+  {
+    cmList list("a;b;c;b;a;d;e;f");
+    std::vector<std::string> remove{ "b", "a", "h" };
+
+    list.remove_items(remove.begin(), remove.end());
+
+    if (list.size() != 4 || list.to_string() != "c;d;e;f") {
+      result = false;
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+
+bool testRemoveDuplicates()
+{
+  std::cout << "testRemoveDuplicates()";
+
+  bool result = true;
+
+  {
+    cmList list("b;c;b;a;a;c;b;a;c;b");
+
+    list.remove_duplicates();
+
+    if (list.size() != 3 || list.to_string() != "b;c;a") {
+      result = false;
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+
+bool testFilter()
+{
+  std::cout << "testFilter()";
+
+  bool result = true;
+
+  {
+    cmList list{ "AA", "Aa", "aA" };
+
+    list.filter("^A", cmList::FilterMode::INCLUDE);
+    if (list.size() != 2 || list.to_string() != "AA;Aa") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "AA", "Aa", "aA" };
+
+    list.filter("^A", cmList::FilterMode::EXCLUDE);
+    if (list.size() != 1 || list.to_string() != "aA") {
+      result = false;
+    }
+  }
+  {
+    cmList list{ "AA", "Aa", "aA" };
+
+    try {
+      list.filter("^(A", cmList::FilterMode::EXCLUDE);
+      if (list.size() != 1) {
+        result = false;
+      }
+    } catch (const std::invalid_argument&) {
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+
+bool testReverse()
+{
+  std::cout << "testReverse()";
+
+  bool result = true;
+
+  {
+    cmList list{ "a", "b", "c" };
+    if (list.reverse().to_string() != "c;b;a") {
+      result = false;
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+
+bool testSort()
+{
+  std::cout << "testSort()";
+
+  bool result = true;
+
+  using SortConfiguration = cmList::SortConfiguration;
+
+  {
+    cmList list{ "A", "D", "C", "B", "A" };
+
+    list.sort();
+    if (list.to_string() != "A;A;B;C;D") {
+      result = false;
+    }
+
+    list.sort({ SortConfiguration::OrderMode::DESCENDING,
+                SortConfiguration::CompareMethod::DEFAULT,
+                SortConfiguration::CaseSensitivity::DEFAULT });
+    if (list.to_string() != "D;C;B;A;A") {
+      result = false;
+    }
+  }
+  {
+    SortConfiguration sortCfg;
+    cmList list{ "1.0", "1.1", "2.5", "10.2" };
+
+    list.sort(sortCfg);
+    if (list.to_string() != "1.0;1.1;10.2;2.5") {
+      result = false;
+    }
+
+    sortCfg.Compare = SortConfiguration::CompareMethod::NATURAL;
+    list.sort(sortCfg);
+    if (list.to_string() != "1.0;1.1;2.5;10.2") {
+      result = false;
+    }
+
+    sortCfg.Order = SortConfiguration::OrderMode::DESCENDING;
+    list.sort(sortCfg);
+    if (list.to_string() != "10.2;2.5;1.1;1.0") {
+      result = false;
+    }
+  }
+  {
+    SortConfiguration sortCfg;
+    cmList list{ "/zz/bb.cc", "/xx/yy/dd.cc", "/aa/cc.aa" };
+
+    list.sort(sortCfg);
+    if (list.to_string() != "/aa/cc.aa;/xx/yy/dd.cc;/zz/bb.cc") {
+      result = false;
+    }
+
+    sortCfg.Compare = SortConfiguration::CompareMethod::FILE_BASENAME;
+    if (list.sort(sortCfg).to_string() != "/zz/bb.cc;/aa/cc.aa;/xx/yy/dd.cc") {
+      result = false;
+    }
+  }
+  {
+    SortConfiguration sortCfg;
+    cmList list{ "c/B", "a/c", "B/a" };
+
+    if (list.sort().to_string() != "B/a;a/c;c/B") {
+      result = false;
+    }
+
+    sortCfg.Case = SortConfiguration::CaseSensitivity::INSENSITIVE;
+    if (list.sort(sortCfg).to_string() != "a/c;B/a;c/B") {
+      result = false;
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+
+bool testTransform()
+{
+  std::cout << "testTransform()";
+
+  bool result = true;
+
+  using AT = cmList::TransformSelector::AT;
+  using FOR = cmList::TransformSelector::FOR;
+  using REGEX = cmList::TransformSelector::REGEX;
+
+  {
+    cmList list({ "AA", "BB", "CC", "DD", "EE" });
+
+    list.transform(cmList::TransformAction::APPEND, "-X");
+    if (list.to_string() != "AA-X;BB-X;CC-X;DD-X;EE-X") {
+      result = false;
+    }
+  }
+  {
+    cmList list({ "AA", "BB", "CC", "DD", "EE" });
+
+    list.transform(cmList::TransformAction::PREPEND, "X-");
+    if (list.to_string() != "X-AA;X-BB;X-CC;X-DD;X-EE") {
+      result = false;
+    }
+  }
+  {
+    cmList list({ "AA", "BB", "CC", "DD", "EE" });
+
+    list.transform(cmList::TransformAction::TOLOWER);
+    if (list.to_string() != "aa;bb;cc;dd;ee") {
+      result = false;
+    }
+  }
+  {
+    cmList list({ "aa", "bb", "cc", "dd", "ee" });
+
+    list.transform(cmList::TransformAction::TOUPPER);
+    if (list.to_string() != "AA;BB;CC;DD;EE") {
+      result = false;
+    }
+  }
+  {
+    cmList list({ "  AA", "BB  ", "  CC  ", "DD", "EE" });
+
+    list.transform(cmList::TransformAction::STRIP);
+    if (list.to_string() != "AA;BB;CC;DD;EE") {
+      result = false;
+    }
+  }
+  {
+    cmList list({ "$<CONFIG>AA", "BB$<OR>", "C$<AND>C", "$<OR>DD$<AND>",
+                  "$<>E$<>E$<>" });
+
+    list.transform(cmList::TransformAction::GENEX_STRIP);
+    if (list.to_string() != "AA;BB;CC;DD;EE") {
+      result = false;
+    }
+  }
+  {
+    cmList list({ "ABC", "BBCB", "BCCCBC", "BCBCDD", "EBCBCEBC" });
+
+    list.transform(cmList::TransformAction::REPLACE, "^BC|BC$", "X");
+    if (list.to_string() != "AX;BBCB;XCCX;XXDD;EBCBCEX") {
+      result = false;
+    }
+  }
+  {
+    auto atSelector = cmList::TransformSelector::New<AT>({ 1, 2, 4 });
+    cmList list({ "AA", "BB", "CC", "DD", "EE" });
+
+    list.transform(cmList::TransformAction::TOLOWER, std::move(atSelector));
+    if (list.to_string() != "AA;bb;cc;DD;ee") {
+      result = false;
+    }
+  }
+  {
+    auto atSelector = cmList::TransformSelector::New<AT>({ 1, 2, -1 });
+    cmList list({ "AA", "BB", "CC", "DD", "EE" });
+
+    list.transform(cmList::TransformAction::TOLOWER, std::move(atSelector));
+    if (list.to_string() != "AA;bb;cc;DD;ee") {
+      result = false;
+    }
+  }
+  {
+    auto forSelector = cmList::TransformSelector::New<FOR>({ 1, 3 });
+    cmList list({ "AA", "BB", "CC", "DD", "EE" });
+
+    list.transform(cmList::TransformAction::TOLOWER, std::move(forSelector));
+    if (list.to_string() != "AA;bb;cc;dd;EE") {
+      result = false;
+    }
+  }
+  {
+    auto forSelector = cmList::TransformSelector::New<FOR>({ 0, 4, 2 });
+    cmList list({ "AA", "BB", "CC", "DD", "EE" });
+
+    list.transform(cmList::TransformAction::TOLOWER, std::move(forSelector));
+    if (list.to_string() != "aa;BB;cc;DD;ee") {
+      result = false;
+    }
+  }
+  {
+    auto regexSelector = cmList::TransformSelector::New<REGEX>("^(A|D|E)");
+    cmList list({ "AA", "BB", "CC", "DD", "EE" });
+
+    list.transform(cmList::TransformAction::TOLOWER, std::move(regexSelector));
+    if (list.to_string() != "aa;BB;CC;dd;ee") {
+      result = false;
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+
+bool testStaticModifiers()
+{
+  std::cout << "testStaticModifiers()";
+
+  bool result = true;
+
+  {
+    std::vector<std::string> v{ "a", "b", "c" };
+    cmList::assign("d;e", v);
+
+    if (v.size() != 2 || v[0] != "d" || v[1] != "e") {
+      result = false;
+    }
+  }
+  {
+    std::vector<std::string> v{ "a", "b", "c" };
+    cmList::append("d;;e", v);
+
+    if (v.size() != 5 || v[3] != "d" || v[4] != "e") {
+      result = false;
+    }
+  }
+  {
+    std::vector<std::string> v{ "a", "b", "c" };
+    cmList::append("d;;e", v, cmList::EmptyElements::Yes);
+
+    if (v.size() != 6 || v[3] != "d" || !v[4].empty() || v[5] != "e") {
+      result = false;
+    }
+  }
+  {
+    std::vector<std::string> v{ "a", "b", "c" };
+    cmList::prepend("d;e", v);
+
+    if (v.size() != 5 || v[0] != "d" || v[1] != "e") {
+      result = false;
+    }
+  }
+  {
+    std::vector<std::string> v{ "a", "b", "c" };
+    cmList::prepend("d;;e", v, cmList::EmptyElements::Yes);
+
+    if (v.size() != 6 || v[0] != "d" || !v[1].empty() || v[2] != "e") {
+      result = false;
+    }
+  }
+  {
+    std::string list{ "a;b;c" };
+    cmList::append("d;e", list);
+
+    if (list != "a;b;c;d;e") {
+      result = false;
+    }
+  }
+  {
+    std::string list;
+    cmList::append("d;e", list);
+
+    if (list != "d;e") {
+      result = false;
+    }
+  }
+  {
+    std::string list{ "a;b;c" };
+    cmList::append("", list);
+
+    if (list != "a;b;c;") {
+      result = false;
+    }
+  }
+  {
+    std::string list{ "a;b;c" };
+    std::vector<std::string> v{ "d", "e" };
+    cmList::append(v.begin(), v.end(), list);
+
+    if (list != "a;b;c;d;e") {
+      result = false;
+    }
+  }
+  {
+    std::string list{ "a;b;c" };
+    std::vector<std::string> v;
+    cmList::append(v.begin(), v.end(), list);
+
+    if (list != "a;b;c") {
+      result = false;
+    }
+  }
+  {
+    std::string list;
+    std::vector<std::string> v{ "d", "e" };
+    cmList::append(v.begin(), v.end(), list);
+
+    if (list != "d;e") {
+      result = false;
+    }
+  }
+  {
+    std::string list{ "a;b;c" };
+    cmList::prepend("d;e", list);
+
+    if (list != "d;e;a;b;c") {
+      result = false;
+    }
+  }
+  {
+    std::string list;
+    cmList::prepend("d;e", list);
+
+    if (list != "d;e") {
+      result = false;
+    }
+  }
+  {
+    std::string list{ "a;b;c" };
+    cmList::prepend("", list);
+
+    if (list != ";a;b;c") {
+      result = false;
+    }
+  }
+  {
+    std::string list{ "a;b;c" };
+    std::vector<std::string> v{ "d", "e" };
+    cmList::prepend(v.begin(), v.end(), list);
+
+    if (list != "d;e;a;b;c") {
+      result = false;
+    }
+  }
+  {
+    std::string list{ "a;b;c" };
+    std::vector<std::string> v;
+    cmList::prepend(v.begin(), v.end(), list);
+
+    if (list != "a;b;c") {
+      result = false;
+    }
+  }
+  {
+    std::string list;
+    std::vector<std::string> v{ "d", "e" };
+    cmList::prepend(v.begin(), v.end(), list);
+
+    if (list != "d;e") {
+      result = false;
+    }
+  }
+
+  checkResult(result);
+
+  return result;
+}
+}
+
+int testList(int /*unused*/, char* /*unused*/[])
+{
+  int result = 0;
+
+  if (!testConstructors()) {
+    result = 1;
+  }
+  if (!testAssign()) {
+    result = 1;
+  }
+  if (!testConversions()) {
+    result = 1;
+  }
+  if (!testAccess()) {
+    result = 1;
+  }
+  if (!testModifiers()) {
+    result = 1;
+  }
+  if (!testRemoveItems()) {
+    result = 1;
+  }
+  if (!testRemoveDuplicates()) {
+    result = 1;
+  }
+  if (!testFilter()) {
+    result = 1;
+  }
+  if (!testReverse()) {
+    result = 1;
+  }
+  if (!testSort()) {
+    result = 1;
+  }
+  if (!testTransform()) {
+    result = 1;
+  }
+  if (!testStaticModifiers()) {
+    result = 1;
+  }
+
+  return result;
+}

bootstrap

@@ -307,6 +307,7 @@ CMAKE_CXX_SOURCES="\
   cmBuildCommand \
   cmCMakeLanguageCommand \
   cmCMakeMinimumRequired \
+  cmList \
   cmCMakePath \
   cmCMakePathCommand \
   cmCMakePolicyCommand \