program.hpp

Go to the documentation of this file.

 
#ifndef REAL_PROGRAM_HPP
#define REAL_PROGRAM_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 <cstdint>
#include <exception>
#include <limits>
#include <span>
#include <string>
#include <vector>
 
#include "real/core/charclass.hpp"
 
namespace real {
 
  inline constexpr std::size_t npos {std::numeric_limits<std::size_t>::max()};
 
  enum class flags : std::uint8_t
  {
    none      = 0,        
    icase     = 1,        
    multiline = 2,        
    dotall    = 4,        
    bytes     = 8,        
    verbose   = 16,       
    ecma = 32,            
    ascii = 64,           
    dollar_endonly = 128, 
  };
 
  enum class match_semantics : std::uint8_t
  {
    first   = 0, 
    longest = 1, 
  };
 
  constexpr flags operator|(flags lhs,
                            flags rhs)
  {
    return static_cast<flags>(static_cast<std::uint8_t>(lhs) | static_cast<std::uint8_t>(rhs));
  }
 
  constexpr flags operator&(flags lhs,
                            flags rhs)
  {
    return static_cast<flags>(static_cast<std::uint8_t>(lhs) & static_cast<std::uint8_t>(rhs));
  }
 
  constexpr bool has_flag(flags value,
                          flags flag)
  {
    return (value & flag) != flags::none;
  }
 
  enum class error_kind : std::uint8_t
  {
    syntax,
    unsupported,
  };
 
  class regex_error : public std::exception
  {
  public:
 
    regex_error(const std::string& message,
                std::size_t        position,
                error_kind         kind = error_kind::syntax)
      : message_("regex_error at " + std::to_string(position) + ": " + message),
        position_(position),
        kind_(kind)
    {}
 
    [[nodiscard]] error_kind kind() const noexcept
    {
      return kind_;
    }
 
    [[nodiscard]] const char* what() const noexcept override
    {
      return message_.c_str();
    }
 
    [[nodiscard]] std::size_t position() const noexcept
    {
      return position_;
    }
 
  private:
 
    std::string message_;  
    std::size_t position_; 
    error_kind  kind_;     
  };
 
  namespace detail {
 
    struct code_range
    {
      std::uint32_t lo {}; 
      std::uint32_t hi {}; 
    };
 
    struct cp_class
    {
      char_class    ascii;          
      std::uint32_t range_begin {}; 
      std::uint32_t range_count {}; 
    };
 
    enum class opcode : std::uint8_t
    {
      byte,              
      klass,             
      klass_cp,          
      split,             
      jump,              
      save,              
      assert_position,   
      match,             
      assert_lookaround, 
    };
 
    enum class assert_kind : std::uint8_t
    {
      text_start,                
      text_end,                  
      text_end_or_final_newline, 
      line_start,                
      line_end,                  
      word_boundary,             
      not_word_boundary,         
      word_start,                
      word_end,                  
    };
 
    enum class look_dir : std::uint8_t
    {
      ahead,  
      behind, 
    };
 
    struct lookaround_sub
    {
      std::int32_t code_offset {};                
      std::int32_t code_length {};                
      std::int32_t l_max       {};                
      look_dir     direction   {look_dir::ahead}; 
      bool         negative    {};                
    };
 
    struct instr
    {
      opcode        op;                  
      std::uint8_t  arg8             {}; 
      std::uint16_t arg16            {}; 
      std::int32_t  primary_target   {}; 
      std::int32_t  secondary_target {}; 
    };
 
    struct pattern_hints
    {
      std::array<char, 16> prefix                {};   
      std::uint8_t         prefix_size           {};   
      bool                 anchored_start        {};   
      bool                 line_anchored         {};   
      bool                 first_bytes_valid     {};   
      bool                 empty_match_possible  {};   
      std::int16_t         single_first          {-1}; 
      char_class           first_bytes;                
      std::array<char, 4>  small_set             {};   
      std::uint8_t         small_set_size        {};   
      std::int32_t         greedy_class_loop     {-1}; 
      std::int32_t         greedy_cp_class       {-1}; 
      bool                 greedy_cp_class_plus  {};   
      std::int16_t         greedy_group_start    {-1}; 
      std::int16_t         greedy_group_end      {-1}; 
      bool                 fixed_shape           {};   
      std::int32_t         codepoint_class_ascii {-1}; 
      bool                 codepoint_class_plus  {};   
      bool                 fixed_alternation     {};   
 
      std::uint8_t exact_literal_len {};
 
      std::array<char, 6> stop_set      {};
      std::uint8_t        stop_set_size {}; 
 
      std::int16_t rare_byte   {-1};
      std::uint8_t rare_offset {}; 
 
      std::array<std::uint8_t, 16> inner_literal        {};
      std::uint8_t                 inner_literal_len    {};
      std::int32_t                 inner_literal_prefix {-1};
    };
 
    struct named_group
    {
      std::int32_t group {}; 
      std::int32_t begin {}; 
      std::int32_t end   {}; 
    };
 
    struct regex_immutables;
    struct program_view
    {
      std::span<const instr>          code;                   
      std::span<const char_class>     classes;                
      std::span<const named_group>    names;                  
      std::span<const lookaround_sub> lookarounds;            
      std::span<const cp_class>       cp_classes;             
      std::span<const code_range>     cp_ranges;              
      std::span<const instr>          prefix_code;            
      std::span<const char_class>     prefix_classes;         
      std::span<const cp_class>       prefix_cp_classes;      
      std::span<const code_range>     prefix_cp_ranges;       
      std::uint16_t                   slot_count   {2};       
      bool                            byte_mode    {};        
      bool                            unicode_word {};        
      pattern_hints                   hints;                  
      regex_immutables*               immut        {nullptr}; 
    };
 
    struct dynamic_program
    {
      std::vector<instr>          code;              
      std::vector<char_class>     classes;           
      std::vector<named_group>    names;             
      std::vector<lookaround_sub> lookarounds;       
      std::vector<cp_class>       cp_classes;        
      std::vector<code_range>     cp_ranges;         
      std::vector<instr>          prefix_code;       
      std::vector<char_class>     prefix_classes;    
      std::vector<cp_class>       prefix_cp_classes; 
      std::vector<code_range>     prefix_cp_ranges;  
      std::uint16_t               slot_count   {2};  
      bool                        byte_mode    {};   
      bool                        unicode_word {};   
      pattern_hints               hints;             
 
      // Codepoint-class marker, set by `emit_codepoint_class` at emission so the
      // prefilter need not reverse-engineer the emitted block's bytecode shape.
      std::int32_t codepoint_mark_ascii  {-1}; 
      std::int32_t codepoint_mark_offset {-1}; 
 
      [[nodiscard]] constexpr program_view view() const
      {
        return {.code              = std::span<const instr>(code),
                .classes           = std::span<const char_class>(classes),
                .names             = std::span<const named_group>(names),
                .lookarounds       = std::span<const lookaround_sub>(lookarounds),
                .cp_classes        = std::span<const cp_class>(cp_classes),
                .cp_ranges         = std::span<const code_range>(cp_ranges),
                .prefix_code       = std::span<const instr>(prefix_code),
                .prefix_classes    = std::span<const char_class>(prefix_classes),
                .prefix_cp_classes = std::span<const cp_class>(prefix_cp_classes),
                .prefix_cp_ranges  = std::span<const code_range>(prefix_cp_ranges),
                .slot_count        = slot_count,
                .byte_mode         = byte_mode,
                .unicode_word      = unicode_word,
                .hints             = hints};
      }
    };
  } // namespace detail
} // namespace real
 
#endif // REAL_PROGRAM_HPP