Source/cmCachePatternTable.cxx

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */

// Built-in cache variable documentation pattern table.
//
// This file is hand-maintained.  Each entry's Pattern is a literal template
// string containing one or more angle-bracketed placeholders (``<LANG>``,
// ``<CONFIG>``, ``<PackageName>``, ``<PROJECT-NAME>``, ``<an-attribute>``,
// ``<NNNN>``, ``<n>``).  The Summary is a one-line tooltip installed as
// the ``HELPSTRING`` of cache variables created via
// ``cmake -D <var>=<value>`` whose name matches the template under the
// lexical classes defined below and for which no exact-match entry exists
// in ``cmCacheDocumentationTable``.
//
// The pattern table is consulted only on the miss path of the exact-match
// ``cmCacheDocumentationTable::Get`` lookup; exact entries always win.
//
// Maintenance discipline:
//   * Adding a new pattern: hand-write one entry below in the canonical
//     ordering ``(numPlaceholders ASC, totalLiteralLen DESC, Pattern ASC)``
//     and make sure that, with ``<`` and ``>`` stripped, the pattern
//     names an existing ``Help/variable/<NAME>.rst`` file.  The
//     ``testPatternTableOrdered`` regression test in
//     ``Tests/CMakeLib`` verifies the canonical ordering; the
//     ``CacheVarHelpCoverage`` lint verifies the structural-parity
//     invariant.
//   * Per-language or per-configuration restrictions documented in the
//     corresponding ``.rst`` file must be reproduced in the Summary
//     prose (the matcher is intentionally permissive; restrictions live
//     in the tooltip).
//   * Summaries must be single-line printable ASCII, no embedded
//     double quotes, no embedded newlines, and ``<= 200`` characters
//     (so that ``cmake-gui`` / ``ccmake`` render them legibly).  The
//     ``testPatternTableFieldsValid`` regression test enforces all of
//     these.
//
// Matcher semantics: lazy + lookahead-anchored, single pass, no
// backtracking.  For each placeholder, the matcher consumes the minimum
// class-valid prefix of the input that lets the next literal anchor
// match at the cursor.  The fixed-length classes ``<NNNN>`` and
// ``<n>`` consume exactly four or one ASCII digits respectively.
// Full-input consumption is required at the end.  First fully-matching
// entry in ``kPatterns[]`` wins.

#include "cmCachePatternTable.h"

#include <cstddef>
#include <iterator>
#include <string>

#include <cm/string_view>
#include <cmext/string_view>

#include "cmCacheDocumentationTable.h"

namespace {

using cmCachePatternTable::Entry;

// The Entry layout below (two lines per row, ``{ "PATTERN",\n    "summary"
// },``) is intentional: it keeps the table easy to diff, review, and hand-edit
// against the corresponding Help/variable/*.rst manuals.  clang-format is
// suppressed across the array so contributors can update one Summary
// without the formatter reflowing every neighbor.
//
// Section headers ``// === N-placeholder, ... (K-literal-char bucket) ===``
// are organizational signposts that mirror the canonical ordering invariant
// enforced by ``testPatternTableOrdered``:
//
//     (numPlaceholders ASC, totalLiteralLen DESC, Pattern ASC)
//
// where ``totalLiteralLen`` is the byte count of the pattern after every
// ``<...>`` placeholder has been stripped.  Examples:
//
//   ``CMAKE_<LANG>_COMPILER_LAUNCHER``  -> ``CMAKE__COMPILER_LAUNCHER``  (24)
//   ``CMAKE_<LANG>_CLANG_TIDY``         -> ``CMAKE__CLANG_TIDY``         (17)
//   ``CMAKE_<LANG>_FLAGS``              -> ``CMAKE__FLAGS``              (12)
//
// Ordering literals DESC within a placeholder-count band is what makes
// ``Match()``'s first-match-wins linear scan correct: a more-anchored
// pattern (e.g. ``CMAKE_<LANG>_FLAGS_<CONFIG>_INIT``, literal=18) must
// shadow a less-anchored one (``CMAKE_<LANG>_FLAGS_<CONFIG>``, literal=13)
// so a lookup of ``CMAKE_CXX_FLAGS_DEBUG_INIT`` resolves to the former
// rather than lazily binding ``CONFIG`` to ``DEBUG_INIT`` against the
// latter.  Contributors adding a new entry: place it in the bucket whose
// literal-count matches yours, and update or add a new ``=== ... ===``
// header if your literal-count is novel.  The unit test catches mistakes.
/* clang-format off */
Entry const kPatterns[] = {

  // === 1-placeholder, (37-literal-char bucket) ===
  { "CMAKE_FRAMEWORK_MULTI_CONFIG_POSTFIX_<CONFIG>"_s,
    "Default framework filename postfix under configuration <CONFIG>."_s },

  // === 1-placeholder, (35-literal-char bucket) ===
  { "CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY_<CONFIG>"_s,
    "Initializes COMPILE_PDB_OUTPUT_DIRECTORY_<CONFIG> target property."_s },
  { "CMAKE_INTERPROCEDURAL_OPTIMIZATION_<CONFIG>"_s,
    "Initializes INTERPROCEDURAL_OPTIMIZATION_<CONFIG> target property."_s },
  { "CMAKE_LINK_LIBRARY_USING_<FEATURE>_SUPPORTED"_s,
    "Set to TRUE if <FEATURE> is supported regardless of linker language."_s },

  // === 1-placeholder, (34-literal-char bucket) ===
  { "CMAKE_<LANG>_CLANG_TIDY_EXPORT_FIXES_DIR"_s,
    "Default value for the <LANG>_CLANG_TIDY_EXPORT_FIXES_DIR target property; directory where clang-tidy writes suggested fix .yaml files. Applies only when <LANG> is C, CXX, OBJC, or OBJCXX."_s },

  // === 1-placeholder, (33-literal-char bucket) ===
  { "CMAKE_LINK_GROUP_USING_<FEATURE>_SUPPORTED"_s,
    "Specifies if <FEATURE> is supported regardless of link language."_s },

  // === 1-placeholder, (31-literal-char bucket) ===
  { "CMAKE_ARCHIVE_OUTPUT_DIRECTORY_<CONFIG>"_s,
    "Initializes ARCHIVE_OUTPUT_DIRECTORY_<CONFIG> target property."_s },
  { "CMAKE_LIBRARY_OUTPUT_DIRECTORY_<CONFIG>"_s,
    "Initializes LIBRARY_OUTPUT_DIRECTORY_<CONFIG> target property."_s },
  { "CMAKE_RUNTIME_OUTPUT_DIRECTORY_<CONFIG>"_s,
    "Initializes RUNTIME_OUTPUT_DIRECTORY_<CONFIG> target property."_s },
  { "CMAKE_USER_MAKE_RULES_OVERRIDE_<LANG>"_s,
    "Specify a CMake file that overrides platform information for <LANG>"_s },

  // === 1-placeholder, (30-literal-char bucket) ===
  { "CMAKE_LINK_LIBRARY_<FEATURE>_ATTRIBUTES"_s,
    "Defines behavior and attributes of the specified link library <FEATURE>."_s },

  // === 1-placeholder, (29-literal-char bucket) ===
  { "CMAKE_PROJECT_<PROJECT-NAME>_INCLUDE_BEFORE"_s,
    "Path to a CMake language file included as the first step of any project() command call matching <PROJECT-NAME>. Intended for injecting custom code into project builds without modifying the source."_s },

  // === 1-placeholder, (27-literal-char bucket) ===
  { "CMAKE_<LANG>_INCLUDE_WHAT_YOU_USE"_s,
    "Default value for the <LANG>_INCLUDE_WHAT_YOU_USE target property; names an include-what-you-use command (and arguments) run alongside compilation. Applies only when <LANG> is C or CXX."_s },
  { "CMAKE_DISABLE_FIND_PACKAGE_<PackageName>"_s,
    "Set to TRUE to disable calls to find_package(<PackageName>); the call returns as if the package were not found, even when REQUIRED was specified."_s },
  { "CMAKE_PDB_OUTPUT_DIRECTORY_<CONFIG>"_s,
    "Initializes PDB_OUTPUT_DIRECTORY_<CONFIG> target property."_s },
  { "CMAKE_REQUIRE_FIND_PACKAGE_<PackageName>"_s,
    "Set to TRUE to make every call to find_package(<PackageName>) behave as if REQUIRED were specified, causing CMake to fail when the package is not found."_s },

  // === 1-placeholder, (26-literal-char bucket) ===
  { "CMAKE_MAP_IMPORTED_CONFIG_<CONFIG>"_s,
    "Initializes MAP_IMPORTED_CONFIG_<CONFIG> target property."_s },
  { "CMAKE_MODULE_LINKER_FLAGS_<CONFIG>"_s,
    "Flags used by the linker when creating a module library for the <CONFIG> configuration. Appended after the configuration-independent CMAKE_MODULE_LINKER_FLAGS."_s },
  { "CMAKE_SHARED_LINKER_FLAGS_<CONFIG>"_s,
    "Flags used by the linker when creating a shared library for the <CONFIG> configuration. Appended after the configuration-independent CMAKE_SHARED_LINKER_FLAGS."_s },
  { "CMAKE_STATIC_LINKER_FLAGS_<CONFIG>"_s,
    "Flags used by the static-library archiver when creating a static library for the <CONFIG> configuration. Appended after the configuration-independent CMAKE_STATIC_LINKER_FLAGS."_s },

  // === 1-placeholder, (25-literal-char bucket) ===
  { "CMAKE_LINK_LIBRARY_USING_<FEATURE>"_s,
    "Defines how to link a library for <FEATURE>."_s },

  // === 1-placeholder, (24-literal-char bucket) ===
  { "CMAKE_<LANG>_COMPILER_LAUNCHER"_s,
    "Default value for the <LANG>_COMPILER_LAUNCHER target property; launcher tool prepended to every <LANG> compile command. Applies only when <LANG> is C, CXX, Fortran, HIP, ISPC, OBJC, OBJCXX, or CUDA."_s },
  { "CMAKE_<LANG>_STANDARD_REQUIRED"_s,
    "Default value for the <LANG>_STANDARD_REQUIRED target property when a target is created. If TRUE, the requested language standard must be supported by the compiler."_s },
  { "CMAKE_<LANG>_VISIBILITY_PRESET"_s,
    "Default value for the <LANG>_VISIBILITY_PRESET target property when a target is created. Controls the default symbol visibility (default, hidden, protected, internal) for <LANG> code."_s },
  { "CMAKE_POLICY_DEFAULT_CMP<NNNN>"_s,
    "Default for CMake Policy CMP<NNNN> when otherwise left unset. Set to OLD or NEW to externally control the policy for projects that have not set it via cmake_minimum_required or cmake_policy."_s },
  { "CMAKE_POLICY_WARNING_CMP<NNNN>"_s,
    "Explicitly enable or disable the warning when CMake Policy CMP<NNNN> has not been set explicitly. Meaningful only for the policies that do not warn by default."_s },

  // === 1-placeholder, (23-literal-char bucket) ===
  { "CMAKE_EXE_LINKER_FLAGS_<CONFIG>"_s,
    "Flags used by the linker when creating an executable for the <CONFIG> configuration. Appended after the configuration-independent CMAKE_EXE_LINKER_FLAGS."_s },
  { "CMAKE_LINK_GROUP_USING_<FEATURE>"_s,
    "Defines how to link a group of libraries for <FEATURE>."_s },

  // === 1-placeholder, (22-literal-char bucket) ===
  { "CMAKE_<LANG>_LINKER_LAUNCHER"_s,
    "Default value for the <LANG>_LINKER_LAUNCHER target property; names a launcher tool prepended to every <LANG> link command. Applies only when <LANG> is C, CXX, OBJC, OBJCXX, or CUDA."_s },
  { "CMAKE_PROJECT_<PROJECT-NAME>_INCLUDE"_s,
    "Path to a CMake language file included as the last step of any project() command call matching <PROJECT-NAME>. Intended for injecting custom code without modifying the project source."_s },
  { "CMAKE_XCODE_ATTRIBUTE_<an-attribute>"_s,
    "Tells the Xcode generator to set <an-attribute> to the given value in the generated Xcode project. Ignored on other generators. Low-level escape hatch for Xcode-specific settings."_s },

  // === 1-placeholder, (20-literal-char bucket) ===
  { "CMAKE_<LANG>_HOST_COMPILER"_s,
    "Host compiler executable for CUDA or HIP code compilation"_s },

  // === 1-placeholder, (17-literal-char bucket) ===
  { "CMAKE_<LANG>_CLANG_TIDY"_s,
    "Default value for the <LANG>_CLANG_TIDY target property; names a clang-tidy command (with arguments) run alongside compilation. Applies only when <LANG> is C, CXX, OBJC, or OBJCXX."_s },
  { "CMAKE_<LANG>_EXTENSIONS"_s,
    "Default value for the <LANG>_EXTENSIONS target property when a target is created. Controls whether compiler-specific extensions to the language standard are enabled."_s },
  { "CMAKE_<LANG>_FLAGS_INIT"_s,
    "Toolchain-file hook initializing CMAKE_<LANG>_FLAGS the first time the build tree is configured for <LANG>. Set in toolchain or platform files; user projects should set CMAKE_<LANG>_FLAGS instead."_s },
  { "CMAKE_<LANG>_LINK_FLAGS"_s,
    "Language-wide flags for <LANG> used when linking for all configurations. Passed to every compiler invocation that drives linking. Per-config CMAKE_<LANG>_LINK_FLAGS_<CONFIG> are appended on top."_s },
  { "CMAKE_<LANG>_PVS_STUDIO"_s,
    "Default value for the <LANG>_PVS_STUDIO target property; names a pvs-studio-analyzer command (with arguments) run alongside compilation. Applies only when <LANG> is C or CXX."_s },

  // === 1-placeholder, (15-literal-char bucket) ===
  { "CMAKE_<LANG>_COMPILER"_s,
    "Full path to the compiler used for language <LANG>. Set by CMake during compiler detection on the first configure; users may override on the command line to select a specific toolchain."_s },
  { "CMAKE_<LANG>_CPPCHECK"_s,
    "Default value for the <LANG>_CPPCHECK target property; names a cppcheck command (with arguments) run alongside compilation. Applies only when <LANG> is C or CXX."_s },
  { "CMAKE_<LANG>_STANDARD"_s,
    "Default value for the <LANG>_STANDARD target property when a target is created. Applies to <LANG> = C, CXX, CUDA, HIP, OBJC, OBJCXX. See cmake-compile-features(7)."_s },

  // === 1-placeholder, (14-literal-char bucket) ===
  { "CMAKE_<CONFIG>_POSTFIX"_s,
    "Default filename postfix for libraries under configuration <CONFIG>."_s },
  { "CMAKE_<LANG>_CPPLINT"_s,
    "Default value for the <LANG>_CPPLINT target property; names a cpplint command (with arguments) run alongside compilation. Applies only when <LANG> is C or CXX."_s },

  // === 1-placeholder, (13-literal-char bucket) ===
  { "CMAKE_<LANG>_ICSTAT"_s,
    "Default value for the <LANG>_ICSTAT target property; names an icstat static-analysis command (with arguments) run alongside compilation. Applies only when <LANG> is C or CXX."_s },

  // === 1-placeholder, (12-literal-char bucket) ===
  { "CMAKE_<LANG>_FLAGS"_s,
    "Language-wide compiler flags for <LANG>. Initialized from the language-specific environment variable (CFLAGS, CXXFLAGS, FFLAGS, etc.) the first time the language is enabled."_s },
  { "CMAKE_MATCH_<n>"_s,
    "Capture group <n> matched by the most recent regular expression (groups 0 through 9). Group 0 is the entire match; groups 1 through 9 are the parenthesized subexpressions."_s },

  // === 1-placeholder, (11-literal-char bucket) ===
  { "<PROJECT-NAME>_BINARY_DIR"_s,
    "Top-level binary directory for the named project. Created by the project() command with the given <PROJECT-NAME>; useful when add_subdirectory is used to connect several projects."_s },
  { "<PROJECT-NAME>_SOURCE_DIR"_s,
    "Top-level source directory for the named project. Created by the project() command with the given <PROJECT-NAME>; useful when add_subdirectory is used to connect several projects."_s },

  // === 1-placeholder, (8-literal-char bucket) ===
  { "<PROJECT-NAME>_VERSION"_s,
    "Value given to the VERSION option of the most recent project() command with project name <PROJECT-NAME>, if any. Component values live in <PROJECT-NAME>_VERSION_{MAJOR,MINOR,PATCH,TWEAK}."_s },

  // === 1-placeholder, (5-literal-char bucket) ===
  { "<PackageName>_ROOT"_s,
    "Initial search prefix(es) for find_package(<PackageName>); covers both the mixed-case form (CMP0074, e.g. Foo_ROOT) and the upper-case form (CMP0144, e.g. FOO_ROOT)."_s },

  // === 2-placeholder, (36-literal-char bucket) ===
  { "CMAKE_<LANG>_LINK_LIBRARY_USING_<FEATURE>_SUPPORTED"_s,
    "Set to TRUE if <FEATURE> is supported for linker language <LANG>."_s },

  // === 2-placeholder, (34-literal-char bucket) ===
  { "CMAKE_<LANG>_LINK_GROUP_USING_<FEATURE>_SUPPORTED"_s,
    "Specifies if <FEATURE> is supported for link language <LANG>."_s },

  // === 2-placeholder, (31-literal-char bucket) ===
  { "CMAKE_<LANG>_LINK_LIBRARY_<FEATURE>_ATTRIBUTES"_s,
    "Defines semantics of link library <FEATURE> for language <LANG>."_s },

  // === 2-placeholder, (26-literal-char bucket) ===
  { "CMAKE_<LANG>_LINK_LIBRARY_USING_<FEATURE>"_s,
    "Defines how to link a library for <FEATURE>."_s },

  // === 2-placeholder, (24-literal-char bucket) ===
  { "CMAKE_<LANG>_LINK_GROUP_USING_<FEATURE>"_s,
    "Defines how to link a group of libraries for <FEATURE>."_s },

  // === 2-placeholder, (20-literal-char bucket) ===
  { "CMAKE_<LANG>_USING_LINKER_<TYPE>"_s,
    "Defines how to specify the <TYPE> linker for the link step."_s },

  // === 2-placeholder, (18-literal-char bucket) ===
  { "CMAKE_<LANG>_FLAGS_<CONFIG>_INIT"_s,
    "Toolchain-file hook initializing CMAKE_<LANG>_FLAGS_<CONFIG> the first time the build tree is configured for language <LANG>. Intended for toolchain or platform files."_s },
  { "CMAKE_<LANG>_LINK_FLAGS_<CONFIG>"_s,
    "Language-wide flags for <LANG> used when linking for the <CONFIG> configuration. Passed to every compiler invocation that drives linking. Appended after CMAKE_<LANG>_LINK_FLAGS."_s },

  // === 2-placeholder, (13-literal-char bucket) ===
  { "CMAKE_<LANG>_FLAGS_<CONFIG>"_s,
    "Language-wide flags for <LANG> used when building for the <CONFIG> configuration. Appended after CMAKE_<LANG>_FLAGS on both compile and link invocations."_s },
};
/* clang-format on */

// ---------------------------------------------------------------------------
// Character classes used by the matcher.
// ---------------------------------------------------------------------------

constexpr bool IsAsciiAlpha(char c)
{
  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
}

constexpr bool IsAsciiDigit(char c)
{
  return c >= '0' && c <= '9';
}

// Identifier: ``[A-Za-z][A-Za-z0-9_]*`` -- start vs. continuation.
constexpr bool IsIdentStart(char c)
{
  return IsAsciiAlpha(c);
}
constexpr bool IsIdentCont(char c)
{
  return IsAsciiAlpha(c) || IsAsciiDigit(c) || c == '_';
}

// Identifier-with-hyphen: ``[A-Za-z][A-Za-z0-9_-]*`` -- start vs.
// continuation.
constexpr bool IsIdentHyphenStart(char c)
{
  return IsAsciiAlpha(c);
}
constexpr bool IsIdentHyphenCont(char c)
{
  return IsAsciiAlpha(c) || IsAsciiDigit(c) || c == '_' || c == '-';
}

// ---------------------------------------------------------------------------
// Placeholder dispatch.
// ---------------------------------------------------------------------------

enum class PlaceholderClass
{
  Ident,       // <LANG>, <CONFIG>, <PackageName>
  IdentHyphen, // <PROJECT-NAME>, <an-attribute>
  FourDigit,   // <NNNN>
  OneDigit,    // <n>
  Unknown,     // malformed pattern entry
};

PlaceholderClass ClassOf(cm::string_view placeholder)
{
  // ``placeholder`` includes the surrounding angle brackets, e.g. "<LANG>".
  // ``<FEATURE>`` and ``<TYPE>`` are documented as identifiers by their
  // RSTs (e.g. WEAK / WHOLE_ARCHIVE for FEATURE in
  // Help/variable/CMAKE_LINK_LIBRARY_USING_FEATURE.rst and LLD / MOLD
  // for TYPE in Help/variable/CMAKE_LANG_USING_LINKER_TYPE.rst), so they
  // share the ``Ident`` lexical class with <LANG>/<CONFIG>/<PackageName>.
  // Without this clause the eleven pattern entries that use these two
  // placeholders would never match any input (regression guarded by
  // testEveryPatternReachable in Tests/CMakeLib).
  if (placeholder == "<LANG>" || placeholder == "<CONFIG>" ||
      placeholder == "<PackageName>" || placeholder == "<FEATURE>" ||
      placeholder == "<TYPE>") {
    return PlaceholderClass::Ident;
  }
  if (placeholder == "<PROJECT-NAME>" || placeholder == "<an-attribute>") {
    return PlaceholderClass::IdentHyphen;
  }
  if (placeholder == "<NNNN>") {
    return PlaceholderClass::FourDigit;
  }
  if (placeholder == "<n>") {
    return PlaceholderClass::OneDigit;
  }
  return PlaceholderClass::Unknown;
}

bool ClassAllowsStart(PlaceholderClass cls, char c)
{
  switch (cls) {
    case PlaceholderClass::Ident:
      return IsIdentStart(c);
    case PlaceholderClass::IdentHyphen:
      return IsIdentHyphenStart(c);
    case PlaceholderClass::FourDigit:
    case PlaceholderClass::OneDigit:
      return IsAsciiDigit(c);
    case PlaceholderClass::Unknown:
      break;
  }
  return false;
}

bool ClassAllowsCont(PlaceholderClass cls, char c)
{
  switch (cls) {
    case PlaceholderClass::Ident:
      return IsIdentCont(c);
    case PlaceholderClass::IdentHyphen:
      return IsIdentHyphenCont(c);
    case PlaceholderClass::FourDigit:
    case PlaceholderClass::OneDigit:
      return IsAsciiDigit(c);
    case PlaceholderClass::Unknown:
      break;
  }
  return false;
}

// ---------------------------------------------------------------------------
// Helpers.
// ---------------------------------------------------------------------------

bool LiteralMatches(cm::string_view input, std::size_t pos,
                    cm::string_view literal)
{
  return input.size() - pos >= literal.size() &&
    input.compare(pos, literal.size(), literal) == 0;
}

// Try to match ``pattern`` against ``input`` end-to-end under the
// lazy + lookahead-anchored semantics documented at the top of this file.
// Returns true on full-consumption match; false otherwise.
bool TryMatch(cm::string_view pattern, cm::string_view input)
{
  std::size_t pi = 0;
  std::size_t ii = 0;

  while (pi < pattern.size()) {
    if (pattern[pi] != '<') {
      // Literal segment: walk until next '<' or end of pattern.
      std::size_t literal_end = pi;
      while (literal_end < pattern.size() && pattern[literal_end] != '<') {
        ++literal_end;
      }
      cm::string_view const lit = pattern.substr(pi, literal_end - pi);
      if (!LiteralMatches(input, ii, lit)) {
        return false;
      }
      pi = literal_end;
      ii += lit.size();
      continue;
    }

    // Placeholder segment: find the closing '>'.
    std::size_t const close = pattern.find('>', pi);
    if (close == cm::string_view::npos) {
      return false; // malformed pattern; matched by no input
    }
    cm::string_view const ph = pattern.substr(pi, close - pi + 1);
    PlaceholderClass const cls = ClassOf(ph);
    if (cls == PlaceholderClass::Unknown) {
      return false; // unknown placeholder class; rejected by unit test too
    }

    // Locate the next anchor literal that follows this placeholder.  An
    // empty anchor means the placeholder is the last segment in the
    // pattern (must consume to end-of-input) or that it is followed
    // immediately by another placeholder (adjacent placeholders are
    // forbidden -- testPatternTableFieldsValid rejects them at table
    // build time, so we treat the case defensively here).
    std::size_t const after_ph = close + 1;
    std::size_t anchor_end = after_ph;
    while (anchor_end < pattern.size() && pattern[anchor_end] != '<') {
      ++anchor_end;
    }
    cm::string_view const anchor =
      pattern.substr(after_ph, anchor_end - after_ph);
    bool const consume_to_eoi =
      anchor.empty() && (anchor_end == pattern.size());
    if (anchor.empty() && !consume_to_eoi) {
      return false; // adjacent placeholders are not supported
    }

    // Fixed-length classes consume exactly that many digits, then anchor.
    if (cls == PlaceholderClass::FourDigit ||
        cls == PlaceholderClass::OneDigit) {
      std::size_t const fixed_len =
        (cls == PlaceholderClass::FourDigit) ? 4u : 1u;
      if (input.size() - ii < fixed_len) {
        return false;
      }
      for (std::size_t k = 0; k < fixed_len; ++k) {
        if (!IsAsciiDigit(input[ii + k])) {
          return false;
        }
      }
      std::size_t const cur = ii + fixed_len;
      if (consume_to_eoi) {
        if (cur != input.size()) {
          return false;
        }
        ii = cur;
      } else {
        if (!LiteralMatches(input, cur, anchor)) {
          return false;
        }
        ii = cur + anchor.size();
      }
      pi = anchor_end;
      continue;
    }

    // Variable-length classes: placeholder is non-empty; consume lazily,
    // stopping at the first cursor position where the anchor matches (or
    // at end-of-input when there is no trailing literal anchor).
    if (ii >= input.size()) {
      return false;
    }
    if (!ClassAllowsStart(cls, input[ii])) {
      return false;
    }
    std::size_t cur = ii + 1; // consumed first char
    if (consume_to_eoi) {
      while (cur < input.size()) {
        if (!ClassAllowsCont(cls, input[cur])) {
          return false;
        }
        ++cur;
      }
      ii = cur;
    } else {
      while (true) {
        if (LiteralMatches(input, cur, anchor)) {
          break;
        }
        if (cur >= input.size()) {
          return false;
        }
        if (!ClassAllowsCont(cls, input[cur])) {
          return false;
        }
        ++cur;
      }
      ii = cur + anchor.size();
    }
    pi = anchor_end;
  }

  return ii == input.size();
}

} // namespace

cmCacheDocumentationTable::LookupResult cmCachePatternTable::Match(
  cm::string_view varName)
{
  for (auto const& entry : kPatterns) {
    if (TryMatch(entry.Pattern, varName)) {
      return { entry.Summary };
    }
  }
  return {};
}

cmCachePatternTable::Entry const* cmCachePatternTable::EntriesBegin()
{
  return std::begin(kPatterns);
}

cmCachePatternTable::Entry const* cmCachePatternTable::EntriesEnd()
{
  return std::end(kPatterns);
}

std::size_t cmCachePatternTable::EntriesSize()
{
  return static_cast<std::size_t>(std::end(kPatterns) - std::begin(kPatterns));
}