kakoune

Fork of kakoune, an acceptable text editor
git clone git://git.laack.co/kakoune.git
Log | Files | Refs

regex.hh (8758B)


      1 #ifndef regex_hh_INCLUDED
      2 #define regex_hh_INCLUDED
      3 
      4 #include "string.hh"
      5 #include "regex_vm.hh"
      6 #include "ref_ptr.hh"
      7 
      8 namespace Kakoune
      9 {
     10 
     11 // Regex that keeps track of its string representation
     12 class Regex
     13 {
     14 public:
     15     Regex() = default;
     16 
     17     explicit Regex(StringView re, RegexCompileFlags flags = RegexCompileFlags::None);
     18     bool empty() const { return m_str.empty(); }
     19     bool operator==(const Regex& other) const { return m_str == other.m_str; }
     20 
     21     const String& str() const { return m_str; }
     22 
     23     size_t mark_count() const { return m_impl->save_count / 2 - 1; }
     24     int named_capture_index(StringView name) const;
     25 
     26     static constexpr const char* option_type_name = "regex";
     27 
     28     const CompiledRegex* impl() const { return m_impl.get(); }
     29 
     30 private:
     31     struct Impl : RefCountable, CompiledRegex {};
     32 
     33     RefPtr<Impl> m_impl;
     34     String m_str;
     35 };
     36 
     37 template<typename Iterator>
     38 struct MatchResults
     39 {
     40     struct SubMatch : std::pair<Iterator, Iterator>
     41     {
     42         SubMatch() = default;
     43         SubMatch(Iterator begin, Iterator end)
     44             : std::pair<Iterator, Iterator>{begin, end}, matched{static_cast<bool>(begin)}
     45         {}
     46 
     47         bool matched = false;
     48     };
     49 
     50     struct iterator
     51     {
     52         using difference_type = size_t;
     53         using value_type = SubMatch;
     54         using pointer = SubMatch*;
     55         using reference = SubMatch;
     56         using iterator_category = std::bidirectional_iterator_tag;
     57         using It = typename Vector<Iterator, MemoryDomain::Regex>::const_iterator;
     58 
     59         iterator() = default;
     60         iterator(It it) : m_it{std::move(it)} {}
     61 
     62         iterator& operator--() { m_it += 2; return *this; }
     63         iterator& operator++() { m_it += 2; return *this; }
     64         SubMatch operator*() const { return {*m_it, *(m_it+1)}; }
     65 
     66         friend bool operator==(const iterator& lhs, const iterator& rhs) = default;
     67     private:
     68 
     69         It m_it;
     70     };
     71 
     72     MatchResults() = default;
     73     MatchResults(Vector<Iterator, MemoryDomain::Regex> values) : m_values{std::move(values)} {}
     74 
     75     iterator begin() const { return iterator{m_values.begin()}; }
     76     iterator cbegin() const { return iterator{m_values.cbegin()}; }
     77     iterator end() const { return iterator{m_values.end()}; }
     78     iterator cend() const { return iterator{m_values.cend()}; }
     79 
     80     size_t size() const { return m_values.size() / 2; }
     81     bool empty() const { return m_values.empty(); }
     82 
     83     SubMatch operator[](size_t i) const
     84     {
     85         return i * 2 < m_values.size() ?
     86             SubMatch{m_values[i*2], m_values[i*2+1]} : SubMatch{};
     87     }
     88 
     89     friend bool operator==(const MatchResults& lhs, const MatchResults& rhs) = default;
     90 
     91     void swap(MatchResults& other)
     92     {
     93         m_values.swap(other.m_values);
     94     }
     95 
     96     Vector<Iterator, MemoryDomain::Regex>& values() { return m_values; }
     97 
     98 private:
     99     Vector<Iterator, MemoryDomain::Regex> m_values;
    100 };
    101 
    102 inline RegexExecFlags match_flags(bool bol, bool eol, bool bow, bool eow)
    103 {
    104     return (bol ? RegexExecFlags::None : RegexExecFlags::NotBeginOfLine) |
    105            (eol ? RegexExecFlags::None : RegexExecFlags::NotEndOfLine) |
    106            (bow ? RegexExecFlags::None : RegexExecFlags::NotBeginOfWord) |
    107            (eow ? RegexExecFlags::None : RegexExecFlags::NotEndOfWord);
    108 }
    109 
    110 struct NoopIdle
    111 {
    112     void operator()() {}
    113 };
    114 
    115 template<typename It, typename IdleFunc = NoopIdle>
    116 bool regex_match(It begin, It end, const Regex& re, IdleFunc&& idle_func = {})
    117 {
    118     ThreadedRegexVM<It, RegexMode::Forward | RegexMode::AnyMatch | RegexMode::NoSaves> vm{*re.impl()};
    119     return vm.exec(begin, end, begin, end, RegexExecFlags::None, idle_func);
    120 }
    121 
    122 template<typename It, typename IdleFunc = NoopIdle>
    123 bool regex_match(It begin, It end, MatchResults<It>& res, const Regex& re, IdleFunc&& idle_func = {})
    124 {
    125     res.values().clear();
    126     ThreadedRegexVM<It, RegexMode::Forward> vm{*re.impl()};
    127     if (vm.exec(begin, end, begin, end, RegexExecFlags::None, idle_func))
    128     {
    129         std::copy(vm.captures().begin(), vm.captures().end(), std::back_inserter(res.values()));
    130         return true;
    131     }
    132     return false;
    133 }
    134 
    135 template<typename It, typename IdleFunc = NoopIdle>
    136 bool regex_search(It begin, It end, It subject_begin, It subject_end, const Regex& re,
    137                   RegexExecFlags flags = RegexExecFlags::None, IdleFunc&& idle_func = {})
    138 {
    139     ThreadedRegexVM<It, RegexMode::Forward | RegexMode::Search | RegexMode::AnyMatch | RegexMode::NoSaves> vm{*re.impl()};
    140     return vm.exec(begin, end, subject_begin, subject_end, flags, idle_func);
    141 }
    142 
    143 template<typename It, RegexMode mode = RegexMode::Forward, typename IdleFunc = NoopIdle>
    144 bool regex_search(It begin, It end, It subject_begin, It subject_end,
    145                   MatchResults<It>& res, const Regex& re,
    146                   RegexExecFlags flags = RegexExecFlags::None,
    147                   IdleFunc&& idle_func = {})
    148 {
    149     res.values().clear();
    150     ThreadedRegexVM<It, mode | RegexMode::Search> vm{*re.impl()};
    151     if (vm.exec(begin, end, subject_begin, subject_end, flags, idle_func))
    152     {
    153         std::move(vm.captures().begin(), vm.captures().end(), std::back_inserter(res.values()));
    154         return true;
    155     }
    156     return false;
    157 }
    158 
    159 template<typename It, typename IdleFunc = NoopIdle>
    160 bool backward_regex_search(It begin, It end, It subject_begin, It subject_end,
    161                            MatchResults<It>& res, const Regex& re,
    162                            RegexExecFlags flags = RegexExecFlags::None,
    163                            IdleFunc&& idle_func = {})
    164 {
    165     return regex_search<It, RegexMode::Backward>(begin, end, subject_begin, subject_end, res, re, flags, idle_func);
    166 }
    167 
    168 enum class Quoting;
    169 String option_to_string(const Regex& re, Quoting quoting);
    170 Regex option_from_string(Meta::Type<Regex>, StringView str);
    171 
    172 template<typename Iterator, RegexMode mode = RegexMode::Forward,
    173          typename VmArg = const Regex, typename IdleFunc = NoopIdle>
    174 struct RegexIterator
    175 {
    176     static_assert(has_direction(mode));
    177     static constexpr bool forward = mode & RegexMode::Forward;
    178     using ValueType = MatchResults<Iterator>;
    179     struct Sentinel{};
    180     struct It
    181     {
    182         It(RegexIterator& base) : m_base(base), m_valid{m_base.next()} {}
    183 
    184         const ValueType& operator*() const { kak_assert(m_valid); return m_base.m_results; }
    185         const ValueType* operator->() const { kak_assert(m_valid); return &m_base.m_results; }
    186 
    187         It& operator++() { m_valid = m_base.next(); return *this; }
    188         bool operator==(Sentinel) const { return not m_valid; }
    189 
    190         RegexIterator& m_base;
    191         bool m_valid;
    192     };
    193 
    194     RegexIterator(Iterator begin, Iterator end,
    195                   Iterator subject_begin, Iterator subject_end,
    196                   VmArg& vm_arg, RegexExecFlags flags = RegexExecFlags::None,
    197                   IdleFunc idle_func = {})
    198         : m_vm{make_vm(vm_arg)}, m_next_pos{forward ? begin : end},
    199           m_begin{std::move(begin)}, m_end{std::move(end)},
    200           m_subject_begin{std::move(subject_begin)}, m_subject_end{std::move(subject_end)},
    201           m_flags{flags}, m_idle_func{idle_func} {}
    202 
    203     RegexIterator(const Iterator& begin, const Iterator& end,
    204                   VmArg& vm_arg, RegexExecFlags flags = RegexExecFlags::None,
    205                   IdleFunc idle_func = {})
    206         : RegexIterator{begin, end, begin, end, vm_arg, flags, idle_func} {}
    207 
    208     It begin() { return {*this}; }
    209     Sentinel end() const { return {}; }
    210 
    211 private:
    212     bool next()
    213     {
    214         auto additional_flags = RegexExecFlags::None;
    215         if (m_results.size() and m_results[0].first == m_results[0].second)
    216             additional_flags |= RegexExecFlags::NotInitialNull;
    217 
    218         if (not m_vm.exec(forward ? m_next_pos : m_begin, forward ? m_end : m_next_pos,
    219                           m_subject_begin, m_subject_end, m_flags | additional_flags,
    220                           m_idle_func))
    221             return false;
    222 
    223         m_results.values().clear();
    224         std::move(m_vm.captures().begin(), m_vm.captures().end(), std::back_inserter(m_results.values()));
    225         m_next_pos = forward ? m_results[0].second : m_results[0].first;
    226         kak_assert(forward ? (m_next_pos <= m_end) : (m_next_pos >= m_begin));
    227         return true;
    228     }
    229 
    230     using RegexVM = ThreadedRegexVM<Iterator, mode | RegexMode::Search>;
    231     static RegexVM& make_vm(RegexVM& vm) { return vm; }
    232     static RegexVM make_vm(const Regex& regex) { return {*regex.impl()}; }
    233 
    234     decltype(make_vm(std::declval<VmArg&>())) m_vm;
    235     MatchResults<Iterator> m_results;
    236     Iterator m_next_pos{};
    237     const Iterator m_begin{};
    238     const Iterator m_end{};
    239     const Iterator m_subject_begin{};
    240     const Iterator m_subject_end{};
    241     const RegexExecFlags m_flags = RegexExecFlags::None;
    242     IdleFunc m_idle_func;
    243 };
    244 
    245 }
    246 
    247 #endif // regex_hh_INCLUDED