1 /// Contains the definition of the basic_regex\<\> class template and its associated helper functions. 2 // 3 // Copyright 2008 Eric Niebler. Distributed under the Boost 4 // Software License, Version 1.0. (See accompanying file 5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 7 #ifndef BOOST_XPRESSIVE_DETAIL_CORE_FINDER_HPP_EAN_10_04_2005 8 #define BOOST_XPRESSIVE_DETAIL_CORE_FINDER_HPP_EAN_10_04_2005 9 10 // MS compatible compilers support #pragma once 11 #if defined(_MSC_VER) && (_MSC_VER >= 1020) 12 # pragma once 13 # pragma warning(push) 14 # pragma warning(disable : 4189) // local variable is initialized but not referenced 15 #endif 16 17 #include <boost/xpressive/detail/detail_fwd.hpp> 18 #include <boost/xpressive/detail/core/regex_impl.hpp> 19 #include <boost/xpressive/detail/utility/boyer_moore.hpp> 20 #include <boost/xpressive/detail/utility/hash_peek_bitset.hpp> 21 22 namespace boost { namespace xpressive { namespace detail 23 { 24 25 /////////////////////////////////////////////////////////////////////////////// 26 // boyer_moore_finder 27 // 28 template<typename BidiIter, typename Traits> 29 struct boyer_moore_finder 30 : finder<BidiIter> 31 { 32 typedef typename iterator_value<BidiIter>::type char_type; 33 boyer_moore_finderboost::xpressive::detail::boyer_moore_finder34 boyer_moore_finder(char_type const *begin, char_type const *end, Traits const &tr, bool icase) 35 : bm_(begin, end, tr, icase) 36 { 37 } 38 ok_for_partial_matchesboost::xpressive::detail::boyer_moore_finder39 bool ok_for_partial_matches() const 40 { 41 return false; 42 } 43 operator ()boost::xpressive::detail::boyer_moore_finder44 bool operator ()(match_state<BidiIter> &state) const 45 { 46 Traits const &traits = traits_cast<Traits>(state); 47 state.cur_ = this->bm_.find(state.cur_, state.end_, traits); 48 return state.cur_ != state.end_; 49 } 50 51 private: 52 boyer_moore_finder(boyer_moore_finder const &); 53 boyer_moore_finder &operator =(boyer_moore_finder const &); 54 55 boyer_moore<BidiIter, Traits> bm_; 56 }; 57 58 /////////////////////////////////////////////////////////////////////////////// 59 // hash_peek_finder 60 // 61 template<typename BidiIter, typename Traits> 62 struct hash_peek_finder 63 : finder<BidiIter> 64 { 65 typedef typename iterator_value<BidiIter>::type char_type; 66 hash_peek_finderboost::xpressive::detail::hash_peek_finder67 hash_peek_finder(hash_peek_bitset<char_type> const &bset) 68 : bset_(bset) 69 { 70 } 71 operator ()boost::xpressive::detail::hash_peek_finder72 bool operator ()(match_state<BidiIter> &state) const 73 { 74 Traits const &traits = traits_cast<Traits>(state); 75 state.cur_ = (this->bset_.icase() 76 ? this->find_(state.cur_, state.end_, traits, mpl::true_()) 77 : this->find_(state.cur_, state.end_, traits, mpl::false_())); 78 return state.cur_ != state.end_; 79 } 80 81 private: 82 hash_peek_finder(hash_peek_finder const &); 83 hash_peek_finder &operator =(hash_peek_finder const &); 84 85 template<typename ICase> find_boost::xpressive::detail::hash_peek_finder86 BidiIter find_(BidiIter begin, BidiIter end, Traits const &traits, ICase) const 87 { 88 for(; begin != end && !this->bset_.test(*begin, traits, ICase()); ++begin) 89 ; 90 return begin; 91 } 92 93 hash_peek_bitset<char_type> bset_; 94 }; 95 96 /////////////////////////////////////////////////////////////////////////////// 97 // line_start_finder 98 // 99 template<typename BidiIter, typename Traits, std::size_t Size = sizeof(typename iterator_value<BidiIter>::type)> 100 struct line_start_finder 101 : finder<BidiIter> 102 { 103 typedef typename iterator_value<BidiIter>::type char_type; 104 typedef typename iterator_difference<BidiIter>::type diff_type; 105 typedef typename Traits::char_class_type char_class_type; 106 line_start_finderboost::xpressive::detail::line_start_finder107 line_start_finder(Traits const &traits) 108 : newline_(lookup_classname(traits, "newline")) 109 { 110 } 111 operator ()boost::xpressive::detail::line_start_finder112 bool operator ()(match_state<BidiIter> &state) const 113 { 114 if(state.bos() && state.flags_.match_bol_) 115 { 116 return true; 117 } 118 119 Traits const &traits = traits_cast<Traits>(state); 120 BidiIter cur = state.cur_; 121 BidiIter const end = state.end_; 122 std::advance(cur, static_cast<diff_type>(-!state.bos())); 123 124 for(; cur != end; ++cur) 125 { 126 if(traits.isctype(*cur, this->newline_)) 127 { 128 state.cur_ = ++cur; 129 return true; 130 } 131 } 132 133 return false; 134 } 135 136 private: 137 line_start_finder(line_start_finder const &); 138 line_start_finder &operator =(line_start_finder const &); 139 140 char_class_type newline_; 141 }; 142 143 /////////////////////////////////////////////////////////////////////////////// 144 // line_start_finder 145 // 146 template<typename BidiIter, typename Traits> 147 struct line_start_finder<BidiIter, Traits, 1u> 148 : finder<BidiIter> 149 { 150 typedef typename iterator_value<BidiIter>::type char_type; 151 typedef typename iterator_difference<BidiIter>::type diff_type; 152 typedef typename Traits::char_class_type char_class_type; 153 line_start_finderboost::xpressive::detail::line_start_finder154 line_start_finder(Traits const &traits) 155 { 156 char_class_type newline = lookup_classname(traits, "newline"); 157 for(int j = 0; j < 256; ++j) 158 { 159 this->bits_[j] = traits.isctype(static_cast<char_type>(static_cast<unsigned char>(j)), newline); 160 } 161 } 162 operator ()boost::xpressive::detail::line_start_finder163 bool operator ()(match_state<BidiIter> &state) const 164 { 165 if(state.bos() && state.flags_.match_bol_) 166 { 167 return true; 168 } 169 170 BidiIter cur = state.cur_; 171 BidiIter const end = state.end_; 172 std::advance(cur, static_cast<diff_type>(-!state.bos())); 173 174 for(; cur != end; ++cur) 175 { 176 if(this->bits_[static_cast<unsigned char>(*cur)]) 177 { 178 state.cur_ = ++cur; 179 return true; 180 } 181 } 182 183 return false; 184 } 185 186 private: 187 line_start_finder(line_start_finder const &); 188 line_start_finder &operator =(line_start_finder const &); 189 190 bool bits_[256]; 191 }; 192 193 /////////////////////////////////////////////////////////////////////////////// 194 // leading_simple_repeat_finder 195 // 196 template<typename BidiIter> 197 struct leading_simple_repeat_finder 198 : finder<BidiIter> 199 { leading_simple_repeat_finderboost::xpressive::detail::leading_simple_repeat_finder200 leading_simple_repeat_finder() 201 : finder<BidiIter>() 202 {} 203 operator ()boost::xpressive::detail::leading_simple_repeat_finder204 bool operator ()(match_state<BidiIter> &state) const 205 { 206 state.cur_ = state.next_search_; 207 return true; 208 } 209 210 private: 211 leading_simple_repeat_finder(leading_simple_repeat_finder const &); 212 leading_simple_repeat_finder &operator =(leading_simple_repeat_finder const &); 213 }; 214 215 }}} 216 217 #if defined(_MSC_VER) && (_MSC_VER >= 1020) 218 # pragma warning(pop) 219 #endif 220 221 #endif 222