regex_match.hpp

Go to the documentation of this file.

 
#ifndef REAL_STD_REGEX_MATCH_HPP
#define REAL_STD_REGEX_MATCH_HPP
 
// Internal — do not include directly.
// Users: #include <real/real.hpp> (or the documented opt-ins <real/dfa.hpp>, <real/std/regex.hpp>).
 
#include "regex_core.hpp"
 
#include <algorithm>
#include <iterator>
 
namespace real::compat {
  template <typename BidirIt>
  class sub_match
  {
    static_assert(std::contiguous_iterator<BidirIt>,
                  "real::compat::sub_match requires a contiguous iterator");
 
  public:
 
    using iterator        = BidirIt;                                                 
    using value_type      = typename std::iterator_traits<BidirIt>::value_type;      
    using difference_type = typename std::iterator_traits<BidirIt>::difference_type; 
    using string_type     = std::basic_string<value_type>;                           
 
    BidirIt first   {};                                                              
    BidirIt second  {};                                                              
    bool    matched {false};                                                         
 
    [[nodiscard]] difference_type length() const
    {
      return matched ? std::distance(first, second) : difference_type {0};
    }
 
    [[nodiscard]] string_type str() const
    {
      return matched ? string_type(first, second) : string_type {};
    }
 
    operator string_type() const // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
    {
      return str();
    }
 
    [[nodiscard]] std::basic_string_view<value_type> view() const
    {
      return matched ? std::basic_string_view<value_type>(std::to_address(first),
                                                          static_cast<std::size_t>(length()))
                     : std::basic_string_view<value_type> {};
    }
 
    [[nodiscard]] int compare(const string_type& other) const
    {
      return str().compare(other);
    }
 
    [[nodiscard]] int compare(const sub_match& other) const
    {
      return str().compare(other.str());
    }
  };
 
  template <typename BidirIt>
  bool operator==(const sub_match<BidirIt>&                       lhs,
                  const typename sub_match<BidirIt>::string_type& rhs)
  {
    return lhs.str() == rhs;
  }
 
  template <typename BidirIt>
  bool operator==(const typename sub_match<BidirIt>::string_type& lhs,
                  const sub_match<BidirIt>&                       rhs)
  {
    return lhs == rhs.str();
  }
 
  template <typename BidirIt>
  bool operator==(const sub_match<BidirIt>& lhs,
                  const sub_match<BidirIt>& rhs)
  {
    return lhs.str() == rhs.str();
  }
 
  template <typename BidirIt, typename Alloc = std::allocator<sub_match<BidirIt>>>
  class match_results
  {
  public:
 
    using value_type      = sub_match<BidirIt>;                                      
    using const_reference = const value_type&;                                       
    using reference       = value_type&;                                             
    using const_iterator  = typename std::vector<value_type, Alloc>::const_iterator; 
    using iterator        = const_iterator;                                          
    using difference_type = typename std::iterator_traits<BidirIt>::difference_type; 
    using size_type       = std::size_t;                                             
    using char_type       = typename std::iterator_traits<BidirIt>::value_type;      
    using string_type     = std::basic_string<char_type>;                            
 
    [[nodiscard]] bool ready() const noexcept
    {
      return ready_;
    }
 
    [[nodiscard]] size_type size() const noexcept
    {
      return groups_.size();
    }
 
    [[nodiscard]] bool      empty() const noexcept
    {
      return groups_.empty();
    }
 
    const_reference operator[](size_type n) const
    {
      return n < groups_.size() ? groups_[n] : unmatched_;
    }
 
    [[nodiscard]] difference_type position(size_type n = 0) const
    {
      return n < groups_.size() ? std::distance(first_, groups_[n].first)
                                : std::distance(first_, last_);
    }
 
    [[nodiscard]] difference_type length(size_type n = 0) const
    {
      return n < groups_.size() ? groups_[n].length() : difference_type {0};
    }
 
    [[nodiscard]] string_type str(size_type n = 0) const
    {
      return (*this)[n].str();
    }
 
    [[nodiscard]] const value_type& prefix() const
    {
      return prefix_;
    }
 
    [[nodiscard]] const value_type& suffix() const
    {
      return suffix_;
    }
 
    [[nodiscard]] const_iterator begin() const
    {
      return groups_.begin();
    }
 
    [[nodiscard]] const_iterator end() const
    {
      return groups_.end();
    }
 
    [[nodiscard]] const_iterator cbegin() const
    {
      return groups_.begin();
    }
 
    [[nodiscard]] const_iterator cend() const
    {
      return groups_.end();
    }
 
    // --- engine-facing fill helpers (used by the free functions) ---------------------------
 
    void reset(BidirIt first,
               BidirIt last)
    {
      first_     = first;
      last_      = last;
      groups_.clear();
      prefix_           = suffix_ = value_type {.first = last, .second = last, .matched = false};
      unmatched_        = value_type {.first = last, .second = last, .matched = false};
      ready_            = false;
    }
 
    void set_ready_no_match()
    {
      groups_.clear();
      ready_ = true;
    }
 
    void rebase_prefix(BidirIt first)
    {
      prefix_.first   = first;
      prefix_.matched = first != prefix_.second;
    }
 
    template <typename RealMatch>
    void fill_from_real(const RealMatch& match)
    {
      groups_.clear();
      const std::size_t count {match.size()};
      groups_.reserve(count);
      for (std::size_t g = 0; g < count; ++g) {
        const std::size_t start {match.start(g)};
        const std::size_t fin   {match.end(g)};
        if (start == real::npos || fin == real::npos) {
          groups_.push_back(value_type {.first = last_, .second = last_, .matched = false});
        }
        else {
          groups_.push_back(value_type {.first   = first_ + static_cast<difference_type>(start),
                                        .second  = first_ + static_cast<difference_type>(fin),
                                        .matched = true});
        }
      }
      const std::size_t whole_start {match.start(0)};
      const std::size_t whole_end   {match.end(0)};
      prefix_ = value_type {.first   = first_,
                            .second  = first_ + static_cast<difference_type>(whole_start),
                            .matched = whole_start > 0};
      suffix_ = value_type {.first   = first_ + static_cast<difference_type>(whole_end),
                            .second  = last_,
                            .matched = (first_ + static_cast<difference_type>(whole_end)) != last_};
      ready_ = true;
    }
 
    template <typename StdMatch>
    void fill_from_std(const StdMatch& match)
    {
      groups_.clear();
      groups_.reserve(match.size());
      for (const auto& sub : match) {
        groups_.push_back(value_type {.first = sub.first, .second = sub.second, .matched = sub.matched});
      }
      const auto& pre {match.prefix()};
      const auto& suf {match.suffix()};
      prefix_ = value_type {.first = pre.first, .second = pre.second, .matched = pre.matched};
      suffix_ = value_type {.first = suf.first, .second = suf.second, .matched = suf.matched};
      ready_  = true;
    }
 
  private:
 
    BidirIt                            first_     {};      
    BidirIt                            last_      {};      
    std::vector<value_type, Alloc>     groups_;            
    value_type                         prefix_    {};      
    value_type                         suffix_    {};      
    value_type                         unmatched_ {};      
    bool                               ready_     {false}; 
  };
 
  using ssub_match  = sub_match<std::string::const_iterator>;  
  using csub_match  = sub_match<const char*>;                  
  using wssub_match = sub_match<std::wstring::const_iterator>; 
  using wcsub_match = sub_match<const wchar_t*>;               
 
  using smatch  = match_results<std::string::const_iterator>;  
  using cmatch  = match_results<const char*>;                  
  using wsmatch = match_results<std::wstring::const_iterator>; 
  using wcmatch = match_results<const wchar_t*>;               
 
  // --- free functions ----------------------------------------------------------------------
 
  namespace detail {
 
    [[nodiscard]] inline bool real_honors(regex_constants::match_flag_type mf) noexcept
    {
      constexpr unsigned non_constraining {static_cast<unsigned>(regex_constants::match_default)
                                           | static_cast<unsigned>(regex_constants::match_any)};
      return (static_cast<unsigned>(mf) & ~non_constraining) == 0U;
    }
 
    [[nodiscard]] inline bool replace_stays_real(regex_constants::match_flag_type f) noexcept
    {
      using namespace regex_constants;
      constexpr unsigned honored {static_cast<unsigned>(match_default) | static_cast<unsigned>(match_any)
                                  | static_cast<unsigned>(format_first_only)
                                  | static_cast<unsigned>(format_no_copy)};
      return (static_cast<unsigned>(f) & ~honored) == 0U;
    }
 
    [[nodiscard]] inline std::regex_constants::match_flag_type
    to_std_match(regex_constants::match_flag_type f) noexcept
    {
      namespace sc = std::regex_constants;
      using namespace regex_constants;
      auto s {sc::match_default};
      if ((f & match_not_bol) != 0U) { s |= sc::match_not_bol; }
      if ((f & match_not_eol) != 0U) { s |= sc::match_not_eol; }
      if ((f & match_not_bow) != 0U) { s |= sc::match_not_bow; }
      if ((f & match_not_eow) != 0U) { s |= sc::match_not_eow; }
      if ((f & match_any) != 0U) { s |= sc::match_any; }
      if ((f & match_not_null) != 0U) { s |= sc::match_not_null; }
      if ((f & match_continuous) != 0U) { s |= sc::match_continuous; }
      if ((f & match_prev_avail) != 0U) { s |= sc::match_prev_avail; }
      if ((f & format_sed) != 0U) { s |= sc::format_sed; }
      if ((f & format_no_copy) != 0U) { s |= sc::format_no_copy; }
      if ((f & format_first_only) != 0U) { s |= sc::format_first_only; }
      return s;
    }
 
    template <typename BidirIt, typename CharT, typename Traits>
    bool run(BidirIt                           first,
             BidirIt                           last,
             match_results<BidirIt>&           m,
             const basic_regex<CharT, Traits>& re,
             bool                              anchored,
             regex_constants::match_flag_type  mf)
    {
      m.reset(first, last);
      if constexpr (real_eligible<CharT, Traits>) {
        if (re.uses_real() && real_honors(mf)) {
          const std::string_view sv     {std::to_address(first),
                                         static_cast<std::size_t>(std::distance(first, last))};
          const real::regex&     engine {std::get<real::regex>(re.engine())};
          // POSIX ERE routes an unanchored search to leftmost-LONGEST bounds (re.posix_longest()); a whole-
          // sequence match (fullmatch) has one candidate, so longest == first there.
          const auto             result {anchored ? engine.fullmatch(sv)
                                         : (re.posix_longest() ? engine.search_longest(sv) : engine.search(sv))};
          if (!result.matched()) {
            m.set_ready_no_match(); // std leaves ready()==true, size()==0 on a failed match
            return false;
          }
          m.fill_from_real(result);
          return true;
        }
      }
      const std::basic_regex<CharT, Traits>& std_engine {re.std_engine()}; // lazy-built if real-backed
      std::match_results<BidirIt>            std_m;
      const auto                             sf         {to_std_match(mf)};
      const bool                             ok         {anchored ? std::regex_match(first, last, std_m, std_engine, sf)
                              : std::regex_search(first, last, std_m, std_engine, sf)};
      if (!ok) {
        m.set_ready_no_match();
        return false;
      }
      m.fill_from_std(std_m);
      return true;
    }
 
    template <typename BidirIt, typename CharT, typename Traits>
    bool run_nocapture(BidirIt                           first,
                       BidirIt                           last,
                       const basic_regex<CharT, Traits>& re,
                       bool                              anchored,
                       regex_constants::match_flag_type  mf)
    {
      if constexpr (real_eligible<CharT, Traits>) {
        if (re.uses_real() && real_honors(mf)) {
          const std::string_view sv     {std::to_address(first),
                                         static_cast<std::size_t>(std::distance(first, last))};
          const real::regex&     engine {std::get<real::regex>(re.engine())};
          return anchored ? engine.fullmatch(sv).matched()
                 : (re.posix_longest() ? engine.search_longest(sv) : engine.search(sv)).matched();
        }
      }
      const std::basic_regex<CharT, Traits>& std_engine {re.std_engine()};
      const auto                             sf         {to_std_match(mf)};
      return anchored ? std::regex_match(first, last, std_engine, sf)
                      : std::regex_search(first, last, std_engine, sf);
    }
  } // namespace detail
 
  template <typename BidirIt, typename CharT, typename Traits>
  bool regex_search(BidirIt                           first,
                    BidirIt                           last,
                    match_results<BidirIt>&           m,
                    const basic_regex<CharT, Traits>& re,
                    regex_constants::match_flag_type  flags = regex_constants::match_default)
  {
    return detail::run(first, last, m, re, /*anchored=*/ false, flags);
  }
 
  template <typename CharT, typename Traits>
  bool regex_search(const std::basic_string<CharT>&                                   s,
                    match_results<typename std::basic_string<CharT>::const_iterator>& m,
                    const basic_regex<CharT, Traits>&                                 re,
                    regex_constants::match_flag_type                                  flags = regex_constants::match_default)
  {
    return detail::run(s.begin(), s.end(), m, re, false, flags);
  }
 
  template <typename CharT, typename Traits>
  bool regex_search(const CharT                     * s,
                    match_results<const CharT*>&      m,
                    const basic_regex<CharT, Traits>& re,
                    regex_constants::match_flag_type  flags = regex_constants::match_default)
  {
    return detail::run(s, s + std::char_traits<CharT>::length(s), m, re, false, flags);
  }
 
  template <typename BidirIt, typename CharT, typename Traits>
  bool regex_search(BidirIt                           first,
                    BidirIt                           last,
                    const basic_regex<CharT, Traits>& re,
                    regex_constants::match_flag_type  flags = regex_constants::match_default)
  {
    return detail::run_nocapture(first, last, re, false, flags);
  }
 
  template <typename CharT, typename Traits>
  bool regex_search(const std::basic_string<CharT>&   s,
                    const basic_regex<CharT, Traits>& re,
                    regex_constants::match_flag_type  flags = regex_constants::match_default)
  {
    return detail::run_nocapture(s.begin(), s.end(), re, false, flags);
  }
 
  template <typename CharT, typename Traits>
  bool regex_search(const CharT                     * s,
                    const basic_regex<CharT, Traits>& re,
                    regex_constants::match_flag_type  flags = regex_constants::match_default)
  {
    return detail::run_nocapture(s, s + std::char_traits<CharT>::length(s), re, false, flags);
  }
 
  template <typename BidirIt, typename CharT, typename Traits>
  bool regex_match(BidirIt                           first,
                   BidirIt                           last,
                   match_results<BidirIt>&           m,
                   const basic_regex<CharT, Traits>& re,
                   regex_constants::match_flag_type  flags = regex_constants::match_default)
  {
    return detail::run(first, last, m, re, /*anchored=*/ true, flags);
  }
 
  template <typename CharT, typename Traits>
  bool regex_match(const std::basic_string<CharT>&                                   s,
                   match_results<typename std::basic_string<CharT>::const_iterator>& m,
                   const basic_regex<CharT, Traits>&                                 re,
                   regex_constants::match_flag_type                                  flags = regex_constants::match_default)
  {
    return detail::run(s.begin(), s.end(), m, re, true, flags);
  }
 
  template <typename CharT, typename Traits>
  bool regex_match(const CharT                     * s,
                   match_results<const CharT*>&      m,
                   const basic_regex<CharT, Traits>& re,
                   regex_constants::match_flag_type  flags = regex_constants::match_default)
  {
    return detail::run(s, s + std::char_traits<CharT>::length(s), m, re, true, flags);
  }
 
  template <typename BidirIt, typename CharT, typename Traits>
  bool regex_match(BidirIt                           first,
                   BidirIt                           last,
                   const basic_regex<CharT, Traits>& re,
                   regex_constants::match_flag_type  flags = regex_constants::match_default)
  {
    return detail::run_nocapture(first, last, re, true, flags);
  }
 
  template <typename CharT, typename Traits>
  bool regex_match(const std::basic_string<CharT>&   s,
                   const basic_regex<CharT, Traits>& re,
                   regex_constants::match_flag_type  flags = regex_constants::match_default)
  {
    return detail::run_nocapture(s.begin(), s.end(), re, true, flags);
  }
 
  template <typename CharT, typename Traits>
  bool regex_match(const CharT                     * s,
                   const basic_regex<CharT, Traits>& re,
                   regex_constants::match_flag_type  flags = regex_constants::match_default)
  {
    return detail::run_nocapture(s, s + std::char_traits<CharT>::length(s), re, true, flags);
  }
 
  // Reject matching against an rvalue string (the result would dangle), mirroring real/std. Both the
  // 3-arg and the 4-arg (with match flags) forms must be deleted — otherwise the temporary binds to
  // the const-ref overload and the filled match_results dangles into freed storage.
  template <typename CharT, typename Traits>
  bool regex_search(const std::basic_string<CharT>&&,
                    match_results<typename std::basic_string<CharT>::const_iterator>&,
                    const basic_regex<CharT, Traits>&) = delete;
  template <typename CharT, typename Traits>
  bool regex_search(const std::basic_string<CharT>&&,
                    match_results<typename std::basic_string<CharT>::const_iterator>&,
                    const basic_regex<CharT, Traits>&,
                    regex_constants::match_flag_type) = delete;
  template <typename CharT, typename Traits>
  bool regex_match(const std::basic_string<CharT>&&,
                   match_results<typename std::basic_string<CharT>::const_iterator>&,
                   const basic_regex<CharT, Traits>&) = delete;
  template <typename CharT, typename Traits>
  bool regex_match(const std::basic_string<CharT>&&,
                   match_results<typename std::basic_string<CharT>::const_iterator>&,
                   const basic_regex<CharT, Traits>&,
                   regex_constants::match_flag_type) = delete;
 
  // --- regex_replace -----------------------------------------------------------------------
 
  namespace detail {
 
    template <typename RealMatch>
    void expand_format(std::string&     out,
                       const RealMatch& m,
                       std::string_view fmt,
                       std::string_view text,
                       std::size_t      prefix_start)
    {
      const std::size_t group_count {m.size()};   // includes group 0
      const std::size_t whole_start {m.start(0)};
      const std::size_t whole_end   {m.end(0)};
      for (std::size_t i = 0; i < fmt.size(); ++i) {
        if (fmt[i] != '$') {
          out.push_back(fmt[i]);
          continue;
        }
        if (i + 1 >= fmt.size()) {
          out.push_back('$');
          break;
        }
        const char next {fmt[i + 1]};
        if (next == '$') {
          out.push_back('$');
          ++i;
        }
        else if (next == '&') {
          out.append(text.substr(whole_start, whole_end - whole_start));
          ++i;
        }
        else if (next == '`') {
          out.append(text.substr(prefix_start, whole_start - prefix_start));
          ++i;
        }
        else if (next == '\'') {
          out.append(text.substr(whole_end));
          ++i;
        }
        else if (next >= '0' && next <= '9') {
          // ECMAScript / std: greedily take a second digit when present (`$12` -> group 12; `$015`
          // -> group 01 == 1, then a literal '5'). The 2-digit value is used as-is; a reference to a
          // group that does not exist expands to nothing (the digits are still consumed). ($0… is
          // screened to std up front, so `next` here is 1-9.)
          std::size_t group    {static_cast<std::size_t>(next - '0')};
          std::size_t consumed {1};
          if (i + 2 < fmt.size() && fmt[i + 2] >= '0' && fmt[i + 2] <= '9') {
            group    = (group * 10) + static_cast<std::size_t>(fmt[i + 2] - '0');
            consumed = 2;
          }
          if (group >= 1 && group < group_count && m.start(group) != real::npos) {
            out.append(text.substr(m.start(group), m.end(group) - m.start(group)));
          }
          i += consumed;
        }
        else {
          out.push_back('$'); // a `$` not forming a valid reference is literal
        }
      }
    }
  } // namespace detail
 
  template <typename CharT, typename Traits>
  std::basic_string<CharT> regex_replace(const std::basic_string<CharT>&   s,
                                         const basic_regex<CharT, Traits>& re,
                                         const std::basic_string<CharT>&   fmt,
                                         regex_constants::match_flag_type  flags = regex_constants::format_default)
  {
    if constexpr (!detail::real_eligible<CharT, Traits>) {
      // wide / custom-traits: always std (real is not eligible for this CharT).
      return std::regex_replace(s, re.std_engine(), fmt, detail::to_std_match(flags));
    }
    else {
      // Route to std when: the pattern is not real-traversable (std/nullable), OR a flag the real
      // expander cannot honor is set (any constraining match flag or format_sed — see
      // detail::replace_stays_real), OR the format uses `$0` (platform-variant, format_forces_std).
      // Only then does the real expander run.
      if (!re.uses_real_traversal() || !detail::replace_stays_real(flags)
          || detail::format_forces_std(std::string_view {fmt})) {
        return std::regex_replace(s, re.std_engine(), fmt, detail::to_std_match(flags));
      }
      const real::regex&     engine     {std::get<real::regex>(re.engine())};
      const std::string_view text       {s};
      std::string            out;
      const bool             first_only {(flags & regex_constants::format_first_only) != 0U};
      const bool             no_copy    {(flags & regex_constants::format_no_copy) != 0U};
      std::size_t            last_end   {0};
      bool                   done       {false};
      // POSIX ERE iterates with leftmost-longest bounds (find_iter_longest); the ECMAScript default keeps
      // leftmost-first. Both yield the same match type, so the range-for binds either.
      const auto matches {re.posix_longest() ? engine.find_iter_longest(text) : engine.find_iter(text)};
      for (const auto& match : matches) {
        if (done) {
          break;
        }
        const std::size_t prefix_start {last_end};
        if (!no_copy) {
          out.append(text.substr(last_end, match.start() - last_end));
        }
        detail::expand_format(out, match, std::string_view {fmt}, text, prefix_start);
        last_end = match.end();
        if (first_only) {
          done = true;
        }
      }
      if (!no_copy) {
        out.append(text.substr(last_end));
      }
      return out;
    }
  }
 
  template <typename CharT, typename Traits>
  std::basic_string<CharT> regex_replace(const std::basic_string<CharT>&   s,
                                         const basic_regex<CharT, Traits>& re,
                                         const CharT                     * fmt,
                                         regex_constants::match_flag_type  flags = regex_constants::format_default)
  {
    return regex_replace(s, re, std::basic_string<CharT>(fmt), flags);
  }
 
  template <typename OutputIt, typename BidirIt, typename CharT, typename Traits>
  OutputIt regex_replace(OutputIt                          out,
                         BidirIt                           first,
                         BidirIt                           last,
                         const basic_regex<CharT, Traits>& re,
                         const std::basic_string<CharT>&   fmt,
                         regex_constants::match_flag_type  flags = regex_constants::format_default)
  {
    const std::basic_string<CharT> result {regex_replace(std::basic_string<CharT>(first, last), re, fmt, flags)};
    return std::copy(result.begin(), result.end(), out);
  }
 
  // --- regex_iterator ----------------------------------------------------------------------
} // namespace real::compat
 
#endif // REAL_STD_REGEX_MATCH_HPP