charclass.hpp

Go to the documentation of this file.

 
#ifndef REAL_CHARCLASS_HPP
#define REAL_CHARCLASS_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 <array>
#include <cstddef>
#include <cstdint>
 
namespace real::detail {
 
  struct char_class
  {
    std::array<std::uint64_t, 4> bits {}; 
 
    constexpr void set(std::uint8_t byte)
    {
      const unsigned bit {byte};
      bits[bit >> 6U] |= std::uint64_t {1} << (bit & 63U);
    }
 
    constexpr void set_range(std::uint8_t low,
                             std::uint8_t high)
    {
      if (low > high) {
        return; // callers pass low <= high (the parser rejects [z-a]); keeps the word math total
      }
      // Set whole 64-bit words at once (4 iterations) instead of looping byte by byte.
      for (unsigned word = 0; word < bits.size(); ++word) {
        const unsigned word_low  {word * 64U};
        const unsigned word_high {word_low + 63U};
        if (high < word_low || low > word_high) {
          continue; // this word holds no byte of [low, high]
        }
        const unsigned a {low > word_low ? low - word_low : 0U};     // first bit set, within the word
        const unsigned b {high < word_high ? high - word_low : 63U}; // last bit set, within the word
        bits[word] |= (b - a == 63U)
                      ? ~std::uint64_t {0}
                      : (((std::uint64_t {1} << (b - a + 1U)) - 1U) << a);
      }
    }
 
    constexpr void merge(const char_class& other)
    {
      for (std::size_t i = 0; i < bits.size(); ++i) {
        bits[i] |= other.bits[i];
      }
    }
 
    constexpr void invert_ascii()
    {
      bits[0] = ~bits[0];
      bits[1] = ~bits[1];
    }
 
    constexpr void invert()
    {
      for (auto& word : bits) {
        word = ~word;
      }
    }
 
    [[nodiscard]] constexpr bool test(std::uint8_t byte) const
    {
      const unsigned bit {byte};
      return ((bits[bit >> 6U] >> (bit & 63U)) & 1U) != 0;
    }
 
    [[nodiscard]] constexpr bool empty() const
    {
      return (bits[0] | bits[1] | bits[2] | bits[3]) == 0;
    }
 
    constexpr bool operator==(const char_class&) const = default;
  };
 
  constexpr void fold_ascii_case(char_class& klass)
  {
    for (std::uint8_t upper = 'A'; upper <= 'Z'; ++upper) {
      const auto lower {static_cast<std::uint8_t>(upper + 32)};
      if (klass.test(upper)) {
        klass.set(lower);
      }
      if (klass.test(lower)) {
        klass.set(upper);
      }
    }
  }
 
  [[nodiscard]] constexpr bool is_ascii_word_byte(std::uint8_t byte)
  {
    return (byte >= '0' && byte <= '9') || (byte >= 'A' && byte <= 'Z') ||
           (byte >= 'a' && byte <= 'z') || byte == '_';
  }
 
  constexpr char_class digit_set()
  {
    char_class result;
    result.set_range('0', '9');
    return result;
  }
 
  constexpr char_class word_set()
  {
    char_class result;
    result.set_range('0', '9');
    result.set_range('A', 'Z');
    result.set_range('a', 'z');
    result.set('_');
    return result;
  }
 
  constexpr char_class space_set()
  {
    char_class result;
    result.set(' ');
    result.set('\t');
    result.set('\n');
    result.set('\r');
    result.set('\f');
    result.set('\v');
    result.set(char {0x1C}); // FS  \ Python re \s also matches these four (str.isspace); the generated
    result.set(char {0x1D}); // GS  |  space_ranges lists U+001C-U+001F, the ASCII set must agree — the
    result.set(char {0x1E}); // RS  |  drift-guard test asserts it.
    result.set(char {0x1F}); // US /
    return result;
  }
 
  // --- UTF-8 byte-class sets -------------------------------------------------
  // The single source of truth for how `.` and negated classes expand to bytes:
  // the compiler emits these sets (compiler.hpp) and the prefilter recognizes
  // the same shape (prefilter.hpp). Keeping them here keeps the two in lock-step.
 
  constexpr char_class utf8_cont_set()
  {
    char_class result;
    result.set_range(0x80, 0xBF);
    return result;
  }
 
  constexpr char_class utf8_lead2_set()
  {
    char_class result;
    result.set_range(0xC2, 0xDF);
    return result;
  }
 
  constexpr char_class utf8_lead3_set()
  {
    char_class result;
    result.set_range(0xE0, 0xEF);
    return result;
  }
 
  constexpr char_class utf8_lead4_set()
  {
    char_class result;
    result.set_range(0xF0, 0xF4);
    return result;
  }
} // namespace real::detail
 
#endif // REAL_CHARCLASS_HPP