31 namespace std _GLIBCXX_VISIBILITY(default)
33 _GLIBCXX_BEGIN_NAMESPACE_VERSION
34 _GLIBCXX_BEGIN_NAMESPACE_CXX11
35 template<
typename,
typename>
38 template<
typename _Bi_iter,
typename _Alloc>
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>
61 template<
typename _Tp>
64 template<
typename _Tp>
65 struct __is_contiguous_iter<_Tp*> :
true_type { };
67 template<
typename _Tp,
typename _Cont>
68 struct __is_contiguous_iter<
__gnu_cxx::__normal_iterator<_Tp*, _Cont>>
72 _GLIBCXX_BEGIN_NAMESPACE_CXX11
89 template<
typename _Ch_type>
93 typedef _Ch_type char_type;
100 typedef std::ctype_base::mask _BaseType;
102 unsigned char _M_extended;
103 static constexpr
unsigned char _S_under = 1 << 0;
104 static constexpr
unsigned char _S_valid_mask = 0x1;
106 constexpr _RegexMask(_BaseType
__base = 0,
107 unsigned char __extended = 0)
108 : _M_base(
__base), _M_extended(__extended)
114 return _RegexMask(_M_base & __other._M_base,
115 _M_extended & __other._M_extended);
121 return _RegexMask(_M_base | __other._M_base,
122 _M_extended | __other._M_extended);
128 return _RegexMask(_M_base ^ __other._M_base,
129 _M_extended ^ __other._M_extended);
134 {
return _RegexMask(~_M_base, ~_M_extended); }
137 operator&=(_RegexMask __other)
138 {
return *
this = (*this) & __other; }
141 operator|=(_RegexMask __other)
142 {
return *
this = (*this) | __other; }
145 operator^=(_RegexMask __other)
146 {
return *
this = (*this) ^ __other; }
149 operator==(_RegexMask __other)
const
151 return (_M_extended & _S_valid_mask)
152 == (__other._M_extended & _S_valid_mask)
153 && _M_base == __other._M_base;
156 #if __cpp_impl_three_way_comparison < 201907L
158 operator!=(_RegexMask __other)
const
159 {
return !((*this) == __other); }
164 typedef _RegexMask char_class_type;
184 {
return string_type::traits_type::length(__p); }
210 const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
211 return __fctyp.tolower(__c);
234 template<
typename _Fwd_iter>
239 const __collate_type& __fclt(use_facet<__collate_type>(_M_locale));
241 return __fclt.transform(__s.
data(), __s.
data() + __s.
size());
258 template<
typename _Fwd_iter>
269 const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
286 template<
typename _Fwd_iter>
327 template<
typename _Fwd_iter>
330 bool __icase =
false)
const;
345 isctype(_Ch_type __c, char_class_type __f)
const;
358 value(_Ch_type __ch,
int __radix)
const;
384 {
return _M_locale; }
387 locale_type _M_locale;
398 template<
typename _Ch_type,
typename _Rx_traits = regex_traits<_Ch_type>>
403 "regex traits class must have the same char_type");
406 typedef _Ch_type value_type;
407 typedef _Rx_traits traits_type;
408 typedef typename traits_type::string_type string_type;
410 typedef typename traits_type::locale_type locale_type;
427 #if __cplusplus >= 201703L || !defined __STRICT_ANSI__
438 : _M_flags(ECMAScript), _M_loc(), _M_automaton(
nullptr)
454 { _M_compile(__p, __p + _Rx_traits::length(__p), __f); }
470 { _M_compile(__p, __p + __len, __f); }
495 template<
typename _Ch_traits,
typename _Ch_alloc>
500 { _M_compile(__s.data(), __s.data() + __s.size(), __f); }
515 template<
typename _FwdIter>
518 { this->
assign(__first, __last, __f); }
529 { _M_compile(__l.begin(), __l.end(), __f); }
558 {
return this->
assign(__p); }
570 {
return this->
assign(__l); }
578 template<
typename _Ch_traits,
typename _Alloc>
581 {
return this->
assign(__s); }
591 {
return *
this = __rhs; }
618 _M_compile(__p, __p + _Rx_traits::length(__p), __flags);
640 _M_compile(__p, __p + __len, __flags);
655 template<
typename _Ch_traits,
typename _Alloc>
660 _M_compile(__s.
data(), __s.
data() + __s.
size(), __flags);
677 template<
typename _InputIterator>
679 assign(_InputIterator __first, _InputIterator __last,
682 #if __cplusplus >= 201703L
684 if constexpr (__detail::__is_contiguous_iter<_InputIterator>::value
685 && is_same_v<_ValT, value_type>)
687 const auto __len = __last - __first;
688 const _Ch_type* __p = std::__to_address(__first);
689 _M_compile(__p, __p + __len, __flags);
693 this->
assign(string_type(__first, __last), __flags);
711 _M_compile(__l.begin(), __l.end(), __flags);
724 return _M_automaton->_M_sub_count() - 1;
746 _M_automaton.reset();
769 std::swap(_M_automaton, __rhs._M_automaton);
772 #ifdef _GLIBCXX_DEBUG
775 { _M_automaton->_M_dot(__ostr); }
782 _M_compile(
const _Ch_type* __first,
const _Ch_type* __last,
785 __detail::_Compiler<_Rx_traits> __c(__first, __last, _M_loc, __f);
786 _M_automaton = __c._M_get_nfa();
790 template<
typename _Bp,
typename _Ap,
typename _Cp,
typename _Rp,
791 __detail::_RegexExecutorPolicy,
bool>
793 __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
794 const basic_regex<_Cp, _Rp>&,
797 template<
typename,
typename,
typename,
bool>
798 friend class __detail::_Executor;
802 _AutomatonPtr _M_automaton;
805 #if __cplusplus < 201703L
806 template<
typename _Ch,
typename _Tr>
810 template<
typename _Ch,
typename _Tr>
814 template<
typename _Ch,
typename _Tr>
818 template<
typename _Ch,
typename _Tr>
822 template<
typename _Ch,
typename _Tr>
826 template<
typename _Ch,
typename _Tr>
830 template<
typename _Ch,
typename _Tr>
834 template<
typename _Ch,
typename _Tr>
838 template<
typename _Ch,
typename _Tr>
842 template<
typename _Ch,
typename _Tr>
847 #if __cpp_deduction_guides >= 201606
848 template<
typename _ForwardIterator>
849 basic_regex(_ForwardIterator, _ForwardIterator,
851 -> basic_regex<
typename iterator_traits<_ForwardIterator>::value_type>;
857 #ifdef _GLIBCXX_USE_WCHAR_T
870 template<
typename _Ch_type,
typename _Rx_traits>
874 { __lhs.swap(__rhs); }
890 template<
typename _BiIter>
896 typedef typename __iter_traits::value_type value_type;
897 typedef typename __iter_traits::difference_type difference_type;
898 typedef _BiIter iterator;
903 constexpr
sub_match() noexcept : matched() { }
920 operator string_type()
const
947 {
return this->_M_str().compare(__s._M_str()); }
961 {
return this->_M_str().compare(__s); }
965 {
return this->_M_str().compare(__s); }
971 _M_compare(
const value_type* __s,
size_t __n)
const
972 {
return this->_M_str().compare({__s, __n}); }
979 using traits_type =
typename string_type::traits_type;
981 __string_view() =
default;
983 __string_view(
const value_type* __s,
size_t __n) noexcept
984 : _M_data(__s), _M_len(__n) { }
986 __string_view(
const value_type* __s) noexcept
987 : _M_data(__s), _M_len(traits_type::length(__s)) { }
989 __string_view(
const string_type& __s) noexcept
990 : _M_data(__s.data()), _M_len(__s.length()) { }
993 compare(__string_view __s)
const noexcept
995 if (
const size_t __n =
std::min(_M_len, __s._M_len))
996 if (
int __ret = traits_type::compare(_M_data, __s._M_data, __n))
999 const difference_type __diff = _M_len - __s._M_len;
1000 if (__diff > __limits::__max)
1001 return __limits::__max;
1002 if (__diff < __limits::__min)
1003 return __limits::__min;
1004 return static_cast<int>(__diff);
1008 const value_type* _M_data =
nullptr;
1013 template<
typename _Iter = _BiIter>
1014 __enable_if_t<__detail::__is_contiguous_iter<_Iter>::value,
1016 _M_str() const noexcept
1025 template<
typename _Iter = _BiIter>
1026 __enable_if_t<!__detail::__is_contiguous_iter<_Iter>::value,
1039 #ifdef _GLIBCXX_USE_WCHAR_T
1057 template<
typename _BiIter>
1060 {
return __lhs.
compare(__rhs) == 0; }
1062 #if __cpp_lib_three_way_comparison
1070 template<
typename _BiIter>
1074 noexcept(__detail::__is_contiguous_iter<_BiIter>::value)
1077 return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
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; }
1119 template<
typename _BiIter>
1122 {
return __lhs.
compare(__rhs) >= 0; }
1130 template<
typename _BiIter>
1133 {
return __lhs.
compare(__rhs) > 0; }
1139 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1142 _Ch_traits, _Ch_alloc>;
1145 #if ! __cpp_lib_three_way_comparison
1153 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1155 operator==(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1157 {
return __rhs._M_compare(__lhs.data(), __lhs.size()) == 0; }
1166 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1168 operator!=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1170 {
return !(__lhs == __rhs); }
1178 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1180 operator<(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1182 {
return __rhs._M_compare(__lhs.data(), __lhs.size()) > 0; }
1190 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1192 operator>(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1194 {
return __rhs < __lhs; }
1202 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1204 operator>=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1206 {
return !(__lhs < __rhs); }
1214 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1216 operator<=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1218 {
return !(__rhs < __lhs); }
1228 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1231 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1232 {
return __lhs._M_compare(__rhs.data(), __rhs.size()) == 0; }
1234 #if __cpp_lib_three_way_comparison
1242 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Alloc>
1245 const __sub_match_string<_Bi_iter, _Ch_traits, _Alloc>& __rhs)
1246 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1248 return __detail::__char_traits_cmp_cat<_Ch_traits>(
1249 __lhs._M_compare(__rhs.data(), __rhs.size()));
1259 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1262 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1263 {
return !(__lhs == __rhs); }
1271 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1274 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1275 {
return __lhs._M_compare(__rhs.data(), __rhs.size()) < 0; }
1283 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1286 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1287 {
return __rhs < __lhs; }
1295 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1298 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1299 {
return !(__lhs < __rhs); }
1307 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1310 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1311 {
return !(__rhs < __lhs); }
1320 template<
typename _Bi_iter>
1324 {
return __rhs.
compare(__lhs) == 0; }
1333 template<
typename _Bi_iter>
1337 {
return !(__lhs == __rhs); }
1345 template<
typename _Bi_iter>
1349 {
return __rhs.
compare(__lhs) > 0; }
1357 template<
typename _Bi_iter>
1361 {
return __rhs < __lhs; }
1369 template<
typename _Bi_iter>
1373 {
return !(__lhs < __rhs); }
1381 template<
typename _Bi_iter>
1385 {
return !(__rhs < __lhs); }
1395 template<
typename _Bi_iter>
1399 {
return __lhs.
compare(__rhs) == 0; }
1401 #if __cpp_lib_three_way_comparison
1410 template<
typename _Bi_iter>
1414 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1417 return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
1427 template<
typename _Bi_iter>
1431 {
return !(__lhs == __rhs); }
1439 template<
typename _Bi_iter>
1443 {
return __lhs.
compare(__rhs) < 0; }
1451 template<
typename _Bi_iter>
1455 {
return __rhs < __lhs; }
1463 template<
typename _Bi_iter>
1467 {
return !(__lhs < __rhs); }
1475 template<
typename _Bi_iter>
1479 {
return !(__rhs < __lhs); }
1488 template<
typename _Bi_iter>
1501 template<
typename _Bi_iter>
1505 {
return !(__lhs == __rhs); }
1514 template<
typename _Bi_iter>
1527 template<
typename _Bi_iter>
1531 {
return __rhs < __lhs; }
1540 template<
typename _Bi_iter>
1544 {
return !(__lhs < __rhs); }
1553 template<
typename _Bi_iter>
1557 {
return !(__rhs < __lhs); }
1567 template<
typename _Bi_iter>
1573 #if __cpp_lib_three_way_comparison
1583 template<
typename _Bi_iter>
1587 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1590 return __detail::__char_traits_cmp_cat<_Tr>(
1601 template<
typename _Bi_iter>
1605 {
return !(__lhs == __rhs); }
1614 template<
typename _Bi_iter>
1627 template<
typename _Bi_iter>
1631 {
return __rhs < __lhs; }
1640 template<
typename _Bi_iter>
1644 {
return !(__lhs < __rhs); }
1653 template<
typename _Bi_iter>
1657 {
return !(__rhs < __lhs); }
1668 template<
typename _Ch_type,
typename _Ch_traits,
typename _Bi_iter>
1673 {
return __os << __m.
str(); }
1699 template<
typename _Bi_iter,
1700 typename _Alloc = allocator<sub_match<_Bi_iter> > >
1702 :
private std::vector<sub_match<_Bi_iter>, _Alloc>
1733 typedef typename _Base_type::const_iterator const_iterator;
1734 typedef const_iterator iterator;
1735 typedef typename __iter_traits::difference_type difference_type;
1737 typedef _Alloc allocator_type;
1738 typedef typename __iter_traits::value_type char_type;
1827 _GLIBCXX_NODISCARD
bool
1848 {
return (*
this)[__sub].length(); }
1875 str(size_type __sub = 0)
const
1892 __glibcxx_assert(
ready() );
1893 return __sub <
size()
1895 : _M_unmatched_sub();
1909 __glibcxx_assert(
ready() );
1910 return !
empty() ? _M_prefix() : _M_unmatched_sub();
1924 __glibcxx_assert(
ready() );
1925 return !
empty() ? _M_suffix() : _M_unmatched_sub();
1940 {
return this->
begin(); }
1954 {
return this->
end(); }
1971 template<
typename _Out_iter>
1973 format(_Out_iter __out,
const char_type* __fmt_first,
1974 const char_type* __fmt_last,
1980 template<
typename _Out_iter,
typename _St,
typename _Sa>
1992 template<
typename _St,
typename _Sa>
2046 swap(_M_begin, __that._M_begin);
2051 template<
typename,
typename,
typename>
2056 template<
typename,
typename,
typename,
bool>
2059 template<
typename _Bp,
typename _Ap,
typename _Cp,
typename _Rp,
2060 __detail::_RegexExecutorPolicy,
bool>
2069 _M_resize(
unsigned int __size)
2074 _M_establish_failed_match(_Bi_iter __end)
2076 sub_match<_Bi_iter> __sm;
2077 __sm.first = __sm.second = __end;
2082 _M_unmatched_sub()
const
2085 sub_match<_Bi_iter>&
2093 sub_match<_Bi_iter>&
2101 sub_match<_Bi_iter>&
2105 _Bi_iter _M_begin {};
2109 typedef match_results<const char*> cmatch;
2110 typedef match_results<string::const_iterator> smatch;
2111 #ifdef _GLIBCXX_USE_WCHAR_T
2112 typedef match_results<const wchar_t*> wcmatch;
2113 typedef match_results<wstring::const_iterator> wsmatch;
2123 template<
typename _Bi_iter,
typename _Alloc>
2142 #if ! __cpp_lib_three_way_comparison
2148 template<
typename _Bi_iter,
class _Alloc>
2152 {
return !(__m1 == __m2); }
2163 template<
typename _Bi_iter,
typename _Alloc>
2167 { __lhs.swap(__rhs); }
2169 _GLIBCXX_END_NAMESPACE_CXX11
2192 template<
typename _Bi_iter,
typename _Alloc,
2193 typename _Ch_type,
typename _Rx_traits>
2202 return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
2203 __detail::_RegexExecutorPolicy::_S_auto,
true>
2204 (__s, __e, __m, __re, __flags);
2221 template<
typename _Bi_iter,
typename _Ch_type,
typename _Rx_traits>
2229 return regex_match(__first, __last, __what, __re, __flags);
2246 template<
typename _Ch_type,
typename _Alloc,
typename _Rx_traits>
2253 {
return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
2269 template<
typename _Ch_traits,
typename _Ch_alloc,
2270 typename _Alloc,
typename _Ch_type,
typename _Rx_traits>
2274 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2283 template<
typename _Ch_traits,
typename _Ch_alloc,
2284 typename _Alloc,
typename _Ch_type,
typename _Rx_traits>
2288 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2306 template<
typename _Ch_type,
class _Rx_traits>
2312 {
return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
2327 template<
typename _Ch_traits,
typename _Str_allocator,
2328 typename _Ch_type,
typename _Rx_traits>
2350 template<
typename _Bi_iter,
typename _Alloc,
2351 typename _Ch_type,
typename _Rx_traits>
2359 return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
2360 __detail::_RegexExecutorPolicy::_S_auto,
false>
2361 (__s, __e, __m, __re, __flags);
2375 template<
typename _Bi_iter,
typename _Ch_type,
typename _Rx_traits>
2383 return regex_search(__first, __last, __what, __re, __flags);
2398 template<
typename _Ch_type,
class _Alloc,
class _Rx_traits>
2405 {
return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
2417 template<
typename _Ch_type,
typename _Rx_traits>
2423 {
return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
2435 template<
typename _Ch_traits,
typename _String_allocator,
2436 typename _Ch_type,
typename _Rx_traits>
2439 _String_allocator>& __s,
2443 {
return regex_search(__s.begin(), __s.end(), __e, __flags); }
2457 template<
typename _Ch_traits,
typename _Ch_alloc,
2458 typename _Alloc,
typename _Ch_type,
2459 typename _Rx_traits>
2463 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2472 template<
typename _Ch_traits,
typename _Ch_alloc,
2473 typename _Alloc,
typename _Ch_type,
2474 typename _Rx_traits>
2478 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2485 template<
typename _Out_iter,
typename _Bi_iter,
2486 typename _Rx_traits,
typename _Ch_type>
2490 const _Ch_type* __fmt,
size_t __len,
2506 template<
typename _Out_iter,
typename _Bi_iter,
2507 typename _Rx_traits,
typename _Ch_type,
2508 typename _St,
typename _Sa>
2517 __fmt.
length(), __flags);
2533 template<
typename _Out_iter,
typename _Bi_iter,
2534 typename _Rx_traits,
typename _Ch_type>
2538 const _Ch_type* __fmt,
2559 template<
typename _Rx_traits,
typename _Ch_type,
2560 typename _St,
typename _Sa,
typename _Fst,
typename _Fsa>
2561 inline basic_string<_Ch_type, _St, _Sa>
2570 __s.
begin(), __s.
end(), __e, __fmt, __flags);
2585 template<
typename _Rx_traits,
typename _Ch_type,
2586 typename _St,
typename _Sa>
2587 inline basic_string<_Ch_type, _St, _Sa>
2590 const _Ch_type* __fmt,
2596 __s.
begin(), __s.
end(), __e, __fmt, __flags);
2611 template<
typename _Rx_traits,
typename _Ch_type,
2612 typename _St,
typename _Sa>
2613 inline basic_string<_Ch_type>
2623 __e, __fmt, __flags);
2638 template<
typename _Rx_traits,
typename _Ch_type>
2639 inline basic_string<_Ch_type>
2642 const _Ch_type* __fmt,
2649 __e, __fmt, __flags);
2655 _GLIBCXX_BEGIN_NAMESPACE_CXX11
2662 template<
typename _Bi_iter,
2663 typename _Ch_type =
typename iterator_traits<_Bi_iter>::value_type,
2664 typename _Rx_traits = regex_traits<_Ch_type> >
2670 typedef std::ptrdiff_t difference_type;
2671 typedef const value_type* pointer;
2672 typedef const value_type& reference;
2691 : _M_begin(__a), _M_end(__b), _M_pregex(&__re), _M_flags(__m), _M_match()
2693 if (!
regex_search(_M_begin, _M_end, _M_match, *_M_pregex, _M_flags))
2723 {
return !(*
this == __rhs); }
2730 {
return _M_match; }
2737 {
return &_M_match; }
2757 _Bi_iter _M_begin {};
2759 const regex_type* _M_pregex =
nullptr;
2761 match_results<_Bi_iter> _M_match;
2764 typedef regex_iterator<const char*> cregex_iterator;
2765 typedef regex_iterator<string::const_iterator> sregex_iterator;
2766 #ifdef _GLIBCXX_USE_WCHAR_T
2767 typedef regex_iterator<const wchar_t*> wcregex_iterator;
2768 typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
2779 template<
typename _Bi_iter,
2780 typename _Ch_type =
typename iterator_traits<_Bi_iter>::value_type,
2781 typename _Rx_traits = regex_traits<_Ch_type> >
2787 typedef std::ptrdiff_t difference_type;
2801 : _M_position(), _M_subs(), _M_suffix(), _M_n(0), _M_result(nullptr),
2826 : _M_position(__a, __b, __re, __m), _M_subs(1, __submatch), _M_n(0)
2827 { _M_init(__a, __b); }
2843 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2844 { _M_init(__a, __b); }
2860 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2861 { _M_init(__a, __b); }
2872 template<std::
size_t _Nm>
2875 const int (&__submatches)[_Nm],
2878 : _M_position(__a, __b, __re, __m),
2879 _M_subs(__submatches, __submatches + _Nm), _M_n(0)
2880 { _M_init(__a, __b); }
2895 template <std::
size_t _Nm>
2906 : _M_position(__rhs._M_position), _M_subs(__rhs._M_subs),
2907 _M_suffix(__rhs._M_suffix), _M_n(__rhs._M_n), _M_has_m1(__rhs._M_has_m1)
2908 { _M_normalize_result(); }
2928 {
return !(*
this == __rhs); }
2935 {
return *_M_result; }
2942 {
return _M_result; }
2965 _M_init(_Bi_iter __a, _Bi_iter __b);
2968 _M_current_match()
const
2970 if (_M_subs[_M_n] == -1)
2971 return (*_M_position).prefix();
2973 return (*_M_position)[_M_subs[_M_n]];
2977 _M_end_of_seq()
const
2978 {
return _M_result ==
nullptr; }
2982 _M_normalize_result()
2984 if (_M_position != _Position())
2985 _M_result = &_M_current_match();
2987 _M_result = &_M_suffix;
2989 _M_result =
nullptr;
2992 _Position _M_position;
2994 value_type _M_suffix;
2996 const value_type* _M_result;
3008 #ifdef _GLIBCXX_USE_WCHAR_T
3018 _GLIBCXX_END_NAMESPACE_CXX11
3019 _GLIBCXX_END_NAMESPACE_VERSION
integral_constant< bool, true > true_type
The type used as a compile-time boolean with true value.
integral_constant< bool, false > false_type
The type used as a compile-time boolean with false value.
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.
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.
_Out_iter __regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, const basic_regex< _Ch_type, _Rx_traits > &__e, const _Ch_type *__fmt, size_t __len, regex_constants::match_flag_type __flags)
Determines if there is a match between the regular expression e and all of the character sequence [fi...
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.
void swap(basic_regex< _Ch_type, _Rx_traits > &__lhs, basic_regex< _Ch_type, _Rx_traits > &__rhs) noexcept
Swaps the contents of two regular expression objects.
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.
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.
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
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.
GNU extensions for public use.
__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 syntax_option_type multiline
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 length() const noexcept
Returns the number of characters in the string, not including any null-termination.
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.
locale_type getloc() const noexcept
Gets the locale currently imbued in the regular expression object.
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
Move-assigns one regular expression to another.
unsigned int mark_count() const noexcept
Gets the number of marked subexpressions within the regular expression.
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(const basic_regex &__rhs)=default
Copy-constructs a basic regular expression.
flag_type flags() const noexcept
Gets the flags used to construct the regular expression or in the last call to assign().
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(const _Ch_type *__p, flag_type __f=ECMAScript)
Constructs a basic regular expression from the sequence [__p, __p + char_traits<_Ch_type>::length(__p...
void swap(basic_regex &__rhs) noexcept
Swaps the contents of two regular expression objects.
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.
basic_regex & operator=(const basic_regex &)=default
Assigns one regular expression to another.
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 basic_regex &__rhs) noexcept
Assigns one regular expression to another.
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...
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 & operator=(basic_regex &&)=default
Move-assigns one regular expression to another.
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.