regex_core.hpp

Go to the documentation of this file.

 
#ifndef REAL_STD_REGEX_CORE_HPP
#define REAL_STD_REGEX_CORE_HPP
 
// Internal — do not include directly.
// Users: #include <real/real.hpp> (or the documented opt-ins <real/dfa.hpp>, <real/std/regex.hpp>).
 
#include <real/version.hpp>
 
#include <cstddef>
#include <mutex>
#include <optional>
#include <regex>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
 
#include <real/real.hpp>
 
namespace real::compat {
 
  namespace regex_constants {
 
    enum syntax_option_type : unsigned
    {
      ECMAScript = 0,        
      icase      = 1U << 0U, 
      nosubs     = 1U << 1U, 
      optimize   = 1U << 2U, 
      collate    = 1U << 3U, 
      multiline  = 1U << 4U, 
      basic      = 1U << 5U, 
      extended   = 1U << 6U, 
      awk        = 1U << 7U, 
      grep       = 1U << 8U, 
      egrep      = 1U << 9U, 
    };
 
    constexpr syntax_option_type operator|(syntax_option_type a,
                                           syntax_option_type b) noexcept
    {
      return static_cast<syntax_option_type>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
    }
 
    constexpr syntax_option_type operator&(syntax_option_type a,
                                           syntax_option_type b) noexcept
    {
      return static_cast<syntax_option_type>(static_cast<unsigned>(a) & static_cast<unsigned>(b));
    }
 
    enum match_flag_type : unsigned
    {
      match_default    = 0,
      match_not_bol    = 1U << 0U,   
      match_not_eol    = 1U << 1U,   
      match_not_bow    = 1U << 2U,   
      match_not_eow    = 1U << 3U,   
      match_any        = 1U << 4U,
      match_not_null   = 1U << 5U,   
      match_continuous = 1U << 6U,   
      match_prev_avail = 1U << 7U,
      format_default    = 0,
      format_sed        = 1U << 8U,  
      format_no_copy    = 1U << 9U,  
      format_first_only = 1U << 10U, 
    };
 
    constexpr match_flag_type operator|(match_flag_type a,
                                        match_flag_type b) noexcept
    {
      return static_cast<match_flag_type>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
    }
 
    constexpr match_flag_type operator&(match_flag_type a,
                                        match_flag_type b) noexcept
    {
      return static_cast<match_flag_type>(static_cast<unsigned>(a) & static_cast<unsigned>(b));
    }
 
    constexpr match_flag_type operator~(match_flag_type a) noexcept
    {
      return static_cast<match_flag_type>(~static_cast<unsigned>(a));
    }
 
    using error_type = std::regex_constants::error_type;
  } // namespace regex_constants
 
  class regex_error : public std::regex_error
  {
  public:
 
    explicit regex_error(const std::regex_error& error)
      : std::regex_error(error.code()),
        message_(error.what())
    {}
 
    regex_error(std::regex_constants::error_type code,
                std::string                      message)
      : std::regex_error(code),
        message_(std::move(message))
    {}
 
    [[nodiscard]] const char* what() const noexcept override
    {
      return message_.c_str();
    }
 
  private:
 
    std::string message_; 
  };
 
  enum class policy : std::uint8_t
  {
    strict,   
    fallback, 
  };
 
  namespace detail {
 
    template <typename CharT, typename Traits>
    inline constexpr bool real_eligible =
      std::is_same_v<CharT, char> && std::is_same_v<Traits, std::regex_traits<char>>;
 
    inline bool grammar_forces_std(regex_constants::syntax_option_type f) noexcept
    {
      using namespace regex_constants;
      return (f & (basic | extended | awk | grep | egrep)) != ECMAScript
             || (f & collate) != ECMAScript
             || (f & nosubs) != ECMAScript;
    }
 
    [[nodiscard]] inline bool pattern_forces_std(std::string_view p) noexcept
    {
      const auto is_flag_or_dash = [](char c) {
                                     return c == '-' || c == 'i' || c == 'm' || c == 's' || c == 'x' || c == 'a';
                                   };
      for (std::size_t i = 0; i < p.size(); ++i) {
        if (p[i] == '\\') {
          if (i + 2 < p.size() && p[i + 1] == '0' && p[i + 2] >= '0' && p[i + 2] <= '9') {
            return true;
          }
          ++i; // consume the escaped character (so `\\0` is an escaped backslash, not `\0`)
          continue;
        }
        // An inline-flags group `(?imsxa:...)` / `(?-...:...)` / a bare `(?imsxa)`: real accepts these
        // (Python semantics), but ECMAScript has no inline flags, so std rejects them. Route to std so
        // compat stays ≡ std — the char after `(?` is a flag letter or `-` only for a flag construct
        // (`(?:` `(?=` `(?!` `(?<` `(?P` start with other characters). Over-routing here is safe.
        if (p[i] == '(' && i + 2 < p.size() && p[i + 1] == '?' && is_flag_or_dash(p[i + 2])) {
          return true;
        }
      }
      return false;
    }
 
    [[nodiscard]] inline bool format_forces_std(std::string_view fmt) noexcept
    {
      for (std::size_t i = 0; i < fmt.size(); ++i) {
        if (fmt[i] == '$' && i + 1 < fmt.size()) {
          if (fmt[i + 1] == '$') {
            ++i;         // `$$` — escaped literal dollar
          }
          else if (fmt[i + 1] == '0') {
            return true; // `$0…` platform-variant
          }
        }
      }
      return false;
    }
 
    inline std::string posix_class_ranges(std::string_view name)
    {
      if (name == "alpha") { return "A-Za-z"; }
      if (name == "digit") { return "0-9"; }
      if (name == "alnum") { return "0-9A-Za-z"; }
      if (name == "upper") { return "A-Z"; }
      if (name == "lower") { return "a-z"; }
      if (name == "xdigit") { return "0-9A-Fa-f"; }
      if (name == "space") { return "\\t\\n\\x0b\\f\\r "; }
      if (name == "blank") { return "\\t "; }
      if (name == "cntrl") { return "\\x00-\\x1f\\x7f"; }
      if (name == "print") { return "\\x20-\\x7e"; }
      if (name == "graph") { return "\\x21-\\x7e"; }
      if (name == "punct") { return "!-/:-@\\[-`{-~"; }
      return {};
    }
 
    [[nodiscard]] inline bool translate_bracket(std::string_view p,
                                                std::size_t&     i,
                                                std::string&     out)
    {
      const std::size_t n   {p.size()};
      std::string       cls {'['};
      i += 1;
      if (i < n && p[i] == '^') { cls += '^'; i += 1; }
      if (i < n && p[i] == ']') { cls += "\\]"; i += 1; } // a leading `]` is a literal member in POSIX — escape
                                                          // it for REAL, where a bare `[]` opens an empty class
      while (i < n && p[i] != ']') {
        if (p[i] == '[' && i + 1 < n && p[i + 1] == ':') {
          const std::size_t close  {p.find(":]", i + 2)};
          if (close == std::string_view::npos) { return false; }
          const std::string ranges {posix_class_ranges(p.substr(i + 2, close - (i + 2)))};
          if (ranges.empty()) { return false; }
          cls += ranges;
          i    = close + 2;
        }
        else if (p[i] == '[' && i + 1 < n && (p[i + 1] == '.' || p[i + 1] == '=')) {
          return false; // collating [.x.] / equivalence [=x=]
        }
        else {
          cls += p[i];
          i   += 1;
        }
      }
      if (i >= n) { return false; } // unterminated class
      cls += ']';
      i   += 1;
      out += cls;
      return true;
    }
 
    [[nodiscard]] inline bool append_awk_escape(std::string_view p,
                                                std::size_t&     i,
                                                std::string&     out)
    {
      const std::size_t n {p.size()};
      const char        d {p[i + 1]};
      const auto        emit_hex {[&out](unsigned v) {
                                    constexpr std::string_view hex {"0123456789abcdef"};
                                    out += "\\x";
                                    out += hex[(v >> 4U) & 0xFU];
                                    out += hex[v & 0xFU];
                                  }};
      switch (d) {
        case 'b': emit_hex(0x08U); i += 2; return true; // BACKSPACE, not a word boundary
        case 'a': emit_hex(0x07U); i += 2; return true;
        case 'n': emit_hex(0x0AU); i += 2; return true;
        case 't': emit_hex(0x09U); i += 2; return true;
        case 'r': emit_hex(0x0DU); i += 2; return true;
        case 'f': emit_hex(0x0CU); i += 2; return true;
        case 'v': emit_hex(0x0BU); i += 2; return true;
        case '/': out                += '/'; i += 2; return true; // an escaped delimiter -> a literal slash
        case '"': out                += '"'; i += 2; return true; // a literal quote
        default: break;
      }
      if (d >= '0' && d <= '7') {
        unsigned    val    {0};
        std::size_t k      {i + 1};
        std::size_t digits {0};
        while (k < n && digits < 3 && p[k] >= '0' && p[k] <= '7') {
          val = (val * 8U) + static_cast<unsigned>(p[k] - '0');
          ++k;
          ++digits;
        }
        if (val > 0xFFU) { return false; } // an octal overflow (> 0377) -> std
        emit_hex(val);
        i = k;
        return true;
      }
      return false; // `\d` `\w` `\s` … — no awk meaning; decline
    }
 
    [[nodiscard]] inline bool has_empty_alternation_branch(std::string_view p)
    {
      bool in_class {false};
      for (std::size_t i = 0; i < p.size(); ++i) {
        const char c {p[i]};
        if (c == '\\') { ++i; continue; } // skip the escaped character
        if (in_class) {
          if (c == ']') { in_class = false; }
          continue;
        }
        if (c == '[') { in_class = true; continue; }
        if (c == '|') {
          const bool left_empty  {i == 0 || p[i - 1] == '(' || p[i - 1] == '|'};
          const bool right_empty {i + 1 >= p.size() || p[i + 1] == ')' || p[i + 1] == '|'};
          if (left_empty || right_empty) { return true; }
        }
      }
      return false;
    }
 
    [[nodiscard]] inline std::optional<std::string> translate_ere(std::string_view p,
                                                                  bool             awk = false)
    {
      if (has_empty_alternation_branch(p)) { return std::nullopt; } // std rejects these in POSIX -> keep ≡ std
      std::string       out;
      std::size_t       i {0};
      const std::size_t n {p.size()};
      while (i < n) {
        const char c {p[i]};
        if (c == '\\') {
          if (i + 1 >= n) { return std::nullopt; } // trailing backslash
          const char d {p[i + 1]};
          // `\]` / `\}` OUTSIDE a class are undefined in POSIX and the std libraries disagree — libc++ rejects
          // `\]` but accepts `\}`, libstdc++ rejects both, AT&T matches — so decline (≡ its own std per platform,
          // the same rule as the medial `^`/`$`). Ironically REAL was AT&T-conformant here, but the drop-in
          // contract is ≡-std, not ≡-AT&T. (Inside a class, `\]` is handled by translate_bracket, unaffected.)
          if (d == ']' || d == '}') { return std::nullopt; }
          if (std::string_view {".[]{}()*+?|^$\\"}.find(d) != std::string_view::npos) {
            out += '\\';
            out += d;
            i   += 2;
            continue; // an escaped metacharacter is a literal in both grammars
          }
          if (awk && append_awk_escape(p, i, out)) { continue; } // awk C-escapes (\b=BS, \n, octal, …)
          return std::nullopt; // \d, \w, \b, … — no ERE meaning; fall back to std
        }
        if (c == '[') {
          if (!translate_bracket(p, i, out)) { return std::nullopt; }
          continue;
        }
        if (c == '{') {
          // keep only a strict interval {n}/{n,}/{n,m}; an ambiguous `{` is literal in POSIX (it diverges).
          std::size_t       j  {i + 1};
          const std::size_t ds {j};
          while (j < n && p[j] >= '0' && p[j] <= '9') { ++j; }
          bool ok              {j > ds};
          if (ok && j < n && p[j] == ',') {
            ++j;
            while (j < n && p[j] >= '0' && p[j] <= '9') { ++j; }
          }
          ok = ok && j < n && p[j] == '}';
          if (!ok) { return std::nullopt; }
          out += p.substr(i, (j + 1) - i);
          i    = j + 1;
          continue;
        }
        out += c; // common production (. * + ? | ( ) ^ $ literal) — read alike
        i   += 1;
      }
      return out;
    }
 
    [[nodiscard]] inline std::optional<std::string> translate_bre(std::string_view p)
    {
      std::string       out;
      std::size_t       i        {0};
      const std::size_t n        {p.size()};
      bool              at_start {true}; // pattern start or just after `\‍(` — where `*` is literal and `^` anchors
      while (i < n) {
        const char c {p[i]};
        if (c == '\\') {
          if (i + 1 >= n) { return std::nullopt; }                          // trailing backslash
          const char d {p[i + 1]};
          if (d == '(') { out += '('; i += 2; at_start = true;  continue; } // \‍( -> group open
          if (d == ')') { out += ')'; i += 2; at_start = false; continue; } // \‍) -> group close
          if (d == '{') {                                                   // \{n\} / \{n,\} / \{n,m\} interval
            std::size_t       j  {i + 2};
            const std::size_t ds {j};
            while (j < n && p[j] >= '0' && p[j] <= '9') { ++j; }
            bool ok              {j > ds};
            if (ok && j < n && p[j] == ',') {
              ++j;
              while (j < n && p[j] >= '0' && p[j] <= '9') { ++j; }
            }
            if (!ok || j + 1 >= n || p[j] != '\\' || p[j + 1] != '}') { return std::nullopt; } // not a strict \{...\}
            out     += '{';
            out     += p.substr(i + 2, j - (i + 2));
            out     += '}';
            i        = j + 2;
            at_start = false;
            continue;
          }
          if (d == ']' || d == '}') { return std::nullopt; } // `\]` / `\}` outside a class: undefined, std-divergent
          if (std::string_view {".[]*\\^$"}.find(d) != std::string_view::npos) {
            out      += '\\'; // an escaped metacharacter is a literal in both grammars
            out      += d;
            i        += 2;
            at_start  = false;
            continue;
          }
          return std::nullopt; // \1-\9 backref, \d\w\s\b, \+ \? \| (not BRE), stray \} -> decline
        }
        if (c == '(' || c == ')' || c == '{' || c == '}' || c == '|' || c == '+' || c == '?') {
          out      += '\\';    // bare, these are literals in BRE -> escape for REAL
          out      += c;
          i        += 1;
          at_start  = false;
          continue;
        }
        if (c == '^') {
          if (i == 0) { out += '^'; i += 1; at_start = false; continue; } // anchor at the pattern head (libs agree)
          return std::nullopt; // a medial `^` is a POSIX literal, but libstdc++ reads it as an anchor while
                               // libc++ reads it as a literal — decline so compat stays ≡ its own std
        }
        if (c == '$') {
          if (i + 1 == n) { out += '$'; i += 1; at_start = false; continue; } // anchor at the tail (libs agree)
          return std::nullopt; // a medial `$` — the same libstdc++/libc++ disagreement; decline to std
        }
        if (c == '*') {
          if (at_start) { return std::nullopt; } // a leading `*` is a literal in POSIX BRE -> decline (rare)
          out += '*';                            // quantifier
          i   += 1;
          continue;
        }
        if (c == '[') {
          if (!translate_bracket(p, i, out)) { return std::nullopt; }
          at_start = false;
          continue;
        }
        out      += c; // `.` and ordinary literals — read alike
        i        += 1;
        at_start  = false;
      }
      return out;
    }
 
    template <typename LineFn>
    [[nodiscard]] inline std::optional<std::string> translate_newline_alt(std::string_view p,
                                                                          LineFn           translate_line)
    {
      std::string out;
      std::size_t start {0};
      bool        first {true};
      while (true) {
        const std::size_t      nl          {p.find('\n', start)};
        const std::string_view line        {p.substr(start, (nl == std::string_view::npos ? p.size() : nl) - start)};
        if (line.empty()) { return std::nullopt; } // a blank branch -> std
        const std::optional<std::string> t {translate_line(line)};
        if (!t) { return std::nullopt; }
        if (!first) { out += '|'; }
        out  += *t;
        first = false;
        if (nl == std::string_view::npos) { break; }
        start = nl + 1;
      }
      return out;
    }
 
    [[nodiscard]] inline std::optional<std::string> translate_posix(std::string_view                    p,
                                                                    regex_constants::syntax_option_type f)
    {
      using namespace regex_constants;
      if ((f & (collate | nosubs)) != ECMAScript) { return std::nullopt; }
      int grammars {0};
      if ((f & basic) != ECMAScript) { ++grammars; }
      if ((f & extended) != ECMAScript) { ++grammars; }
      if ((f & awk) != ECMAScript) { ++grammars; }
      if ((f & grep) != ECMAScript) { ++grammars; }
      if ((f & egrep) != ECMAScript) { ++grammars; }
      if (grammars != 1) { return std::nullopt; } // ECMAScript (0), or a mix — not a single POSIX grammar
      if ((f & extended) != ECMAScript) { return translate_ere(p); }
      if ((f & basic) != ECMAScript) { return translate_bre(p); }
      if ((f & awk) != ECMAScript) { return translate_ere(p, /*awk=*/ true); }
      if ((f & grep) != ECMAScript) { return translate_newline_alt(p, [](std::string_view l) { return translate_bre(l); }); }
      return translate_newline_alt(p, [](std::string_view l) { return translate_ere(l); }); // egrep
    }
 
    inline real::flags to_real(regex_constants::syntax_option_type f) noexcept
    {
      real::flags r {real::flags::bytes | real::flags::ecma};
      if ((f & regex_constants::icase) != regex_constants::ECMAScript) { r = r | real::flags::icase; }
      if ((f & regex_constants::multiline) != regex_constants::ECMAScript) { r = r | real::flags::multiline; }
      return r;
    }
 
    inline std::regex_constants::syntax_option_type to_std(regex_constants::syntax_option_type f) noexcept
    {
      namespace sc = std::regex_constants;
      sc::syntax_option_type s {};
      using namespace regex_constants;
      if ((f & icase) != ECMAScript) { s |= sc::icase; }
      if ((f & nosubs) != ECMAScript) { s |= sc::nosubs; }
      if ((f & optimize) != ECMAScript) { s |= sc::optimize; }
      if ((f & collate) != ECMAScript) { s |= sc::collate; }
      if ((f & multiline) != ECMAScript) { s |= sc::multiline; }
      if ((f & basic) != ECMAScript) { s |= sc::basic; }
      else if ((f & extended) != ECMAScript) { s |= sc::extended; }
      else if ((f & awk) != ECMAScript) { s |= sc::awk; }
      else if ((f & grep) != ECMAScript) { s |= sc::grep; }
      else if ((f & egrep) != ECMAScript) { s |= sc::egrep; }
      else { s |= sc::ECMAScript; }
      return s;
    }
  } // namespace detail
 
  template <typename CharT = char, typename Traits = std::regex_traits<CharT>>
  class basic_regex
  {
  public:
 
    using value_type  = CharT;                               
    using flag_type   = regex_constants::syntax_option_type; 
    using string_type = std::basic_string<CharT>;            
 
    basic_regex() = default;                                 // the variant default-constructs to an empty std regex
 
    explicit basic_regex(const CharT* pattern,
                         flag_type    f   = regex_constants::ECMAScript,
                         policy       pol = policy::strict)
    {
      policy_ = pol;
      assign(std::basic_string_view<CharT>(pattern), f);
    }
 
    explicit basic_regex(const string_type& pattern,
                         flag_type          f   = regex_constants::ECMAScript,
                         policy             pol = policy::strict)
    {
      policy_ = pol;
      assign(std::basic_string_view<CharT>(pattern), f);
    }
 
    basic_regex(const CharT* pattern,
                std::size_t  len,
                flag_type    f   = regex_constants::ECMAScript,
                policy       pol = policy::strict)
    {
      policy_ = pol;
      assign(std::basic_string_view<CharT>(pattern, len), f);
    }
 
    template <typename It>
    basic_regex(It        begin,
                It        end,
                flag_type f   = regex_constants::ECMAScript,
                policy    pol = policy::strict)
    {
      policy_ = pol;
      const string_type pattern(begin, end);
      assign(std::basic_string_view<CharT>(pattern), f);
    }
 
    [[nodiscard]] std::size_t mark_count() const noexcept
    {
      return mark_count_;
    }
 
    [[nodiscard]] flag_type flags() const noexcept
    {
      return flags_;
    }
 
    void swap(basic_regex& other) noexcept
    {
      engine_.swap(other.engine_);
      std::swap(pattern_, other.pattern_);
      std::swap(flags_, other.flags_);
      std::swap(mark_count_, other.mark_count_);
      std::swap(nullable_, other.nullable_);
      std::swap(posix_longest_, other.posix_longest_);
      std::swap(lazy_std_, other.lazy_std_);
      std::swap(policy_, other.policy_);
    }
 
    [[nodiscard]] bool uses_real() const noexcept
    {
      return std::holds_alternative<real::regex>(engine_);
    }
 
    [[nodiscard]] bool uses_fallback() const noexcept
    {
      return !uses_real();
    }
 
    [[nodiscard]] compat::policy policy() const noexcept
    {
      return policy_;
    }
 
    [[nodiscard]] const std::variant<std::basic_regex<CharT, Traits>, real::regex>& engine() const noexcept
    {
      return engine_;
    }
 
    [[nodiscard]] bool nullable() const noexcept
    {
      return nullable_;
    }
 
    [[nodiscard]] bool posix_longest() const noexcept
    {
      return posix_longest_;
    }
 
    [[nodiscard]] bool uses_real_traversal() const noexcept
    {
      return uses_real() && !nullable_;
    }
 
    [[nodiscard]] const std::basic_regex<CharT, Traits>& std_engine() const
    {
      if (std::holds_alternative<std::basic_regex<CharT, Traits>>(engine_)) {
        return std::get<std::basic_regex<CharT, Traits>>(engine_);
      }
      static std::mutex          build_mutex; // one per basic_regex<CharT, Traits> instantiation
      const std::lock_guard      lock {build_mutex};
      if (!lazy_std_.has_value()) {
        try {
          lazy_std_.emplace(pattern_.data(), pattern_.size(), detail::to_std(flags_));
        }
        catch (const std::regex_error& std_error) {
          // A pattern real accepted but std cannot build (a real superset) reaches std only via a
          // constraining flag / nullable replace-iterate. Surface it as a compat::regex_error, not a
          // raw std one: an error, homogeneous with the ctor path, never a silent result.
          throw regex_error(std_error);
        }
      }
      return *lazy_std_;
    }
 
  private:
 
    // std backend first so the variant is default-constructible (real::regex has no default ctor).
    std::variant<std::basic_regex<CharT, Traits>, real::regex>           engine_;
    string_type                                                          pattern_;                        
    flag_type                                                            flags_         {regex_constants::ECMAScript};
    std::size_t                                                          mark_count_    {};
    bool                                                                 nullable_      {};               
    bool                                                                 posix_longest_ {};               
    mutable std::optional<std::basic_regex<CharT, Traits>>               lazy_std_;                       
    compat::policy                                                       policy_        {policy::strict}; 
 
    void assign(std::basic_string_view<CharT> pattern,
                flag_type                     f)
    {
      flags_   = f;
      pattern_ = string_type(pattern);
      lazy_std_.reset();
      nullable_      = false;
      posix_longest_ = false;
      if constexpr (detail::real_eligible<CharT, Traits>) {
        const std::string_view sv {pattern.data(), pattern.size()};
        // PX1a/PX1b: a single POSIX grammar (extended -> ERE, basic -> BRE; awk/grep/egrep next) on the linear
        // engine when the pattern translates — run it on REAL with leftmost-LONGEST bounds (the POSIX semantics,
        // via search_longest / find_iter_longest) instead of delegating to std's backtracker. A `nullopt` (a
        // wrong grammar mix, or an untranslatable construct) or a real reject falls through to the std path below;
        // the fallback lives, and nothing that used to reach std stops reaching it.
        if (!detail::pattern_forces_std(sv)) {
          if (const std::optional<std::string> translated {detail::translate_posix(sv, f)}) {
            try {
              real::regex compiled(*translated, detail::to_real(f));
              mark_count_    = compiled.group_count();
              nullable_      = compiled.raw_program().hints.empty_match_possible;
              posix_longest_ = true;
              engine_.template emplace<real::regex>(std::move(compiled));
              return;
            }
            catch (const real::regex_error&) {
              // translated but real cannot represent it -> fall through to the std path
            }
          }
        }
        if (detail::grammar_forces_std(f) || detail::pattern_forces_std(sv)) {
          reject_or_fallback(sv, f, "the pattern uses a construct the linear engine does not represent "
                             "(a backreference, an unbounded lookaround, a POSIX class, or a "
                             "grammar that forces std)");
          return;
        }
        try {
          real::regex compiled(sv, detail::to_real(f));
          mark_count_ = compiled.group_count();
          nullable_   = compiled.raw_program().hints.empty_match_possible;
          engine_.template emplace<real::regex>(std::move(compiled));
          // The std engine for a real-backed pattern (needed for a constraining flag or nullable
          // replace/iterate) is built lazily and thread-safely by std_engine() under its build mutex,
          // so no eager build is needed here (a real superset that std rejects surfaces the wrapped
          // error only when the std-only operation is actually invoked; search/match stay on real).
        }
        catch (const real::regex_error& real_error) {
          // real cannot represent it (backref / unbounded lookaround / POSIX class / non-ASCII in a
          // class). strict rejects; fallback delegates to std (which may accept it). Invalid for both
          // throws compat::regex_error (emplace_std wraps).
          reject_or_fallback(sv, f, real_error.what());
        }
      }
      else {
        // wchar_t / char8/16/32 / custom traits: real is never eligible, so go straight to std. The
        // real::regex variant alternative stays dead for this CharT (never emplaced), and real's
        // char-only helpers are not instantiated. always-std => std parity by construction.
        try {
          engine_.template emplace<std::basic_regex<CharT, Traits>>(pattern.data(), pattern.size(),
                                                                    detail::to_std(f));
          mark_count_ = std::get<std::basic_regex<CharT, Traits>>(engine_).mark_count();
        }
        catch (const std::regex_error& std_error) {
          throw regex_error(std_error); // homogeneous compat::regex_error on the wide/custom-traits path
        }
      }
    }
 
    void reject_or_fallback(std::string_view   sv,
                            flag_type          f,
                            const std::string& reason)
    {
      if (policy_ == policy::strict) {
        // Distinguish "real cannot represent it, but the pattern is valid" (std accepts) from "invalid for
        // both" (a syntax error). The first is a capability limit -> error_complexity; the second is a bad
        // pattern -> std's own code, so a syntax error still reports as a syntax error, exactly like std.
        if constexpr (detail::real_eligible<CharT, Traits>) {
          try {
            const std::basic_regex<CharT, Traits> probe(sv.data(), sv.size(), detail::to_std(f));
            static_cast<void>(probe);     // std accepts it: a real-only limitation, fall through to the throw below
          }
          catch (const std::regex_error& std_error) {
            throw regex_error(std_error); // invalid for both -> std's exact code (drop-in ≡ std)
          }
        }
        throw regex_error(std::regex_constants::error_complexity,
                          "real::compat (strict policy): this pattern requires a non-linear (backtracking) "
                          "engine — " + reason + ". Construct with policy::fallback to delegate it to "
                          "std::regex, forfeiting the linear-time / ReDoS-safe guarantee for it.");
      }
      emplace_std(sv, f);
    }
 
    void emplace_std(std::string_view sv,
                     flag_type        f)
    {
      try {
        auto& std_engine = engine_.template emplace<std::basic_regex<CharT, Traits>>(
          sv.data(), sv.size(), detail::to_std(f));
        mark_count_ = std_engine.mark_count();
      }
      catch (const std::regex_error& std_error) {
        // Every std-only build path throws a compat::regex_error, homogeneous with the rest of the
        // layer (never a raw std::regex_error leaking out of a compat entry point).
        throw regex_error(std_error);
      }
    }
  };
 
  using regex  = basic_regex<char>;    
  using wregex = basic_regex<wchar_t>; 
} // namespace real::compat
 
#endif // REAL_STD_REGEX_CORE_HPP