ast.hpp

Go to the documentation of this file.

 
#ifndef REAL_AST_HPP
#define REAL_AST_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 <algorithm>
#include <cstdint>
#include <span>
#include <string_view>
#include <vector>
 
#include "real/core/charclass.hpp"
#include "real/core/config.hpp"
#include "real/core/program.hpp"
#include "real/unicode/unicode_fold.hpp"
#include "real/unicode/unicode_property.hpp"
#include "real/unicode/unicode_props.hpp"
#include "real/unicode/unicode_script.hpp"
#include "real/unicode/utf8.hpp"
 
namespace real::detail {
 
  enum class node_kind : std::uint8_t
  {
    empty,       
    byte,        
    klass,       
    any,         
    concat,      
    repeat,      
    alternation, 
    group,       
    anchor,      
    lookaround,  
  };
 
  enum class anchor_kind : std::uint8_t
  {
    caret,             
    dollar,            
    text_start,        
    text_end,          
    word_boundary,     
    not_word_boundary, 
    word_start,        
    word_end,          
  };
 
  struct ast_node
  {
    node_kind    kind            {node_kind::empty};   
    std::uint8_t byte            {};                   
    anchor_kind  anchor          {anchor_kind::caret}; 
    bool         negated         {};                   
    bool         lazy            {};                   
    look_dir     direction       {look_dir::ahead};    
    std::int32_t klass           {-1};                 
    std::int32_t min             {};                   
    std::int32_t max             {-1};                 
    std::int32_t group           {-1};                 
    std::int32_t child           {-1};                 
    std::int32_t next            {-1};                 
    std::uint8_t effective_flags {};                   
  };
 
  struct class_def
  {
    char_class              ascii;                    
    std::vector<code_range> ranges;                   
    bool                    codepoint_predicate {};   
  };
 
  constexpr std::vector<code_range> coalesce_ranges(std::vector<code_range> ranges)
  {
    // Fast path: already sorted and disjoint (no overlap, no adjacency). The shorthand / property tables come
    // this way, so a bare `\w`/`\d`/`\p{…}` class skips the O(n log n) sort and the second allocation entirely —
    // which also keeps it within a static_regex's constexpr step budget (the sort of the large word table would
    // otherwise blow it). Only a genuinely mixed class (a predicate plus a literal/range, or two predicates)
    // falls through to the sort.
    bool tidy {true};
    for (std::size_t i = 1; i < ranges.size(); ++i) {
      if (ranges[i].lo <= ranges[i - 1].hi + 1U) { // unsorted, overlapping, or adjacent
        tidy = false;
        break;
      }
    }
    if (tidy) {
      return ranges;
    }
    std::sort(ranges.begin(), ranges.end(),
              [](const code_range& a, const code_range& b) { return a.lo < b.lo; });
    std::vector<code_range> merged;
    for (const code_range& r : ranges) {
      if (!merged.empty() && r.lo <= merged.back().hi + 1U) { // overlapping OR adjacent
        merged.back().hi = merged.back().hi > r.hi ? merged.back().hi : r.hi;
      }
      else {
        merged.push_back(r);
      }
    }
    return merged;
  }
 
  constexpr std::vector<code_range> complement_code_ranges(std::vector<code_range> ranges)
  {
    const std::vector<code_range> merged {coalesce_ranges(std::move(ranges))};
    std::vector<code_range>       gaps;
    std::uint32_t                 next   {0x80U};
    for (const code_range& r : merged) {
      if (r.lo > next) {
        gaps.push_back({.lo = next, .hi = r.lo - 1U});
      }
      next = r.hi + 1U;
    }
    if (next <= 0x10FFFFU) {
      gaps.push_back({.lo = next, .hi = 0x10FFFFU});
    }
    return gaps;
  }
 
  struct ast
  {
    std::vector<ast_node>    nodes;                      
    std::vector<class_def>   classes;                    
    std::vector<named_group> names;                      
    flags                    inline_flags {flags::none}; 
    std::int32_t             group_count  {};            
    std::int32_t             root         {-1};          
  };
 
  enum class digit_escape_kind : std::uint8_t
  {
    octal,          
    group_ref,      
    octal_overflow, 
  };
 
  struct digit_escape_result
  {
    digit_escape_kind kind   {digit_escape_kind::group_ref}; 
    unsigned          value  {};                             
    std::size_t       length {};                             
  };
 
  constexpr digit_escape_result decode_digit_escape(std::string_view text,
                                                    std::size_t      first)
  {
    const auto is_octal {[](char c) { return c >= '0' && c <= '7'; }};
    const auto is_digit {[](char c) { return c >= '0' && c <= '9'; }};
    if (text[first] == '0') {
      unsigned    value {};
      std::size_t taken {};
      while (taken < 3 && first + taken < text.size() && is_octal(text[first + taken])) {
        value = (value * 8U) + static_cast<unsigned>(text[first + taken] - '0');
        ++taken;
      }
      return {.kind = digit_escape_kind::octal, .value = value & 0xFFU, .length = taken};
    }
    std::size_t length {1};
    if (first + 1 < text.size() && is_digit(text[first + 1])) {
      length = 2;
      if (is_octal(text[first]) && is_octal(text[first + 1]) && first + 2 < text.size() &&
          is_octal(text[first + 2])) {
        const unsigned value {(static_cast<unsigned>(text[first] - '0') * 8U * 8U) +
                              (static_cast<unsigned>(text[first + 1] - '0') * 8U) +
                              static_cast<unsigned>(text[first + 2] - '0')};
        return value > 0xFFU ? digit_escape_result {.kind   = digit_escape_kind::octal_overflow,
                                                    .value  = value,
                                                    .length = 3}
                             : digit_escape_result {.kind   = digit_escape_kind::octal, .value = value, .length = 3};
      }
    }
    unsigned group {};
    for (std::size_t k = 0; k < length; ++k) {
      group = (group * 10U) + static_cast<unsigned>(text[first + k] - '0');
    }
    return {.kind = digit_escape_kind::group_ref, .value = group, .length = length};
  }
 
  class parser
  {
  public:
 
    constexpr explicit parser(std::string_view pattern,
                              flags            initial_flags = flags::none)
      : pattern_(pattern),
        bytes_(has_flag(initial_flags, flags::bytes)),
        ecma_(has_flag(initial_flags, flags::ecma))
    {
      // The scope stack holds the flag set in force at each nesting level; the base is the
      // constructor's flags. A scoped group (?flags:...) pushes a modified copy for its body.
      flag_scopes_.push_back(initial_flags);
    }
 
    constexpr ast parse()
    {
      ast out;
      while (parse_global_flags_prefix(out)) {}
      out.root = parse_alternation(out);
      if (pos_ != pattern_.size()) {
        fail("unbalanced parenthesis"); // only a stray ')' stops earlier
      }
      return out;
    }
 
  private:
 
    std::string_view   pattern_;          
    std::size_t        pos_           {}; 
    std::int32_t       depth_         {}; 
    std::vector<flags> flag_scopes_;      
    bool               in_lookaround_ {}; 
    bool               bytes_         {}; 
    bool               ecma_          {}; 
 
    [[nodiscard]] constexpr flags current_flags() const
    {
      return flag_scopes_.back();
    }
 
    [[nodiscard]] constexpr bool is_verbose() const
    {
      return has_flag(current_flags(), flags::verbose);
    }
 
    [[nodiscard]] constexpr bool is_icase() const
    {
      return has_flag(current_flags(), flags::icase);
    }
 
    [[nodiscard]] constexpr bool is_ascii_mode() const
    {
      return has_flag(current_flags(), flags::ascii);
    }
 
    constexpr void skip_insignificant()
    {
      if (!is_verbose()) {
        return;
      }
      while (!eof()) {
        const char ch {peek()};
        if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || ch == '\f' || ch == '\v') {
          ++pos_;
        }
        else if (ch == '#') {
          while (!eof() && peek() != '\n') {
            ++pos_;
          }
        }
        else {
          break;
        }
      }
    }
 
    template <typename Error = regex_error>
    [[noreturn]] constexpr void fail(const char* message) const
    {
      throw Error(message, pos_);
    }
 
    template <typename = void>
    [[noreturn]] constexpr void fail_unsupported(const char* message) const
    {
      throw regex_error(message, pos_, error_kind::unsupported);
    }
 
    [[nodiscard]] constexpr bool eof() const
    {
      return pos_ >= pattern_.size();
    }
 
    [[nodiscard]] constexpr char peek() const
    {
      return pattern_[pos_];
    }
 
    [[nodiscard]] constexpr bool accept(char ch)
    {
      if (!eof() && peek() == ch) {
        ++pos_;
        return true;
      }
      return false;
    }
 
    static constexpr bool is_ascii_alnum(char ch)
    {
      return (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');
    }
 
    constexpr std::int32_t add_node(ast&     out,
                                    ast_node node)
    {
      // Stamp the flag set in force where this node was parsed (from the scope stack). Carried for
      // scoped-flag semantics; the compiler does not read it yet, so it does not change any program.
      node.effective_flags = static_cast<std::uint8_t>(current_flags());
      out.nodes.push_back(node);
      return static_cast<std::int32_t>(out.nodes.size()) - 1;
    }
 
    constexpr std::int32_t add_class_node(ast&                           out,
                                          const char_class&              klass,
                                          bool                           negated,
                                          const std::vector<code_range>& ranges              = {},
                                          bool                           codepoint_predicate = false)
    {
      out.classes.push_back({.ascii = klass, .ranges = ranges, .codepoint_predicate = codepoint_predicate});
      const auto index {static_cast<std::int32_t>(out.classes.size()) - 1};
      return add_node(out, {.kind = node_kind::klass, .negated = negated, .klass = index});
    }
 
    [[nodiscard]] constexpr bool text_shorthand() const
    {
      return !bytes_ && !is_ascii_mode();
    }
 
    constexpr void merge_property(char_class&                 klass,
                                  std::vector<code_range>&    ranges,
                                  const char_class&           prop_ascii,
                                  std::span<const code_range> table,
                                  bool                        negated,
                                  bool&                       property_derived) const
    {
      if (negated) {
        char_class inverted {prop_ascii};
        if (bytes_) {
          inverted.invert(); // raw bytes: plain 256-bit complement, no ranges
          klass.merge(inverted);
          return;
        }
        inverted.invert_ascii();
        klass.merge(inverted);
        // Text: the gaps between the property's ranges. ASCII: shorthand_ranges is empty, so the
        // complement is the whole non-ASCII space (`\W` under re.A still matches é).
        const std::vector<code_range> comp {complement_code_ranges(shorthand_ranges(table))};
        ranges.insert(ranges.end(), comp.begin(), comp.end());
      }
      else {
        klass.merge(prop_ascii);
        const std::vector<code_range> high {shorthand_ranges(table)};
        ranges.insert(ranges.end(), high.begin(), high.end());
      }
      property_derived = property_derived || text_shorthand();
    }
 
    [[nodiscard]] constexpr std::vector<code_range> shorthand_ranges(std::span<const code_range> table) const
    {
      std::vector<code_range> out;
      if (bytes_ || is_ascii_mode()) {
        return out;
      }
      for (const code_range& r : table) {
        if (r.hi < 0x80U) {
          continue; // wholly ASCII: already covered by the bitmap
        }
        out.push_back({.lo = r.lo < 0x80U ? 0x80U : r.lo, .hi = r.hi});
      }
      return out;
    }
 
    struct shorthand_spec
    {
      char_class                  set;     
      std::span<const code_range> ranges;  
      bool                        negated; 
    };
 
    [[nodiscard]] static constexpr shorthand_spec shorthand_class(char letter)
    {
      switch (letter) {
        case 'd': return {.set = digit_set(), .ranges = digit_ranges, .negated = false};
        case 'D': return {.set = digit_set(), .ranges = digit_ranges, .negated = true};
        case 'w': return {.set = word_set(), .ranges = word_ranges, .negated = false};
        case 'W': return {.set = word_set(), .ranges = word_ranges, .negated = true};
        case 's': return {.set = space_set(), .ranges = space_ranges, .negated = false};
        case 'S': return {.set = space_set(), .ranges = space_ranges, .negated = true};
        default: break;
      }
      // Unreachable: both call sites dispatch only on the six shorthand letters (see parse_escape /
      // parse_class_item). Kept as a structural fallback; never hit at run time (coverage-honest).
      return {.set = space_set(), .ranges = space_ranges, .negated = true};
    }
 
    struct loose_buf
    {
      std::array<char, 64> data {};
      std::size_t          len  {};
      [[nodiscard]] constexpr std::string_view view() const
      {
        return {data.data(), len};
      }
    };
 
    [[nodiscard]] static constexpr loose_buf loose_key(std::string_view s)
    {
      loose_buf b;
      for (const char c : s) {
        if (c == '_' || c == '-' || c == ' ') {
          continue;
        }
        if (b.len < b.data.size()) {
          b.data[b.len++] = (c >= 'A' && c <= 'Z') ? static_cast<char>(c - 'A' + 'a') : c;
        }
      }
      return b;
    }
 
    [[nodiscard]] constexpr std::vector<code_range> resolve_property(std::string_view name) const
    {
      std::string_view ns;
      std::string_view value {name};
      for (std::size_t i = 0; i < name.size(); ++i) {
        if (name[i] == '=') {
          ns    = name.substr(0, i);
          value = name.substr(i + 1);
          break;
        }
      }
      const loose_buf        ns_key      {loose_key(ns)};
      const std::string_view nk          {ns_key.view()};
      const bool             want_gc     {nk.empty() || nk == "gc" || nk == "generalcategory"};
      const bool             want_script {nk.empty() || nk == "sc" || nk == "script"};
      if (!want_gc && !want_script) {
        // well-formed `\p{ns=...}` but a namespace REAL does not offer (a binding may delegate it).
        fail_unsupported("unknown Unicode property namespace in \\p{...} (use gc= or sc=)");
      }
      const loose_buf value_key {loose_key(value)};
      if (want_gc) {
        const gc_property prop {resolve_gc(value_key.view())};
        if (prop != gc_property::count) {
          const std::span<const code_range> t {gc_property_ranges[static_cast<std::size_t>(prop)]};
          return {t.begin(), t.end()};
        }
      }
      if (want_script) {
        const script sc {resolve_script(value_key.view())};
        if (sc != script::count) {
          std::vector<code_range> out;
          for (const script_range& r : script_ranges) {
            if (r.sc == sc) {
              out.push_back({.lo = r.lo, .hi = r.hi});
            }
          }
          return out;
        }
      }
      // well-formed `\p{Name}` but a property REAL does not yet tabulate (e.g. a binary property like
      // `\p{Alphabetic}`, or a script/category REAL lacks): unsupported, so a binding can delegate it.
      fail_unsupported("unsupported Unicode property in \\p{...} (only General_Category and Script are built in)");
    }
 
    constexpr std::vector<code_range> parse_property_table()
    {
      // Read bytes-mode from the scope stack, not the global `bytes_` member (the flag-scope ratchet): bytes is
      // never scoped, so this equals `bytes_` while keeping the parser's global-read count flat.
      if (has_flag(current_flags(), flags::bytes)) {
        fail_unsupported("\\p{...} Unicode property classes are not available in bytes mode");
      }
      ++pos_; // consume the 'p' / 'P'
      std::string_view name;
      if (!eof() && peek() == '{') {
        ++pos_;
        const std::size_t start {pos_};
        while (!eof() && peek() != '}') {
          ++pos_;
        }
        if (eof()) {
          fail("unterminated \\p{...} property");
        }
        name = pattern_.substr(start, pos_ - start);
        ++pos_; // consume '}'
      }
      else {
        if (eof()) {
          fail("\\p must be followed by a property name or {name}");
        }
        name = pattern_.substr(pos_, 1);
        ++pos_;
      }
      if (name.empty()) {
        fail("empty Unicode property name in \\p{}");
      }
      return resolve_property(name);
    }
 
    constexpr void property_ascii_high(const std::vector<code_range>& table,
                                       char_class&                    ascii,
                                       std::vector<code_range>&       high) const
    {
      for (char32_t c = 0; c < 0x80U; ++c) {
        if (cp_in_ranges(table, c)) {
          ascii.set(static_cast<std::uint8_t>(c));
        }
      }
      for (const code_range& r : table) {
        if (r.hi < 0x80U) {
          continue; // wholly ASCII: already in the bitmap
        }
        high.push_back({.lo = r.lo < 0x80U ? 0x80U : r.lo, .hi = r.hi});
      }
    }
 
    constexpr std::int32_t parse_unicode_property(ast& out,
                                                  bool negated)
    {
      const std::vector<code_range> table {parse_property_table()};
      char_class                    ascii;
      std::vector<code_range>       high;
      property_ascii_high(table, ascii, high);
      return add_class_node(out, ascii, negated, high, /*codepoint_predicate=*/ true);
    }
 
    constexpr void merge_unicode_property(char_class&                    klass,
                                          std::vector<code_range>&       ranges,
                                          const std::vector<code_range>& table,
                                          bool                           negated,
                                          bool&                          property_derived) const
    {
      char_class              ascii;
      std::vector<code_range> high;
      property_ascii_high(table, ascii, high);
      if (negated) {
        ascii.invert_ascii();
        klass.merge(ascii);
        const std::vector<code_range> comp {complement_code_ranges(high)};
        ranges.insert(ranges.end(), comp.begin(), comp.end());
      }
      else {
        klass.merge(ascii);
        ranges.insert(ranges.end(), high.begin(), high.end());
      }
      property_derived = true;
    }
 
    constexpr std::int32_t parse_alternation(ast& out)
    {
      const std::int32_t first {parse_sequence(out)};
      if (eof() || peek() != '|') {
        return first;
      }
      std::int32_t last {first};
      while (accept('|')) {
        const std::int32_t branch {parse_sequence(out)}; // may be empty
        out.nodes[static_cast<std::size_t>(last)].next = branch;
        last                                           = branch;
      }
      const std::int32_t alt                         = add_node(out, {.kind = node_kind::alternation});
      out.nodes[static_cast<std::size_t>(alt)].child = first;
      return alt;
    }
 
    constexpr std::int32_t parse_sequence(ast& out)
    {
      std::int32_t first {-1};
      std::int32_t last  {-1};
      while (true) {
        skip_insignificant(); // verbose: between elements and before '|' / ')'
        if (eof() || peek() == '|' || peek() == ')') {
          break;
        }
        std::int32_t atom {parse_atom(out)};
        skip_insignificant(); // verbose: whitespace between an atom and its quantifier
        atom = parse_quantifier(out, atom);
        if (first == -1) {
          first = atom;
        }
        else {
          out.nodes[static_cast<std::size_t>(last)].next = atom;
        }
        last = atom;
      }
      if (first == -1) {
        return add_node(out, {.kind = node_kind::empty});
      }
      if (out.nodes[static_cast<std::size_t>(first)].next == -1) {
        return first; // single atom: no concat wrapper needed
      }
      const std::int32_t seq                         = add_node(out, {.kind = node_kind::concat});
      out.nodes[static_cast<std::size_t>(seq)].child = first;
      return seq;
    }
 
    constexpr std::int32_t parse_atom(ast& out)
    {
      const char ch {peek()};
      switch (ch) {
        case '*':
        case '+':
        case '?':
          fail("nothing to repeat");
        case '^':
          ++pos_;
          return add_node(out, {.kind = node_kind::anchor, .anchor = anchor_kind::caret});
        case '$':
          ++pos_;
          return add_node(out, {.kind = node_kind::anchor, .anchor = anchor_kind::dollar});
        case '(':
          return parse_group(out);
        case ')':
          fail("unbalanced parenthesis");
        case '.':
          ++pos_;
          return add_node(out, {.kind = node_kind::any});
        case '[':
          return parse_class(out);
        case '\\':
          return parse_escape(out);
        default:
          {
            // In code-point mode a raw non-ASCII byte begins a UTF-8 sequence: decode the WHOLE
            // code point and emit it as one atom (the same emission as `\uHHHH`), so a following
            // quantifier applies to the code point, not just its last byte (the é+ bug). A malformed
            // sequence is a pattern error, not a silent literal. In bytes mode, and for ASCII, a raw
            // byte stays a single byte node (so the compat layer's bytes|ecma path is unchanged).
            if (!bytes_ && static_cast<std::uint8_t>(ch) >= 0x80U) {
              const detail::decoded_codepoint decoded {detail::decode_codepoint_strict(pattern_, pos_)};
              if (!decoded.valid) {
                fail("invalid UTF-8 byte in pattern");
              }
              pos_ += decoded.length;
              return emit_literal_codepoint(out, static_cast<std::int32_t>(decoded.cp));
            }
            // Like Python: lone '{', ']' and '}' are ordinary characters.
            ++pos_;
            return emit_literal_codepoint(out, static_cast<std::uint8_t>(ch));
          }
      }
    }
 
    constexpr std::int32_t parse_quantifier(ast&         out,
                                            std::int32_t atom)
    {
      if (eof()) {
        return atom;
      }
      // Like Python: a bare anchor cannot be repeated ((?:^)* is fine).
      if (out.nodes[static_cast<std::size_t>(atom)].kind == node_kind::anchor &&
          (peek() == '*' || peek() == '+' || peek() == '?' || peek() == '{')) {
        std::int32_t ignored_min {};
        std::int32_t ignored_max {-1};
        if (peek() != '{' || try_parse_braces(ignored_min, ignored_max)) {
          fail("nothing to repeat");
        }
      }
      std::int32_t min {};
      std::int32_t max {-1};
      switch (peek()) {
        case '*':
          ++pos_;
          break;
        case '+':
          ++pos_;
          min = 1;
          break;
        case '?':
          ++pos_;
          max = 1;
          break;
        case '{':
          if (!try_parse_braces(min, max)) {
            return atom; // literal '{': handled as the next atom
          }
          break;
        default:
          return atom;
      }
      const bool lazy {accept('?')};
      if (!eof()) {
        const char   ch          {peek()};
        std::int32_t ignored_min {};
        std::int32_t ignored_max {-1};
        if (ch == '*' || ch == '+' || ch == '?' ||
            (ch == '{' && try_parse_braces(ignored_min, ignored_max))) {
          fail("multiple repeat");
        }
      }
      return add_node(out, {.kind = node_kind::repeat, .lazy = lazy, .min = min, .max = max, .child = atom});
    }
 
    constexpr bool try_parse_braces(std::int32_t& min,
                                    std::int32_t& max)
    {
      const std::size_t saved_pos   {pos_};
      ++pos_; // consume '{'
      const std::int32_t repeat_min {parse_repeat_count()};
      std::int32_t       repeat_max {repeat_min};
      bool               has_comma  {};
      if (accept(',')) {
        has_comma  = true;
        repeat_max = parse_repeat_count();
      }
      if (!accept('}') || (repeat_min < 0 && repeat_max < 0)) {
        pos_ = saved_pos;
        return false; // "{", "{}", "{,}", "{x"…: literal text
      }
      min = repeat_min < 0 ? 0 : repeat_min;
      max = (has_comma && repeat_max < 0) ? -1 : repeat_max;
      if (max != -1 && max < min) {
        pos_ = saved_pos;
        fail("min repeat greater than max repeat");
      }
      return true;
    }
 
    constexpr std::int32_t parse_repeat_count()
    {
      std::int32_t value {-1};
      while (!eof() && peek() >= '0' && peek() <= '9') {
        value = value < 0 ? 0 : value;
        value = (value * 10) + (peek() - '0');
        if (value > max_repeat_count) {
          fail("repetition count too large");
        }
        ++pos_;
      }
      return value;
    }
 
    constexpr void expect(char        ch,
                          const char* message)
    {
      if (!accept(ch)) {
        fail(message);
      }
    }
 
    static constexpr flags flag_for_letter(char letter)
    {
      switch (letter) {
        case 'i':
          return flags::icase;
        case 'm':
          return flags::multiline;
        case 's':
          return flags::dotall;
        case 'x':
          return flags::verbose;
        case 'a': // ASCII mode: `\d \w \s \b` stay ASCII, icase folds ASCII only.
          return flags::ascii;
        default:
          return flags::none;
      }
    }
 
    static constexpr bool is_flag_letter(char letter)
    {
      return letter == 'i' || letter == 'm' || letter == 's' || letter == 'a' || letter == 'x';
    }
 
    static constexpr flags without(flags value,
                                   flags bit)
    {
      return static_cast<flags>(
        static_cast<std::uint8_t>(static_cast<unsigned>(value) & ~static_cast<unsigned>(bit)));
    }
 
    constexpr bool parse_global_flags_prefix(ast& out)
    {
      const std::size_t saved_pos {pos_};
      if (!accept('(') || !accept('?')) {
        pos_ = saved_pos;
        return false;
      }
      flags found      {flags::none};
      bool  any_letter {};
      while (!eof() && is_flag_letter(peek())) {
        found      = found | flag_for_letter(peek());
        any_letter = true;
        ++pos_;
      }
      if (!any_letter || !accept(')')) {
        pos_ = saved_pos; // some other (?...) construct: let parse_group decide
        return false;
      }
      out.inline_flags = out.inline_flags | found;
      // A leading (?flags) group sets the base scope, so the rest of the pattern is parsed under it —
      // verbose affects tokenization, icase/ascii affect literal folding and the \w\d\s tables. This
      // mirrors the constructor flags, which seed the same base scope.
      flag_scopes_.back() = flag_scopes_.back() | found;
      return true;
    }
 
    constexpr std::int32_t parse_group(ast& out)
    {
      const std::size_t open_pos {pos_};
      if (++depth_ > max_nesting_depth) {
        fail("pattern nesting too deep");
      }
      ++pos_;                            // consume '('
      std::int32_t group        {-1};
      bool         scoped_flags {false}; 
      if (accept('?')) {
        if (accept('#')) {
          // (?#...) comment: skip to the first ')' (a backslash is not special here, like re);
          // emits nothing. Works the same in verbose and non-verbose mode.
          while (!eof() && peek() != ')') {
            ++pos_;
          }
          if (!accept(')')) {
            pos_ = open_pos;
            fail("missing ), unterminated comment");
          }
          --depth_;
          return add_node(out, {.kind = node_kind::empty});
        }
        if (accept(':')) {
          // non-capturing
        }
        else if (accept('P')) {
          if (accept('<')) {
            group = new_group(out, open_pos);
            parse_group_name(out, group);
          }
          else if (!eof() && peek() == '=') {
            fail_unsupported("named backreferences are not supported");
          }
          else {
            fail("unknown extension");
          }
        }
        else if (accept('<')) {
          if (!eof() && (peek() == '=' || peek() == '!')) {
            return parse_lookaround(out, look_dir::behind, open_pos);
          }
          group = new_group(out, open_pos);
          parse_group_name(out, group);
        }
        else if (!eof() && (peek() == '=' || peek() == '!')) {
          return parse_lookaround(out, look_dir::ahead, open_pos);
        }
        else if (!eof() && peek() == '>') {
          fail("atomic groups are not supported");
        }
        else if (!eof() && peek() == '(') {
          fail("conditional groups are not supported");
        }
        else if (!eof() && (is_flag_letter(peek()) || peek() == '-')) {
          // (?flags:...) / (?-flags:...) / (?flags-flags:...) — a scoped-flags group. Parse the
          // added flags, an optional '-' and the removed flags.
          flags added   {flags::none};
          flags removed {flags::none};
          while (!eof() && is_flag_letter(peek())) {
            added = added | flag_for_letter(peek());
            ++pos_;
          }
          if (accept('-')) {
            bool saw_negative {false};
            while (!eof() && is_flag_letter(peek())) {
              removed      = removed | flag_for_letter(peek());
              saw_negative = true;
              ++pos_;
            }
            if (!saw_negative) {
              fail("missing flag after '-'");
            }
          }
          if (!accept(':')) {
            // An unscoped (?flags) is only legal at the very start of the pattern (consumed by
            // parse_global_flags_prefix); anything else here is a misplaced global-flags group.
            fail("global flags not at the start of the expression");
          }
          // Every inline flag (i m s x a) is honoured per scope: verbose changes tokenization, icase/
          // ascii govern folding and the \w\d\s tables, dotall the dot, multiline the ^/$ anchors — all
          // read from the scope stack. The added set is applied and the removed set cleared for the body.
          flag_scopes_.push_back(without(current_flags() | added, removed));
          scoped_flags = true; // group stays non-capturing (-1)
        }
        else {
          fail("unknown extension");
        }
      }
      else {
        group = new_group(out, open_pos);
      }
      const std::int32_t body {parse_alternation(out)};
      if (scoped_flags) {
        flag_scopes_.pop_back(); // the scoped flags apply only to the body just parsed
      }
      if (!accept(')')) {
        pos_ = open_pos;
        fail("missing ), unterminated subpattern");
      }
      --depth_;
      return add_node(out, {.kind = node_kind::group, .group = group, .child = body});
    }
 
    constexpr std::int32_t parse_lookaround(ast&        out,
                                            look_dir    direction,
                                            std::size_t open_pos)
    {
      if (in_lookaround_) {
        fail_unsupported("nested lookaround is not supported");
      }
      const bool negative {peek() == '!'};
      ++pos_; // consume '=' or '!'
      in_lookaround_         = true;
      const std::int32_t sub {parse_alternation(out)};
      in_lookaround_         = false;
      if (!accept(')')) {
        pos_ = open_pos;
        fail("missing ), unterminated subpattern");
      }
      --depth_;
      return add_node(out, {.kind      = node_kind::lookaround,
                            .negated   = negative,
                            .direction = direction,
                            .child     = sub});
    }
 
    constexpr std::int32_t new_group(ast&        out,
                                     std::size_t open_pos)
    {
      if (out.group_count >= max_group_count) {
        pos_ = open_pos;
        fail("too many capture groups");
      }
      return ++out.group_count;
    }
 
    static constexpr bool is_name_start(char ch)
    {
      return ch == '_' || (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');
    }
 
    constexpr void parse_group_name(ast&         out,
                                    std::int32_t group)
    {
      const std::size_t begin {pos_};
      if (eof() || !is_name_start(peek())) {
        fail("bad character in group name");
      }
      while (!eof() && (is_ascii_alnum(peek()) || peek() == '_')) {
        ++pos_;
      }
      const std::size_t end {pos_};
      expect('>', "bad character in group name");
      for (const named_group& existing : out.names) {
        const std::string_view name    {pattern_.substr(begin, end - begin)};
        const auto             e_begin {static_cast<std::size_t>(existing.begin)};
        const auto             e_end   {static_cast<std::size_t>(existing.end)};
        if (pattern_.substr(e_begin, e_end - e_begin) == name) {
          fail("redefinition of group name");
        }
      }
      out.names.push_back({.group = group,
                           .begin = static_cast<std::int32_t>(begin),
                           .end   = static_cast<std::int32_t>(end)});
    }
 
    constexpr std::int32_t parse_byte_escape()
    {
      const char ch {peek()};
      if (ch >= '0' && ch <= '9') {
        return parse_digit_escape(); // octal byte, or a rejected back-reference
      }
      switch (ch) {
        case 'n':
          ++pos_;
          return '\n';
        case 't':
          ++pos_;
          return '\t';
        case 'r':
          ++pos_;
          return '\r';
        case 'f':
          ++pos_;
          return '\f';
        case 'v':
          ++pos_;
          return '\v';
        case 'a':
          ++pos_;
          // REAL/Python `\a` is the bell (0x07). ECMAScript has no `\a` escape — it is an identity
          // escape (the literal 'a'). Gate under ecma; `\n \t \r \f \v` are ECMAScript ControlEscapes
          // and stay unchanged. This covers both contexts (parse_byte_escape is shared with classes).
          if (ecma_) { return 'a'; }
          return '\a';
        case 'x':
          {
            ++pos_;
            const std::int32_t high_nibble {hex_digit()};
            const std::int32_t low_nibble  {hex_digit()};
            return (high_nibble * 16) + low_nibble; // arithmetic, not signed bitwise (MISRA)
          }
        default:
          // Any escaped ASCII punctuation is that literal character.
          if (static_cast<std::uint8_t>(ch) < 0x80 && !is_ascii_alnum(ch)) {
            ++pos_;
            return static_cast<std::uint8_t>(ch);
          }
          return -1;
      }
    }
 
    constexpr std::int32_t parse_digit_escape()
    {
      const digit_escape_result decoded {decode_digit_escape(pattern_, pos_)};
      pos_ += decoded.length;
      if (decoded.kind == digit_escape_kind::octal) {
        return static_cast<std::int32_t>(decoded.value); // a single byte, like \xHH
      }
      if (decoded.kind == digit_escape_kind::octal_overflow) {
        fail("octal escape value outside of range 0-0o377");
      }
      fail_unsupported("backreferences are not supported"); // a decimal group number = a back-reference
    }
 
    constexpr std::int32_t hex_digit()
    {
      if (eof()) {
        fail("invalid \\x escape: expected two hex digits");
      }
      const char ch {peek()};
      ++pos_;
      if (ch >= '0' && ch <= '9') {
        return ch - '0';
      }
      if (ch >= 'a' && ch <= 'f') {
        return ch - 'a' + 10;
      }
      if (ch >= 'A' && ch <= 'F') {
        return ch - 'A' + 10;
      }
      --pos_;
      fail("invalid \\x escape: expected two hex digits");
    }
 
    constexpr std::int32_t parse_unicode_codepoint(bool capital)
    {
      if (bytes_) {
        fail("\\u and \\U escapes are not allowed in bytes patterns");
      }
      const int    width {capital ? 8 : 4};
      std::int32_t value {};
      for (int i = 0; i < width; ++i) {
        std::int32_t digit {-1};
        if (!eof()) {
          const char ch {peek()};
          if (ch >= '0' && ch <= '9') {
            digit = ch - '0';
          }
          else if (ch >= 'a' && ch <= 'f') {
            digit = (ch - 'a') + 10;
          }
          else if (ch >= 'A' && ch <= 'F') {
            digit = (ch - 'A') + 10;
          }
        }
        if (digit < 0) {
          fail(capital ? "invalid \\U escape: expected 8 hex digits"
                       : "invalid \\u escape: expected 4 hex digits");
        }
        value = (value * 16) + digit;
        ++pos_;
      }
      if (value >= 0xD800 && value <= 0xDFFF) {
        fail("invalid Unicode escape: surrogate code point");
      }
      if (value > 0x10FFFF) {
        fail("invalid Unicode escape: code point out of range");
      }
      return value;
    }
 
    constexpr std::int32_t parse_named_codepoint()
    {
      if (bytes_) {
        fail("\\N escapes are not allowed in bytes patterns");
      }
      if (eof() || peek() != '{') {
        fail("expected '{' after \\N (\\N{U+XXXX})");
      }
      ++pos_; // consume '{'
      if (eof() || peek() != 'U') {
        fail("\\N{...} takes a U+XXXX code point; a character name is resolved by the Python binding");
      }
      ++pos_; // consume 'U'
      if (eof() || peek() != '+') {
        fail("expected '+' in \\N{U+XXXX}");
      }
      ++pos_; // consume '+'
      std::int32_t value {};
      int          count {};
      while (!eof() && count < 6) {
        const char   ch    {peek()};
        std::int32_t digit {-1};
        if (ch >= '0' && ch <= '9') {
          digit = ch - '0';
        }
        else if (ch >= 'a' && ch <= 'f') {
          digit = (ch - 'a') + 10;
        }
        else if (ch >= 'A' && ch <= 'F') {
          digit = (ch - 'A') + 10;
        }
        if (digit < 0) {
          break;
        }
        value = (value * 16) + digit;
        ++pos_;
        ++count;
      }
      if (count == 0) {
        fail("expected 1 to 6 hex digits in \\N{U+XXXX}");
      }
      if (eof() || peek() != '}') {
        fail("unterminated \\N{U+XXXX} (expected '}')");
      }
      ++pos_; // consume '}'
      if (value >= 0xD800 && value <= 0xDFFF) {
        fail("invalid \\N escape: surrogate code point");
      }
      if (value > 0x10FFFF) {
        fail("invalid \\N escape: code point out of range");
      }
      return value;
    }
 
    constexpr std::int32_t emit_codepoint_utf8(ast&         out,
                                               std::int32_t cp)
    {
      const auto value {static_cast<std::uint32_t>(cp)};
      if (value < 0x80U) {
        return add_node(out, {.kind = node_kind::byte, .byte = static_cast<std::uint8_t>(value)});
      }
      std::int32_t first {-1};
      std::int32_t last  {-1};
      const auto   emit_byte {[&](std::uint8_t one) {
                                const std::int32_t node {add_node(out, {.kind = node_kind::byte, .byte = one})};
                                if (first < 0) {
                                  first = node;
                                }
                                else {
                                  out.nodes[static_cast<std::size_t>(last)].next = node;
                                }
                                last = node;
                              }};
      if (value < 0x800U) {
        emit_byte(static_cast<std::uint8_t>(0xC0U | (value >> 6U)));
        emit_byte(static_cast<std::uint8_t>(0x80U | (value & 0x3FU)));
      }
      else if (value < 0x10000U) {
        emit_byte(static_cast<std::uint8_t>(0xE0U | (value >> 12U)));
        emit_byte(static_cast<std::uint8_t>(0x80U | ((value >> 6U) & 0x3FU)));
        emit_byte(static_cast<std::uint8_t>(0x80U | (value & 0x3FU)));
      }
      else {
        emit_byte(static_cast<std::uint8_t>(0xF0U | (value >> 18U)));
        emit_byte(static_cast<std::uint8_t>(0x80U | ((value >> 12U) & 0x3FU)));
        emit_byte(static_cast<std::uint8_t>(0x80U | ((value >> 6U) & 0x3FU)));
        emit_byte(static_cast<std::uint8_t>(0x80U | (value & 0x3FU)));
      }
      const std::int32_t seq {add_node(out, {.kind = node_kind::concat})};
      out.nodes[static_cast<std::size_t>(seq)].child = first;
      return seq;
    }
 
    constexpr std::int32_t emit_literal_codepoint(ast&         out,
                                                  std::int32_t cp)
    {
      if (is_icase()) {
        const bool ascii_letter {(cp >= 'A' && cp <= 'Z') || (cp >= 'a' && cp <= 'z')};
        if (ascii_letter) {
          char_class bitmap;
          bitmap.set(static_cast<std::uint8_t>(cp));
          return add_class_node(out, bitmap, false);
        }
        if (!bytes_ && cp >= 0x80 &&
            detail::find_fold_index(static_cast<std::uint32_t>(cp)) != detail::unicode_fold_table_size) {
          const std::vector<code_range> single {
            {.lo = static_cast<std::uint32_t>(cp), .hi = static_cast<std::uint32_t>(cp)}};
          return add_class_node(out, char_class {}, false, single);
        }
      }
      // Not promoted: a raw byte (ASCII, or any byte in bytes mode) is a byte node; a non-ASCII
      // code point in text mode is emitted as its UTF-8 bytes.
      if (bytes_ || cp < 0x80) {
        return add_node(out, {.kind = node_kind::byte, .byte = static_cast<std::uint8_t>(cp)});
      }
      return emit_codepoint_utf8(out, cp);
    }
 
    constexpr std::int32_t parse_escape(ast& out)
    {
      ++pos_; // consume the backslash
      if (eof()) {
        fail("dangling backslash");
      }
      switch (peek()) {
        // A bare shorthand in text mode (not bytes, not re.A) is emitted as a match-time code-point
        // predicate (klass_cp): O(decode + range bsearch) per position, independent of the range count.
        // In bytes / ASCII mode shorthand_ranges() is empty and the flag is off -> the ASCII byte-NFA.
        case 'd':
        case 'D':
        case 'w':
        case 'W':
        case 's':
        case 'S': {
            const shorthand_spec sc {shorthand_class(peek())};
            ++pos_;
            return add_class_node(out, sc.set, sc.negated, shorthand_ranges(sc.ranges), text_shorthand());
          }
        // `\p{Name}` / `\P{Name}` / `\pX` — Unicode General_Category and Script property classes (text mode).
        case 'p':
        case 'P':
          return parse_unicode_property(out, peek() == 'P');
        // `\A \Z < >` are REAL extensions (text-start/end, word-start/end). ECMAScript has no
        // such escapes — they are identity escapes (the literal character). Under the ecma flag
        // (the std-compat layer), emit the literal; otherwise keep REAL's anchor. `\b`/`\B` are
        // standard word boundaries in both and stay unchanged.
        case 'A':
          ++pos_;
          // ecma: `\A` is the literal 'A' (Annex B identity escape); a cased letter, so it folds under icase.
          if (ecma_) {
            return emit_literal_codepoint(out, 'A');
          }
          return add_node(out, {.kind = node_kind::anchor, .anchor = anchor_kind::text_start});
        case 'Z':
          ++pos_;
          if (ecma_) {
            return emit_literal_codepoint(out, 'Z'); // ecma: literal 'Z', folds under icase
          }
          return add_node(out, {.kind = node_kind::anchor, .anchor = anchor_kind::text_end});
        case 'z':
          // `\z` is an exact alias of `\Z` (end of the text, no MULTILINE interaction) — Python 3.14
          // added it with that meaning. Same anchor, so it is byte-identical to `\Z`.
          ++pos_;
          if (ecma_) {
            return emit_literal_codepoint(out, 'z'); // ecma: literal 'z' (identity escape), folds under icase
          }
          return add_node(out, {.kind = node_kind::anchor, .anchor = anchor_kind::text_end});
        case 'b':
          ++pos_;
          return add_node(out, {.kind = node_kind::anchor, .anchor = anchor_kind::word_boundary});
        case 'B':
          ++pos_;
          return add_node(out, {.kind = node_kind::anchor, .anchor = anchor_kind::not_word_boundary});
        case '<':
          ++pos_;
          if (ecma_) {
            return emit_literal_codepoint(out, '<'); // ecma: literal '<' (non-cased -> a plain byte)
          }
          return add_node(out, {.kind = node_kind::anchor, .anchor = anchor_kind::word_start});
        case '>':
          ++pos_;
          if (ecma_) {
            return emit_literal_codepoint(out, '>'); // ecma: literal '>'
          }
          return add_node(out, {.kind = node_kind::anchor, .anchor = anchor_kind::word_end});
        case 'u':
          ++pos_;
          return emit_literal_codepoint(out, parse_unicode_codepoint(false));
        case 'U':
          ++pos_;
          return emit_literal_codepoint(out, parse_unicode_codepoint(true));
        case 'N':
          ++pos_;
          return emit_literal_codepoint(out, parse_named_codepoint());
        default:
          {
            const std::int32_t byte_value {parse_byte_escape()};
            if (byte_value < 0) {
              fail_unsupported("unsupported escape sequence");
            }
            // A `\xHH` / octal escape with value < 0x80 is an ASCII character (byte == code point): a
            // cased one folds under icase like a raw ASCII literal (`\x4B` == `K`). A value >= 0x80
            // keeps byte provenance and is never folded — the documented text-mode divergence.
            if (byte_value < 0x80) {
              return emit_literal_codepoint(out, byte_value);
            }
            return add_node(out, {.kind = node_kind::byte, .byte = static_cast<std::uint8_t>(byte_value)});
          }
      }
    }
 
    constexpr std::int32_t parse_class_item(char_class&               klass,
                                            std::vector<code_range>&  ranges,
                                            bool&                     property_derived)
    {
      const char ch {peek()};
      if (static_cast<std::uint8_t>(ch) >= 0x80) {
        // bytes mode keeps rejecting non-ASCII in a class (the compat layer relies on that rejection
        // to fall back to std). Code-point mode decodes the whole code point as a class member.
        if (bytes_) {
          fail("non-ASCII character class member not supported");
        }
        const detail::decoded_codepoint decoded {detail::decode_codepoint_strict(pattern_, pos_)};
        if (!decoded.valid) {
          fail("invalid UTF-8 byte in character class");
        }
        pos_ += decoded.length;
        return static_cast<std::int32_t>(decoded.cp); // a code point (may be >= 0x80)
      }
      if (ch != '\\') {
        ++pos_;
        return static_cast<std::uint8_t>(ch);
      }
      ++pos_; // consume the backslash
      if (eof()) {
        fail("dangling backslash");
      }
      switch (peek()) {
        case 'd':
        case 'D':
        case 'w':
        case 'W':
        case 's':
        case 'S': {
            const shorthand_spec sc {shorthand_class(peek())};
            ++pos_;
            merge_property(klass, ranges, sc.set, sc.ranges, sc.negated, property_derived);
            return -1;
          }
        // `\p{Name}` / `\P{Name}` / `\pX` inside a class — a Unicode General_Category / Script property member.
        case 'p':
        case 'P': {
            const bool                    negated {peek() == 'P'};
            const std::vector<code_range> table   {parse_property_table()};
            merge_unicode_property(klass, ranges, table, negated, property_derived);
            return -1;
          }
        case 'b':
          ++pos_;
          return 0x08; // backspace, only inside classes
        case 'u':
        case 'U':
          {
            const bool capital {peek() == 'U'};
            ++pos_;
            // A non-ASCII code point is now a valid class member (code-point mode); `parse_unicode_codepoint`
            // already rejects `\u`/`\U` in bytes mode, so a class in bytes mode still has ASCII-only members.
            return parse_unicode_codepoint(capital);
          }
        case 'N':
          ++pos_;
          return parse_named_codepoint(); // \N{U+XXXX} is a valid class member (a code point)
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
          {
            // Inside a class every `\digit` is octal — there are no back-references in a class (re's
            // rule). Up to 3 octal digits; a value above 0o377 (255) is out of range, as in re. The
            // first non-octal digit ends the escape, so `[\18]` is `\x01` then a literal '8'.
            unsigned    value {};
            std::size_t taken {};
            while (taken < 3 && !eof() && peek() >= '0' && peek() <= '7') {
              value = (value * 8U) + static_cast<unsigned>(peek() - '0');
              ++pos_;
              ++taken;
            }
            if (value > 0xFFU) {
              fail("octal escape value out of range (\\0 to \\377)");
            }
            return static_cast<std::int32_t>(value);
          }
        case '8':
        case '9':
          fail("invalid escape (\\8 and \\9 are not octal and there are no back-references in a class)");
        default:
          {
            const std::int32_t byte_value {parse_byte_escape()};
            if (byte_value < 0) {
              fail_unsupported("unsupported escape sequence");
            }
            return byte_value;
          }
      }
    }
 
    constexpr std::int32_t parse_class(ast& out)
    {
      const std::size_t open_pos      {pos_};
      ++pos_;                                      // consume '['
      const bool              negated {accept('^')};
      char_class              klass;
      std::vector<code_range> ranges;              // non-ASCII members (code-point mode); empty in bytes/ASCII-only classes
      bool                    property_derived {}; // a \w/\d/\s (text mode) contributed -> emit as klass_cp
      bool                    first            {true};
      // Add one member. In bytes mode a member >= 0x80 (from `\xHH`) is a raw byte in the bitmap, NOT
      // a code point — so class_ranges stays empty and a bytes-mode class is byte-for-byte a
      // std::basic_regex<char> class (what the compat layer relies on). In code-point mode, >= 0x80 is
      // a (degenerate) code-point range.
      const auto add_cp {[&](std::int32_t cp) {
                           if (bytes_ || cp < 0x80) {
                             klass.set(static_cast<std::uint8_t>(cp));
                           }
                           else {
                             ranges.push_back({static_cast<std::uint32_t>(cp), static_cast<std::uint32_t>(cp)});
                           }
                         }};
      // Add an inclusive range [lo, hi]. Bytes mode: the whole range is bytes in the bitmap.
      // Code-point mode: a range crossing 0x7F/0x80 splits (the ASCII part -> bitmap).
      const auto add_range {[&](std::int32_t lo, std::int32_t hi) {
                              if (bytes_) {
                                klass.set_range(static_cast<std::uint8_t>(lo), static_cast<std::uint8_t>(hi));
                              }
                              else if (lo < 0x80) {
                                klass.set_range(static_cast<std::uint8_t>(lo), static_cast<std::uint8_t>(hi < 0x80 ? hi : 0x7F));
                                if (hi >= 0x80) {
                                  ranges.push_back({0x80U, static_cast<std::uint32_t>(hi)});
                                }
                              }
                              else {
                                ranges.push_back({static_cast<std::uint32_t>(lo), static_cast<std::uint32_t>(hi)});
                              }
                            }};
      while (true) {
        if (eof()) {
          pos_ = open_pos;
          fail("unterminated character class");
        }
        // Python (default): a ']' right after '[' or '[^' is a literal member, so `[]`/`[^]`
        // continue. ECMAScript (ecma): ']' always closes — `[]` is the empty class (matches
        // nothing) and `[^]` is its negation (matches any character, the "any incl. newline" idiom).
        if (peek() == ']' && (!first || ecma_)) {
          ++pos_;
          break;
        }
        first = false;
        const std::size_t  item_pos     {pos_};
        const std::int32_t range_start  {parse_class_item(klass, ranges, property_derived)};
        if (range_start < 0) {
          continue; // set item (e.g. \d): its bitmap and any Unicode ranges are already merged
        }
        // Possible range: 'x-y', where a trailing '-]' is a literal '-'.
        if (!eof() && peek() == '-' && pos_ + 1 < pattern_.size() &&
            pattern_[pos_ + 1] != ']') {
          ++pos_; // consume '-'
          const std::int32_t range_end {parse_class_item(klass, ranges, property_derived)};
          if (range_end < 0 || range_end < range_start) {
            pos_ = item_pos;
            fail("bad character range");
          }
          add_range(range_start, range_end);
        }
        else {
          add_cp(range_start);
        }
      }
      return add_class_node(out, klass, negated, ranges, property_derived);
    }
  };
 
  constexpr ast parse(std::string_view pattern,
                      flags            initial_flags = flags::none)
  {
    return parser(pattern, initial_flags).parse();
  }
} // namespace real::detail
 
#endif // REAL_AST_HPP