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