31 namespace std _GLIBCXX_VISIBILITY(default)
33 _GLIBCXX_BEGIN_NAMESPACE_VERSION
34 _GLIBCXX_BEGIN_NAMESPACE_CXX11
35 template<
typename,
typename>
38 template<
typename,
typename>
41 _GLIBCXX_END_NAMESPACE_CXX11
45 enum class _RegexExecutorPolicy : int { _S_auto, _S_alternate };
47 template<
typename _BiIter,
typename _Alloc,
48 typename _CharT,
typename _TraitsT,
49 _RegexExecutorPolicy __policy,
52 __regex_algo_impl(_BiIter __s,
54 match_results<_BiIter, _Alloc>& __m,
55 const basic_regex<_CharT, _TraitsT>& __re,
58 template<
typename,
typename,
typename,
bool>
62 _GLIBCXX_BEGIN_NAMESPACE_CXX11
79 template<
typename _Ch_type>
83 typedef _Ch_type char_type;
90 typedef std::ctype_base::mask _BaseType;
92 unsigned char _M_extended;
93 static constexpr
unsigned char _S_under = 1 << 0;
94 static constexpr
unsigned char _S_valid_mask = 0x1;
96 constexpr _RegexMask(_BaseType
__base = 0,
97 unsigned char __extended = 0)
98 : _M_base(
__base), _M_extended(__extended)
104 return _RegexMask(_M_base & __other._M_base,
105 _M_extended & __other._M_extended);
111 return _RegexMask(_M_base | __other._M_base,
112 _M_extended | __other._M_extended);
118 return _RegexMask(_M_base ^ __other._M_base,
119 _M_extended ^ __other._M_extended);
124 {
return _RegexMask(~_M_base, ~_M_extended); }
127 operator&=(_RegexMask __other)
128 {
return *
this = (*this) & __other; }
131 operator|=(_RegexMask __other)
132 {
return *
this = (*this) | __other; }
135 operator^=(_RegexMask __other)
136 {
return *
this = (*this) ^ __other; }
139 operator==(_RegexMask __other)
const
141 return (_M_extended & _S_valid_mask)
142 == (__other._M_extended & _S_valid_mask)
143 && _M_base == __other._M_base;
146 #if __cpp_impl_three_way_comparison < 201907L
148 operator!=(_RegexMask __other)
const
149 {
return !((*this) == __other); }
154 typedef _RegexMask char_class_type;
174 {
return string_type::traits_type::length(__p); }
200 const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
201 return __fctyp.tolower(__c);
224 template<
typename _Fwd_iter>
229 const __collate_type& __fclt(use_facet<__collate_type>(_M_locale));
231 return __fclt.transform(__s.
data(), __s.
data() + __s.
size());
248 template<
typename _Fwd_iter>
259 const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
276 template<
typename _Fwd_iter>
317 template<
typename _Fwd_iter>
320 bool __icase =
false)
const;
335 isctype(_Ch_type __c, char_class_type __f)
const;
348 value(_Ch_type __ch,
int __radix)
const;
374 {
return _M_locale; }
377 locale_type _M_locale;
388 template<
typename _Ch_type,
typename _Rx_traits = regex_traits<_Ch_type>>
393 "regex traits class must have the same char_type");
396 typedef _Ch_type value_type;
397 typedef _Rx_traits traits_type;
398 typedef typename traits_type::string_type string_type;
400 typedef typename traits_type::locale_type locale_type;
425 : _M_flags(ECMAScript), _M_loc(), _M_automaton(nullptr)
484 template<
typename _Ch_traits,
typename _Ch_alloc>
505 template<
typename _FwdIter>
534 {
return this->
assign(__rhs); }
552 {
return this->
assign(__p); }
564 {
return this->
assign(__l.begin(), __l.end()); }
572 template<
typename _Ch_traits,
typename _Alloc>
575 {
return this->
assign(__s); }
619 {
return this->
assign(string_type(__p), __flags); }
638 {
return this->
assign(string_type(__p, __len), __flags); }
651 template<
typename _Ch_traits,
typename _Alloc>
673 template<
typename _InputIterator>
675 assign(_InputIterator __first, _InputIterator __last,
677 {
return this->
assign(string_type(__first, __last), __flags); }
692 {
return this->
assign(__l.begin(), __l.end(), __flags); }
703 return _M_automaton->_M_sub_count() - 1;
725 _M_automaton.reset();
748 std::swap(_M_automaton, __rhs._M_automaton);
751 #ifdef _GLIBCXX_DEBUG
754 { _M_automaton->_M_dot(__ostr); }
760 template<
typename _FwdIter>
761 basic_regex(_FwdIter __first, _FwdIter __last, locale_type __loc,
763 : _M_flags(__f), _M_loc(
std::
move(__loc)),
764 _M_automaton(__detail::__compile_nfa<_Rx_traits>(
768 template<
typename _Bp,
typename _Ap,
typename _Cp,
typename _Rp,
769 __detail::_RegexExecutorPolicy,
bool>
771 __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
772 const basic_regex<_Cp, _Rp>&,
775 template<
typename,
typename,
typename,
bool>
776 friend class __detail::_Executor;
780 _AutomatonPtr _M_automaton;
783 #if __cplusplus < 201703L
784 template<
typename _Ch,
typename _Tr>
788 template<
typename _Ch,
typename _Tr>
792 template<
typename _Ch,
typename _Tr>
796 template<
typename _Ch,
typename _Tr>
800 template<
typename _Ch,
typename _Tr>
804 template<
typename _Ch,
typename _Tr>
808 template<
typename _Ch,
typename _Tr>
812 template<
typename _Ch,
typename _Tr>
816 template<
typename _Ch,
typename _Tr>
820 template<
typename _Ch,
typename _Tr>
825 #if __cpp_deduction_guides >= 201606
826 template<
typename _ForwardIterator>
827 basic_regex(_ForwardIterator, _ForwardIterator,
829 -> basic_regex<
typename iterator_traits<_ForwardIterator>::value_type>;
835 #ifdef _GLIBCXX_USE_WCHAR_T
848 template<
typename _Ch_type,
typename _Rx_traits>
852 { __lhs.
swap(__rhs); }
868 template<
typename _BiIter>
874 typedef typename __iter_traits::value_type value_type;
875 typedef typename __iter_traits::difference_type difference_type;
876 typedef _BiIter iterator;
881 constexpr
sub_match() noexcept : matched() { }
886 {
return this->matched ? std::distance(this->
first, this->
second) : 0; }
898 operator string_type()
const
925 {
return this->_M_str().compare(__s._M_str()); }
939 {
return this->_M_str().compare(__s); }
943 {
return this->_M_str().compare(__s); }
949 _M_compare(
const value_type* __s,
size_t __n)
const
950 {
return this->_M_str().compare({__s, __n}); }
957 using traits_type =
typename string_type::traits_type;
959 __string_view() =
default;
961 __string_view(
const value_type* __s,
size_t __n) noexcept
962 : _M_data(__s), _M_len(__n) { }
964 __string_view(
const value_type* __s) noexcept
965 : _M_data(__s), _M_len(traits_type::length(__s)) { }
967 __string_view(
const string_type& __s) noexcept
968 : _M_data(__s.data()), _M_len(__s.length()) { }
971 compare(__string_view __s)
const noexcept
973 if (
const size_t __n =
std::min(_M_len, __s._M_len))
974 if (
int __ret = traits_type::compare(_M_data, __s._M_data, __n))
977 const difference_type __diff = _M_len - __s._M_len;
978 if (__diff > __limits::__max)
979 return __limits::__max;
980 if (__diff < __limits::__min)
981 return __limits::__min;
982 return static_cast<int>(__diff);
986 const value_type* _M_data =
nullptr;
991 template<
typename _Iter = _BiIter>
992 __enable_if_t<__detail::__is_contiguous_iter<_Iter>::value,
994 _M_str() const noexcept
1003 template<
typename _Iter = _BiIter>
1004 __enable_if_t<!__detail::__is_contiguous_iter<_Iter>::value,
1017 #ifdef _GLIBCXX_USE_WCHAR_T
1035 template<
typename _BiIter>
1038 {
return __lhs.
compare(__rhs) == 0; }
1040 #if __cpp_lib_three_way_comparison
1048 template<
typename _BiIter>
1052 noexcept(__detail::__is_contiguous_iter<_BiIter>::value)
1055 return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
1064 template<
typename _BiIter>
1067 {
return __lhs.
compare(__rhs) != 0; }
1075 template<
typename _BiIter>
1078 {
return __lhs.
compare(__rhs) < 0; }
1086 template<
typename _BiIter>
1089 {
return __lhs.
compare(__rhs) <= 0; }
1097 template<
typename _BiIter>
1100 {
return __lhs.
compare(__rhs) >= 0; }
1108 template<
typename _BiIter>
1111 {
return __lhs.
compare(__rhs) > 0; }
1117 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1120 _Ch_traits, _Ch_alloc>;
1123 #if ! __cpp_lib_three_way_comparison
1131 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1133 operator==(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1135 {
return __rhs._M_compare(__lhs.data(), __lhs.size()) == 0; }
1144 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1146 operator!=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1148 {
return !(__lhs == __rhs); }
1156 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1158 operator<(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1160 {
return __rhs._M_compare(__lhs.data(), __lhs.size()) > 0; }
1168 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1170 operator>(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1172 {
return __rhs < __lhs; }
1180 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1182 operator>=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1184 {
return !(__lhs < __rhs); }
1192 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1194 operator<=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1196 {
return !(__rhs < __lhs); }
1206 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1209 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1210 {
return __lhs._M_compare(__rhs.data(), __rhs.size()) == 0; }
1212 #if __cpp_lib_three_way_comparison
1220 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Alloc>
1223 const __sub_match_string<_Bi_iter, _Ch_traits, _Alloc>& __rhs)
1224 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1226 return __detail::__char_traits_cmp_cat<_Ch_traits>(
1227 __lhs._M_compare(__rhs.data(), __rhs.size()));
1237 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1240 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1241 {
return !(__lhs == __rhs); }
1249 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1252 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1253 {
return __lhs._M_compare(__rhs.data(), __rhs.size()) < 0; }
1261 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1264 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1265 {
return __rhs < __lhs; }
1273 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1276 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1277 {
return !(__lhs < __rhs); }
1285 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1288 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1289 {
return !(__rhs < __lhs); }
1298 template<
typename _Bi_iter>
1302 {
return __rhs.
compare(__lhs) == 0; }
1311 template<
typename _Bi_iter>
1315 {
return !(__lhs == __rhs); }
1323 template<
typename _Bi_iter>
1327 {
return __rhs.
compare(__lhs) > 0; }
1335 template<
typename _Bi_iter>
1339 {
return __rhs < __lhs; }
1347 template<
typename _Bi_iter>
1351 {
return !(__lhs < __rhs); }
1359 template<
typename _Bi_iter>
1363 {
return !(__rhs < __lhs); }
1373 template<
typename _Bi_iter>
1377 {
return __lhs.
compare(__rhs) == 0; }
1379 #if __cpp_lib_three_way_comparison
1388 template<
typename _Bi_iter>
1392 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1395 return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
1405 template<
typename _Bi_iter>
1409 {
return !(__lhs == __rhs); }
1417 template<
typename _Bi_iter>
1421 {
return __lhs.
compare(__rhs) < 0; }
1429 template<
typename _Bi_iter>
1433 {
return __rhs < __lhs; }
1441 template<
typename _Bi_iter>
1445 {
return !(__lhs < __rhs); }
1453 template<
typename _Bi_iter>
1457 {
return !(__rhs < __lhs); }
1466 template<
typename _Bi_iter>
1479 template<
typename _Bi_iter>
1483 {
return !(__lhs == __rhs); }
1492 template<
typename _Bi_iter>
1505 template<
typename _Bi_iter>
1509 {
return __rhs < __lhs; }
1518 template<
typename _Bi_iter>
1522 {
return !(__lhs < __rhs); }
1531 template<
typename _Bi_iter>
1535 {
return !(__rhs < __lhs); }
1545 template<
typename _Bi_iter>
1551 #if __cpp_lib_three_way_comparison
1561 template<
typename _Bi_iter>
1565 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1568 return __detail::__char_traits_cmp_cat<_Tr>(
1579 template<
typename _Bi_iter>
1583 {
return !(__lhs == __rhs); }
1592 template<
typename _Bi_iter>
1605 template<
typename _Bi_iter>
1609 {
return __rhs < __lhs; }
1618 template<
typename _Bi_iter>
1622 {
return !(__lhs < __rhs); }
1631 template<
typename _Bi_iter>
1635 {
return !(__rhs < __lhs); }
1646 template<
typename _Ch_type,
typename _Ch_traits,
typename _Bi_iter>
1651 {
return __os << __m.
str(); }
1677 template<
typename _Bi_iter,
1678 typename _Alloc = allocator<sub_match<_Bi_iter> > >
1680 :
private std::vector<sub_match<_Bi_iter>, _Alloc>
1711 typedef typename _Base_type::const_iterator const_iterator;
1712 typedef const_iterator iterator;
1713 typedef typename __iter_traits::difference_type difference_type;
1715 typedef _Alloc allocator_type;
1716 typedef typename __iter_traits::value_type char_type;
1805 _GLIBCXX_NODISCARD
bool
1807 {
return size() == 0; }
1826 {
return (*
this)[__sub].length(); }
1841 {
return std::distance(_M_begin, (*
this)[__sub].first); }
1853 str(size_type __sub = 0)
const
1870 __glibcxx_assert(
ready() );
1871 return __sub <
size()
1873 : _M_unmatched_sub();
1887 __glibcxx_assert(
ready() );
1888 return !
empty() ? _M_prefix() : _M_unmatched_sub();
1902 __glibcxx_assert(
ready() );
1903 return !
empty() ? _M_suffix() : _M_unmatched_sub();
1918 {
return this->
begin(); }
1932 {
return this->
end(); }
1949 template<
typename _Out_iter>
1951 format(_Out_iter __out,
const char_type* __fmt_first,
1952 const char_type* __fmt_last,
1958 template<
typename _Out_iter,
typename _St,
typename _Sa>
1970 template<
typename _St,
typename _Sa>
2024 swap(_M_begin, __that._M_begin);
2029 template<
typename,
typename,
typename>
2034 template<
typename,
typename,
typename,
bool>
2037 template<
typename _Bp,
typename _Ap,
typename _Cp,
typename _Rp,
2038 __detail::_RegexExecutorPolicy,
bool>
2047 _M_resize(
unsigned int __size)
2052 _M_establish_failed_match(_Bi_iter __end)
2054 sub_match<_Bi_iter> __sm;
2055 __sm.first = __sm.second = __end;
2060 _M_unmatched_sub()
const
2063 sub_match<_Bi_iter>&
2071 sub_match<_Bi_iter>&
2079 sub_match<_Bi_iter>&
2087 typedef match_results<const char*> cmatch;
2088 typedef match_results<string::const_iterator> smatch;
2089 #ifdef _GLIBCXX_USE_WCHAR_T
2090 typedef match_results<const wchar_t*> wcmatch;
2091 typedef match_results<wstring::const_iterator> wsmatch;
2101 template<
typename _Bi_iter,
typename _Alloc>
2120 #if ! __cpp_lib_three_way_comparison
2126 template<
typename _Bi_iter,
class _Alloc>
2130 {
return !(__m1 == __m2); }
2141 template<
typename _Bi_iter,
typename _Alloc>
2145 { __lhs.swap(__rhs); }
2147 _GLIBCXX_END_NAMESPACE_CXX11
2170 template<
typename _Bi_iter,
typename _Alloc,
2171 typename _Ch_type,
typename _Rx_traits>
2180 return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
2181 __detail::_RegexExecutorPolicy::_S_auto,
true>
2182 (__s, __e, __m, __re, __flags);
2199 template<
typename _Bi_iter,
typename _Ch_type,
typename _Rx_traits>
2207 return regex_match(__first, __last, __what, __re, __flags);
2224 template<
typename _Ch_type,
typename _Alloc,
typename _Rx_traits>
2231 {
return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
2247 template<
typename _Ch_traits,
typename _Ch_alloc,
2248 typename _Alloc,
typename _Ch_type,
typename _Rx_traits>
2252 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2261 template<
typename _Ch_traits,
typename _Ch_alloc,
2262 typename _Alloc,
typename _Ch_type,
typename _Rx_traits>
2266 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2284 template<
typename _Ch_type,
class _Rx_traits>
2290 {
return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
2305 template<
typename _Ch_traits,
typename _Str_allocator,
2306 typename _Ch_type,
typename _Rx_traits>
2328 template<
typename _Bi_iter,
typename _Alloc,
2329 typename _Ch_type,
typename _Rx_traits>
2337 return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
2338 __detail::_RegexExecutorPolicy::_S_auto,
false>
2339 (__s, __e, __m, __re, __flags);
2353 template<
typename _Bi_iter,
typename _Ch_type,
typename _Rx_traits>
2361 return regex_search(__first, __last, __what, __re, __flags);
2376 template<
typename _Ch_type,
class _Alloc,
class _Rx_traits>
2383 {
return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
2395 template<
typename _Ch_type,
typename _Rx_traits>
2401 {
return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
2413 template<
typename _Ch_traits,
typename _String_allocator,
2414 typename _Ch_type,
typename _Rx_traits>
2417 _String_allocator>& __s,
2421 {
return regex_search(__s.begin(), __s.end(), __e, __flags); }
2435 template<
typename _Ch_traits,
typename _Ch_alloc,
2436 typename _Alloc,
typename _Ch_type,
2437 typename _Rx_traits>
2441 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2450 template<
typename _Ch_traits,
typename _Ch_alloc,
2451 typename _Alloc,
typename _Ch_type,
2452 typename _Rx_traits>
2456 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2475 template<
typename _Out_iter,
typename _Bi_iter,
2476 typename _Rx_traits,
typename _Ch_type,
2477 typename _St,
typename _Sa>
2501 template<
typename _Out_iter,
typename _Bi_iter,
2502 typename _Rx_traits,
typename _Ch_type>
2506 const _Ch_type* __fmt,
2521 template<
typename _Rx_traits,
typename _Ch_type,
2522 typename _St,
typename _Sa,
typename _Fst,
typename _Fsa>
2532 __s.
begin(), __s.
end(), __e, __fmt, __flags);
2547 template<
typename _Rx_traits,
typename _Ch_type,
2548 typename _St,
typename _Sa>
2549 inline basic_string<_Ch_type, _St, _Sa>
2552 const _Ch_type* __fmt,
2558 __s.
begin(), __s.
end(), __e, __fmt, __flags);
2573 template<
typename _Rx_traits,
typename _Ch_type,
2574 typename _St,
typename _Sa>
2575 inline basic_string<_Ch_type>
2585 __e, __fmt, __flags);
2600 template<
typename _Rx_traits,
typename _Ch_type>
2601 inline basic_string<_Ch_type>
2604 const _Ch_type* __fmt,
2611 __e, __fmt, __flags);
2617 _GLIBCXX_BEGIN_NAMESPACE_CXX11
2624 template<
typename _Bi_iter,
2625 typename _Ch_type =
typename iterator_traits<_Bi_iter>::value_type,
2626 typename _Rx_traits = regex_traits<_Ch_type> >
2632 typedef std::ptrdiff_t difference_type;
2633 typedef const value_type* pointer;
2634 typedef const value_type& reference;
2653 : _M_begin(__a), _M_end(__b), _M_pregex(&__re), _M_flags(__m), _M_match()
2655 if (!
regex_search(_M_begin, _M_end, _M_match, *_M_pregex, _M_flags))
2685 {
return !(*
this == __rhs); }
2692 {
return _M_match; }
2699 {
return &_M_match; }
2719 _Bi_iter _M_begin {};
2721 const regex_type* _M_pregex =
nullptr;
2723 match_results<_Bi_iter> _M_match;
2726 typedef regex_iterator<const char*> cregex_iterator;
2727 typedef regex_iterator<string::const_iterator> sregex_iterator;
2728 #ifdef _GLIBCXX_USE_WCHAR_T
2729 typedef regex_iterator<const wchar_t*> wcregex_iterator;
2730 typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
2741 template<
typename _Bi_iter,
2742 typename _Ch_type =
typename iterator_traits<_Bi_iter>::value_type,
2743 typename _Rx_traits = regex_traits<_Ch_type> >
2749 typedef std::ptrdiff_t difference_type;
2763 : _M_position(), _M_subs(), _M_suffix(), _M_n(0), _M_result(nullptr),
2788 : _M_position(__a, __b, __re, __m), _M_subs(1, __submatch), _M_n(0)
2789 { _M_init(__a, __b); }
2805 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2806 { _M_init(__a, __b); }
2822 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2823 { _M_init(__a, __b); }
2834 template<std::
size_t _Nm>
2837 const int (&__submatches)[_Nm],
2840 : _M_position(__a, __b, __re, __m),
2841 _M_subs(__submatches, __submatches + _Nm), _M_n(0)
2842 { _M_init(__a, __b); }
2857 template <std::
size_t _Nm>
2868 : _M_position(__rhs._M_position), _M_subs(__rhs._M_subs),
2869 _M_suffix(__rhs._M_suffix), _M_n(__rhs._M_n), _M_has_m1(__rhs._M_has_m1)
2870 { _M_normalize_result(); }
2890 {
return !(*
this == __rhs); }
2897 {
return *_M_result; }
2904 {
return _M_result; }
2927 _M_init(_Bi_iter __a, _Bi_iter __b);
2930 _M_current_match()
const
2932 if (_M_subs[_M_n] == -1)
2933 return (*_M_position).prefix();
2935 return (*_M_position)[_M_subs[_M_n]];
2939 _M_end_of_seq()
const
2940 {
return _M_result ==
nullptr; }
2944 _M_normalize_result()
2946 if (_M_position != _Position())
2947 _M_result = &_M_current_match();
2949 _M_result = &_M_suffix;
2951 _M_result =
nullptr;
2954 _Position _M_position;
2956 value_type _M_suffix;
2958 const value_type* _M_result;
2970 #ifdef _GLIBCXX_USE_WCHAR_T
2980 _GLIBCXX_END_NAMESPACE_CXX11
2981 _GLIBCXX_END_NAMESPACE_VERSION
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
_Tp * begin(valarray< _Tp > &__va)
Return an iterator pointing to the first element of the valarray.
_Tp * end(valarray< _Tp > &__va)
Return an iterator pointing to one past the last element of the valarray.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
bool operator>=(typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a character and a regular expression submatch.
sub_match< wstring::const_iterator > wssub_match
Regex submatch over a standard wide string.
bool operator!=(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)
Tests the inequivalence of a regular expression submatch and a character.
sub_match< string::const_iterator > ssub_match
Standard regex submatch over a standard string.
bool operator==(const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the equivalence of a string and a regular expression submatch.
bool operator!=(const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the inequivalence of a string and a regular expression submatch.
sub_match< const char * > csub_match
Standard regex submatch over a C-style null-terminated string.
regex_token_iterator< const char * > cregex_token_iterator
Token iterator for C-style NULL-terminated strings.
bool operator==(const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)
Tests the equivalence of a regular expression submatch and a string.
bool operator>=(const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a string and a regular expression submatch.
regex_token_iterator< wstring::const_iterator > wsregex_token_iterator
Token iterator for standard wide-character strings.
bool operator==(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)
Tests the equivalence of a regular expression submatch and a character.
bool operator>=(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)
Tests the ordering of a regular expression submatch and a C string.
bool operator==(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)
Tests the equivalence of a regular expression submatch and a C string.
bool operator!=(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)
Tests the inequivalence of a regular expression submatch and a string.
bool operator!=(typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the inequivalence of a C string and a regular expression submatch.
regex_token_iterator< const wchar_t * > wcregex_token_iterator
Token iterator for C-style NULL-terminated wide strings.
bool operator>(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)
Tests the ordering of a regular expression submatch and a character.
bool operator>(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)
Tests the ordering of a regular expression submatch and a C string.
bool operator>=(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)
Tests the ordering of a regular expression submatch and a character.
bool operator>(typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a character and a regular expression submatch.
basic_regex< char > regex
Standard regular expressions.
_Out_iter regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, const basic_regex< _Ch_type, _Rx_traits > &__e, const basic_string< _Ch_type, _St, _Sa > &__fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)
Search for a regular expression within a range for multiple times, and replace the matched parts thro...
sub_match< const wchar_t * > wcsub_match
Regex submatch over a C-style null-terminated wide string.
regex_token_iterator< string::const_iterator > sregex_token_iterator
Token iterator for standard strings.
bool operator>=(const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)
Tests the ordering of a regular expression submatch and a string.
bool regex_match(_Bi_iter __s, _Bi_iter __e, match_results< _Bi_iter, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)
Determines if there is a match between the regular expression e and all of the character sequence [fi...
bool operator==(const match_results< _Bi_iter, _Alloc > &__m1, const match_results< _Bi_iter, _Alloc > &__m2)
Compares two match_results for equality.
bool operator!=(const match_results< _Bi_iter, _Alloc > &__m1, const match_results< _Bi_iter, _Alloc > &__m2)
Compares two match_results for inequality.
bool regex_search(_Bi_iter __s, _Bi_iter __e, match_results< _Bi_iter, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)
bool operator>(const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)
Tests the ordering of a regular expression submatch and a string.
bool operator>(typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a C string and a regular expression submatch.
bool operator>=(const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)
Tests the ordering of two regular expression submatches.
bool operator>(const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)
Tests the ordering of two regular expression submatches.
bool operator==(typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the equivalence of a character and a regular expression submatch.
void swap(basic_regex< _Ch_type, _Rx_traits > &__lhs, basic_regex< _Ch_type, _Rx_traits > &__rhs)
Swaps the contents of two regular expression objects.
bool operator>(const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a string and a regular expression submatch.
bool operator!=(typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the inequivalence of a character and a regular expression submatch.
basic_regex< wchar_t > wregex
Standard wide-character regular expressions.
bool operator==(typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the equivalence of a C string and a regular expression submatch.
bool operator==(const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)
Tests the equivalence of two regular expression submatches.
bool operator!=(const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)
Tests the inequivalence of two regular expression submatches.
bool operator!=(const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)
Tests the inequivalence of a regular expression submatch and a string.
bool operator>=(typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a C string and a regular expression submatch.
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
ISO C++ entities toplevel namespace is std.
bitset< _Nb > operator^(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
bitset< _Nb > operator&(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
constexpr auto data(_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())
Return the data pointer of a container.
__numeric_traits_integer< _Tp > __int_traits
Convenience alias for __numeric_traits<integer-type>.
constexpr syntax_option_type collate
constexpr syntax_option_type ECMAScript
constexpr syntax_option_type egrep
syntax_option_type
This is a bitmask type indicating how to interpret the regex.
constexpr match_flag_type match_default
constexpr syntax_option_type awk
constexpr syntax_option_type extended
constexpr syntax_option_type basic
match_flag_type
This is a bitmask type indicating regex matching rules.
constexpr syntax_option_type icase
constexpr syntax_option_type optimize
constexpr match_flag_type format_default
constexpr syntax_option_type nosubs
constexpr syntax_option_type grep
constexpr _Iterator __base(_Iterator __it)
typename _Size< _Alloc, difference_type >::type size_type
The allocator's size type.
Managing sequences of characters and character-like objects.
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
const _CharT * data() const noexcept
Return const pointer to contents.
Basis for explicit traits specializations.
Traits class for iterators.
Container class for localization functionality.
Facet for localized string comparison.
Primary class template ctype facet.
basic_regex & assign(const basic_string< _Ch_type, _Ch_traits, _Alloc > &__s, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object from a string containing a regular expression patt...
basic_regex & assign(basic_regex &&__rhs) noexcept
The move-assignment operator.
basic_regex & operator=(const basic_regex &__rhs)
Assigns one regular expression to another.
basic_regex & assign(initializer_list< _Ch_type > __l, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object.
locale_type imbue(locale_type __loc)
Imbues the regular expression object with the given locale.
basic_regex & assign(const basic_regex &__rhs)
the real assignment operator.
basic_regex(const basic_regex &__rhs)=default
Copy-constructs a basic regular expression.
void swap(basic_regex &__rhs)
Swaps the contents of two regular expression objects.
unsigned int mark_count() const
Gets the number of marked subexpressions within the regular expression.
basic_regex & operator=(const basic_string< _Ch_type, _Ch_traits, _Alloc > &__s)
Replaces a regular expression with a new one constructed from a string.
basic_regex & operator=(basic_regex &&__rhs) noexcept
Move-assigns one regular expression to another.
basic_regex(const _Ch_type *__p, flag_type __f=ECMAScript)
Constructs a basic regular expression from the sequence [__p, __p + char_traits<_Ch_type>::length(__p...
basic_regex(const std::basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &__s, flag_type __f=ECMAScript)
Constructs a basic regular expression from the string s interpreted according to the flags in f.
basic_regex & operator=(const _Ch_type *__p)
Replaces a regular expression with a new one constructed from a C-style null-terminated string.
locale_type getloc() const
Gets the locale currently imbued in the regular expression object.
basic_regex(_FwdIter __first, _FwdIter __last, flag_type __f=ECMAScript)
Constructs a basic regular expression from the range [first, last) interpreted according to the flags...
basic_regex & assign(const _Ch_type *__p, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object from a C-style null-terminated string containing a...
flag_type flags() const
Gets the flags used to construct the regular expression or in the last call to assign().
basic_regex(const _Ch_type *__p, std::size_t __len, flag_type __f=ECMAScript)
Constructs a basic regular expression from the sequence [p, p + len) interpreted according to the fla...
basic_regex & assign(_InputIterator __first, _InputIterator __last, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object.
basic_regex & assign(const _Ch_type *__p, size_t __len, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object from a C-style string containing a regular express...
basic_regex(basic_regex &&__rhs) noexcept=default
Move-constructs a basic regular expression.
basic_regex(initializer_list< _Ch_type > __l, flag_type __f=ECMAScript)
Constructs a basic regular expression from an initializer list.
basic_regex & operator=(initializer_list< _Ch_type > __l)
Replaces a regular expression with a new one constructed from an initializer list.
~basic_regex()
Destroys a basic regular expression.
The results of a match or search operation.
allocator_type get_allocator() const noexcept
Gets a copy of the allocator.
void swap(match_results &__that) noexcept
Swaps the contents of two match_results.
difference_type position(size_type __sub=0) const
Gets the offset of the beginning of the indicated submatch.
size_type size() const noexcept
Gets the number of matches and submatches.
_Out_iter format(_Out_iter __out, const char_type *__fmt_first, const char_type *__fmt_last, match_flag_type __flags=regex_constants::format_default) const
difference_type length(size_type __sub=0) const
Gets the length of the indicated submatch.
const_reference prefix() const
Gets a sub_match representing the match prefix.
size_type max_size() const noexcept
Gets the number of matches and submatches.
const_reference operator[](size_type __sub) const
Gets a sub_match reference for the match or submatch.
match_results(match_results &&) noexcept=default
Move constructs a match_results.
basic_string< char_type, _St, _Sa > format(const basic_string< char_type, _St, _Sa > &__fmt, match_flag_type __flags=regex_constants::format_default) const
match_results(const _Alloc &__a) noexcept
Constructs a default match_results container.
match_results(const match_results &)=default
Copy constructs a match_results.
_Out_iter format(_Out_iter __out, const basic_string< char_type, _St, _Sa > &__fmt, match_flag_type __flags=regex_constants::format_default) const
const_iterator cbegin() const noexcept
Gets an iterator to the start of the sub_match collection.
string_type str(size_type __sub=0) const
Gets the match or submatch converted to a string type.
const_iterator end() const noexcept
Gets an iterator to one-past-the-end of the collection.
const_reference suffix() const
Gets a sub_match representing the match suffix.
bool ready() const noexcept
Indicates if the match_results is ready.
bool empty() const noexcept
Indicates if the match_results contains no results.
string_type format(const char_type *__fmt, match_flag_type __flags=regex_constants::format_default) const
match_results()
Constructs a default match_results container.
const_iterator cend() const noexcept
Gets an iterator to one-past-the-end of the collection.
const_iterator begin() const noexcept
Gets an iterator to the start of the sub_match collection.
Takes a regex and an input string and does the matching.
Describes aspects of a regular expression.
char_type translate(char_type __c) const
Performs the identity translation.
string_type lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
Gets a collation element by name.
char_class_type lookup_classname(_Fwd_iter __first, _Fwd_iter __last, bool __icase=false) const
Maps one or more characters to a named character classification.
static std::size_t length(const char_type *__p)
Gives the length of a C-style string starting at __p.
string_type transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
Gets a sort key for a character sequence, independent of case.
regex_traits()
Constructs a default traits object.
int value(_Ch_type __ch, int __radix) const
Converts a digit to an int.
char_type translate_nocase(char_type __c) const
Translates a character into a case-insensitive equivalent.
locale_type getloc() const
Gets a copy of the current locale in use by the regex_traits object.
bool isctype(_Ch_type __c, char_class_type __f) const
Determines if c is a member of an identified class.
locale_type imbue(locale_type __loc)
Imbues the regex_traits object with a copy of a new locale.
string_type transform(_Fwd_iter __first, _Fwd_iter __last) const
Gets a sort key for a character sequence.
difference_type length() const noexcept
Gets the length of the matching sequence.
int compare(const value_type *__s) const
Compares this sub_match to a string.
string_type str() const
Gets the matching sequence as a string.
int compare(const sub_match &__s) const
Compares this and another matched sequence.
int compare(const string_type &__s) const
Compares this sub_match to a string.
regex_iterator & operator++()
Increments a regex_iterator.
bool operator!=(const regex_iterator &__rhs) const noexcept
Tests the inequivalence of two regex iterators.
regex_iterator operator++(int)
Postincrements a regex_iterator.
regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, regex_constants::match_flag_type __m=regex_constants::match_default)
regex_iterator(const regex_iterator &)=default
Copy constructs a regex_iterator.
regex_iterator()=default
Provides a singular iterator, useful for indicating one-past-the-end of a range.
regex_iterator & operator=(const regex_iterator &)=default
Copy assigns one regex_iterator to another.
const value_type & operator*() const noexcept
Dereferences a regex_iterator.
const value_type * operator->() const noexcept
Selects a regex_iterator member.
bool operator==(const regex_iterator &) const noexcept
Tests the equivalence of two regex iterators.
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, const int(&__submatches)[_Nm], regex_constants::match_flag_type __m=regex_constants::match_default)
bool operator==(const regex_token_iterator &__rhs) const
Compares a regex_token_iterator to another for equality.
const value_type & operator*() const
Dereferences a regex_token_iterator.
regex_token_iterator(const regex_token_iterator &__rhs)
Copy constructs a regex_token_iterator.
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, const std::vector< int > &__submatches, regex_constants::match_flag_type __m=regex_constants::match_default)
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, initializer_list< int > __submatches, regex_constants::match_flag_type __m=regex_constants::match_default)
regex_token_iterator & operator++()
Increments a regex_token_iterator.
bool operator!=(const regex_token_iterator &__rhs) const
Compares a regex_token_iterator to another for inequality.
regex_token_iterator operator++(int)
Postincrements a regex_token_iterator.
regex_token_iterator()
Default constructs a regex_token_iterator.
regex_token_iterator & operator=(const regex_token_iterator &__rhs)
Assigns a regex_token_iterator to another.
const value_type * operator->() const
Selects a regex_token_iterator member.
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, int __submatch=0, regex_constants::match_flag_type __m=regex_constants::match_default)
A smart pointer with reference-counted copy semantics.
Forward iterators support a superset of input iterator operations.
Struct holding two objects of arbitrary type.
_BiIter first
The first member.
_BiIter second
The second member.
A standard container which offers fixed time access to individual elements in any order.
bool empty() const noexcept
allocator_type get_allocator() const noexcept
Get a copy of the memory allocation object.
size_type max_size() const noexcept
void assign(size_type __n, const value_type &__val)
Assigns a given value to a vector.
void swap(vector &__x) noexcept
Swaps data with another vector.
iterator begin() noexcept
size_type size() const noexcept
reference operator[](size_type __n) noexcept
Subscript access to the data contained in the vector.