31#if __cplusplus >= 202002L
35namespace std _GLIBCXX_VISIBILITY(default)
37_GLIBCXX_BEGIN_NAMESPACE_VERSION
38_GLIBCXX_BEGIN_NAMESPACE_CXX11
39 template<
typename,
typename>
42 template<
typename _Bi_iter,
typename _Alloc>
45_GLIBCXX_END_NAMESPACE_CXX11
49 enum class _RegexExecutorPolicy :
int { _S_auto, _S_alternate };
51 template<
typename _BiIter,
typename _Alloc,
52 typename _CharT,
typename _TraitsT>
54 __regex_algo_impl(_BiIter __s, _BiIter __e,
55 match_results<_BiIter, _Alloc>& __m,
56 const basic_regex<_CharT, _TraitsT>& __re,
58 _RegexExecutorPolicy __policy,
61 template<
typename,
typename,
typename,
bool>
64 template<
typename _Tp>
67 template<
typename _Tp>
68 struct __is_contiguous_iter<_Tp*> :
true_type { };
70 template<
typename _Tp,
typename _Cont>
71 struct __is_contiguous_iter<__gnu_cxx::__normal_iterator<_Tp*, _Cont>>
75_GLIBCXX_BEGIN_NAMESPACE_CXX11
95 template<
typename _Ch_type>
99 typedef _Ch_type char_type;
106 typedef std::ctype_base::mask _BaseType;
108 unsigned char _M_extended;
109 static constexpr unsigned char _S_under = 1 << 0;
110 static constexpr unsigned char _S_valid_mask = 0x1;
112 constexpr _RegexMask(_BaseType __base = 0,
113 unsigned char __extended = 0)
114 : _M_base(__base), _M_extended(__extended)
120 return _RegexMask(_M_base & __other._M_base,
121 _M_extended & __other._M_extended);
127 return _RegexMask(_M_base | __other._M_base,
128 _M_extended | __other._M_extended);
134 return _RegexMask(_M_base ^ __other._M_base,
135 _M_extended ^ __other._M_extended);
140 {
return _RegexMask(~_M_base, ~_M_extended); }
143 operator&=(_RegexMask __other)
144 {
return *
this = (*this) & __other; }
147 operator|=(_RegexMask __other)
148 {
return *
this = (*this) | __other; }
151 operator^=(_RegexMask __other)
152 {
return *
this = (*this) ^ __other; }
155 operator==(_RegexMask __other)
const
157 return (_M_extended & _S_valid_mask)
158 == (__other._M_extended & _S_valid_mask)
159 && _M_base == __other._M_base;
162#if __cpp_impl_three_way_comparison < 201907L
164 operator!=(_RegexMask __other)
const
165 {
return !((*this) == __other); }
170 typedef _RegexMask char_class_type;
217 return __fctyp.tolower(__c);
240 template<
typename _Fwd_iter>
244 typedef std::collate<char_type> __collate_type;
246 string_type __s(__first, __last);
247 return __fclt.transform(__s.
data(), __s.
data() + __s.
size());
264 template<
typename _Fwd_iter>
276 _GLIBCXX_STD_C::vector<char_type> __s(__first, __last);
277 __fctyp.tolower(__s.data(), __s.data() + __s.size());
278 return this->
transform(__s.data(), __s.data() + __s.size());
292 template<
typename _Fwd_iter>
333 template<
typename _Fwd_iter>
336 bool __icase =
false)
const;
351 isctype(_Ch_type __c, char_class_type __f)
const;
364 value(_Ch_type __ch,
int __radix)
const;
380 std::swap(_M_locale, __loc);
390 {
return _M_locale; }
393 locale_type _M_locale;
417 template<
typename _Ch_type,
typename _Rx_traits = regex_traits<_Ch_type>>
422 "regex traits class must have the same char_type");
425 typedef _Ch_type value_type;
426 typedef _Rx_traits traits_type;
427 typedef typename traits_type::string_type string_type;
429 typedef typename traits_type::locale_type locale_type;
446#if __cplusplus >= 201703L || !defined __STRICT_ANSI__
457 : _M_flags(ECMAScript), _M_loc(), _M_automaton(
nullptr)
473 { _M_compile(__p, __p + _Rx_traits::length(__p), __f); }
488 flag_type __f = ECMAScript)
490 __glibcxx_requires_string_len(__p, __len);
491 _M_compile(__p, __p + __len, __f);
517 template<
typename _Ch_traits,
typename _Ch_alloc>
521 flag_type __f = ECMAScript)
522 { _M_compile(__s.data(), __s.data() + __s.size(), __f); }
537 template<
typename _FwdIter>
539 flag_type __f = ECMAScript)
540 { this->
assign(__first, __last, __f); }
551 { _M_compile(__l.begin(), __l.end(), __f); }
580 {
return this->
assign(__p); }
592 {
return this->
assign(__l); }
600 template<
typename _Ch_traits,
typename _Alloc>
603 {
return this->
assign(__s); }
613 {
return *
this = __rhs; }
638 assign(
const _Ch_type* __p, flag_type __flags = ECMAScript)
640 _M_compile(__p, __p + _Rx_traits::length(__p), __flags);
660 assign(
const _Ch_type* __p,
size_t __len, flag_type __flags = ECMAScript)
662 _M_compile(__p, __p + __len, __flags);
677 template<
typename _Ch_traits,
typename _Alloc>
680 flag_type __flags = ECMAScript)
682 _M_compile(__s.
data(), __s.
data() + __s.
size(), __flags);
699 template<
typename _InputIterator>
701 assign(_InputIterator __first, _InputIterator __last,
702 flag_type __flags = ECMAScript)
704#if __cpp_if_constexpr >= 201606L
706 if constexpr (__detail::__is_contiguous_iter<_InputIterator>::value
707 && is_same_v<_ValT, value_type>)
709 __glibcxx_requires_valid_range(__first, __last);
710 if constexpr (is_pointer_v<_InputIterator>)
711 _M_compile(__first, __last, __flags);
713 _M_compile(__first.base(), __last.base(), __flags);
717 this->
assign(string_type(__first, __last), __flags);
735 _M_compile(__l.begin(), __l.end(), __flags);
748 return _M_automaton->_M_sub_count() - 1;
769 std::swap(__loc, _M_loc);
770 _M_automaton.reset();
791 std::swap(_M_flags, __rhs._M_flags);
792 std::swap(_M_loc, __rhs._M_loc);
793 std::swap(_M_automaton, __rhs._M_automaton);
799 { _M_automaton->_M_dot(__ostr); }
806 _M_compile(
const _Ch_type* __first,
const _Ch_type* __last,
809 __detail::_Compiler<_Rx_traits> __c(__first, __last, _M_loc, __f);
810 _M_automaton = __c._M_get_nfa();
814 template<
typename _Bp,
typename _Ap,
typename _Cp,
typename _Rp>
816 __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
819 __detail::_RegexExecutorPolicy,
bool);
821 template<
typename,
typename,
typename,
bool>
822 friend class __detail::_Executor;
826 _AutomatonPtr _M_automaton;
829#if ! __cpp_inline_variables
830 template<
typename _Ch,
typename _Tr>
832 basic_regex<_Ch, _Tr>::icase;
834 template<
typename _Ch,
typename _Tr>
836 basic_regex<_Ch, _Tr>::nosubs;
838 template<
typename _Ch,
typename _Tr>
840 basic_regex<_Ch, _Tr>::optimize;
842 template<
typename _Ch,
typename _Tr>
844 basic_regex<_Ch, _Tr>::collate;
846 template<
typename _Ch,
typename _Tr>
848 basic_regex<_Ch, _Tr>::ECMAScript;
850 template<
typename _Ch,
typename _Tr>
852 basic_regex<_Ch, _Tr>::basic;
854 template<
typename _Ch,
typename _Tr>
856 basic_regex<_Ch, _Tr>::extended;
858 template<
typename _Ch,
typename _Tr>
860 basic_regex<_Ch, _Tr>::awk;
862 template<
typename _Ch,
typename _Tr>
864 basic_regex<_Ch, _Tr>::grep;
866 template<
typename _Ch,
typename _Tr>
868 basic_regex<_Ch, _Tr>::egrep;
871#if __cpp_deduction_guides >= 201606
872 template<
typename _ForwardIterator>
881#ifdef _GLIBCXX_USE_WCHAR_T
894 template<
typename _Ch_type,
typename _Rx_traits>
898 { __lhs.swap(__rhs); }
919 template<
typename _BiIter>
928 typedef typename __iter_traits::value_type value_type;
929 typedef typename __iter_traits::difference_type difference_type;
930 typedef _BiIter iterator;
933 _GLIBCXX_DOXYGEN_ONLY(iterator first; iterator second;)
937 constexpr sub_match() noexcept : matched() { }
942 {
return this->matched ?
std::distance(this->first, this->second) : 0; }
954 operator string_type()
const
966 ? string_type(this->first, this->second)
981 {
return this->_M_str().compare(__s._M_str()); }
995 {
return this->_M_str().compare(__s); }
999 {
return this->_M_str().compare(__s); }
1005 _M_compare(
const value_type* __s,
size_t __n)
const
1006 {
return this->_M_str().compare({__s, __n}); }
1013 swap(sub_match& __s)
noexcept(__is_nothrow_swappable<_BiIter>::value)
1016 std::swap(matched, __s.matched);
1021 struct __string_view
1023 using traits_type =
typename string_type::traits_type;
1025 __string_view() =
default;
1027 __string_view(
const value_type* __s,
size_t __n) noexcept
1028 : _M_data(__s), _M_len(__n) { }
1030 __string_view(
const value_type* __s) noexcept
1031 : _M_data(__s), _M_len(traits_type::length(__s)) { }
1033 __string_view(
const string_type& __s) noexcept
1034 : _M_data(__s.data()), _M_len(__s.length()) { }
1037 compare(__string_view __s)
const noexcept
1039 if (
const size_t __n =
std::min(_M_len, __s._M_len))
1040 if (
int __ret = traits_type::compare(_M_data, __s._M_data, __n))
1043 const difference_type __diff = _M_len - __s._M_len;
1044 if (__diff > __limits::__max)
1045 return __limits::__max;
1046 if (__diff < __limits::__min)
1047 return __limits::__min;
1048 return static_cast<int>(__diff);
1052 const value_type* _M_data =
nullptr;
1057 template<
typename _Iter = _BiIter>
1058 __enable_if_t<__detail::__is_contiguous_iter<_Iter>::value,
1060 _M_str() const noexcept
1063 if (
size_t __len = this->second - this->first)
1069 template<
typename _Iter = _BiIter>
1070 __enable_if_t<!__detail::__is_contiguous_iter<_Iter>::value,
1083#ifdef _GLIBCXX_USE_WCHAR_T
1101 template<
typename _BiIter>
1103 operator==(
const sub_match<_BiIter>& __lhs,
const sub_match<_BiIter>& __rhs)
1104 {
return __lhs.
compare(__rhs) == 0; }
1106#if __cpp_lib_three_way_comparison
1114 template<
typename _BiIter>
1117 const sub_match<_BiIter>& __rhs)
1118 noexcept(__detail::__is_contiguous_iter<_BiIter>::value)
1121 return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
1130 template<
typename _BiIter>
1133 {
return __lhs.
compare(__rhs) != 0; }
1141 template<
typename _BiIter>
1143 operator<(
const sub_match<_BiIter>& __lhs,
const sub_match<_BiIter>& __rhs)
1144 {
return __lhs.compare(__rhs) < 0; }
1152 template<
typename _BiIter>
1155 {
return __lhs.compare(__rhs) <= 0; }
1163 template<
typename _BiIter>
1166 {
return __lhs.compare(__rhs) >= 0; }
1174 template<
typename _BiIter>
1177 {
return __lhs.compare(__rhs) > 0; }
1183 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1186 _Ch_traits, _Ch_alloc>;
1189#if ! __cpp_lib_three_way_comparison
1197 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1199 operator==(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1201 {
return __rhs._M_compare(__lhs.data(), __lhs.size()) == 0; }
1210 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1212 operator!=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1214 {
return !(__lhs == __rhs); }
1222 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1224 operator<(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1226 {
return __rhs._M_compare(__lhs.data(), __lhs.size()) > 0; }
1234 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1236 operator>(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1238 {
return __rhs < __lhs; }
1246 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1248 operator>=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1250 {
return !(__lhs < __rhs); }
1258 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1260 operator<=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1262 {
return !(__rhs < __lhs); }
1272 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1275 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1276 {
return __lhs._M_compare(__rhs.data(), __rhs.size()) == 0; }
1278#if __cpp_lib_three_way_comparison
1286 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Alloc>
1289 const __sub_match_string<_Bi_iter, _Ch_traits, _Alloc>& __rhs)
1290 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1292 return __detail::__char_traits_cmp_cat<_Ch_traits>(
1293 __lhs._M_compare(__rhs.data(), __rhs.size()));
1303 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1306 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1307 {
return !(__lhs == __rhs); }
1315 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1317 operator<(
const sub_match<_Bi_iter>& __lhs,
1318 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1319 {
return __lhs._M_compare(__rhs.data(), __rhs.size()) < 0; }
1327 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1330 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1331 {
return __rhs < __lhs; }
1339 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1342 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1343 {
return !(__lhs < __rhs); }
1351 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1354 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1355 {
return !(__rhs < __lhs); }
1364 template<
typename _Bi_iter>
1368 {
return __rhs.compare(__lhs) == 0; }
1377 template<
typename _Bi_iter>
1381 {
return !(__lhs == __rhs); }
1389 template<
typename _Bi_iter>
1393 {
return __rhs.compare(__lhs) > 0; }
1401 template<
typename _Bi_iter>
1405 {
return __rhs < __lhs; }
1413 template<
typename _Bi_iter>
1417 {
return !(__lhs < __rhs); }
1425 template<
typename _Bi_iter>
1429 {
return !(__rhs < __lhs); }
1439 template<
typename _Bi_iter>
1443 {
return __lhs.
compare(__rhs) == 0; }
1445#if __cpp_lib_three_way_comparison
1454 template<
typename _Bi_iter>
1458 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1461 return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
1471 template<
typename _Bi_iter>
1475 {
return !(__lhs == __rhs); }
1483 template<
typename _Bi_iter>
1485 operator<(
const sub_match<_Bi_iter>& __lhs,
1486 typename iterator_traits<_Bi_iter>::value_type
const* __rhs)
1487 {
return __lhs.compare(__rhs) < 0; }
1495 template<
typename _Bi_iter>
1499 {
return __rhs < __lhs; }
1507 template<
typename _Bi_iter>
1511 {
return !(__lhs < __rhs); }
1519 template<
typename _Bi_iter>
1523 {
return !(__rhs < __lhs); }
1532 template<
typename _Bi_iter>
1545 template<
typename _Bi_iter>
1549 {
return !(__lhs == __rhs); }
1558 template<
typename _Bi_iter>
1571 template<
typename _Bi_iter>
1575 {
return __rhs < __lhs; }
1584 template<
typename _Bi_iter>
1588 {
return !(__lhs < __rhs); }
1597 template<
typename _Bi_iter>
1601 {
return !(__rhs < __lhs); }
1611 template<
typename _Bi_iter>
1617#if __cpp_lib_three_way_comparison
1627 template<
typename _Bi_iter>
1631 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1634 return __detail::__char_traits_cmp_cat<_Tr>(
1645 template<
typename _Bi_iter>
1649 {
return !(__lhs == __rhs); }
1658 template<
typename _Bi_iter>
1660 operator<(
const sub_match<_Bi_iter>& __lhs,
1661 typename iterator_traits<_Bi_iter>::value_type
const& __rhs)
1671 template<
typename _Bi_iter>
1675 {
return __rhs < __lhs; }
1684 template<
typename _Bi_iter>
1688 {
return !(__lhs < __rhs); }
1697 template<
typename _Bi_iter>
1701 {
return !(__rhs < __lhs); }
1712 template<
typename _Ch_type,
typename _Ch_traits,
typename _Bi_iter>
1717 {
return __os << __m.str(); }
1746 template<
typename _Bi_iter,
1749 :
private std::vector<sub_match<_Bi_iter>, _Alloc>
1770 typedef _GLIBCXX_STD_C::vector<sub_match<_Bi_iter>, _Alloc> _Unchecked;
1780 typedef const value_type& const_reference;
1781 typedef value_type& reference;
1782 typedef typename _Base_type::const_iterator const_iterator;
1783 typedef const_iterator iterator;
1784 typedef typename __iter_traits::difference_type difference_type;
1786 typedef _Alloc allocator_type;
1787 typedef typename __iter_traits::value_type char_type;
1843 : _Base_type(__m, __a) { }
1846 noexcept(
noexcept(_Base_type(
std::move(__m), __a)))
1847 : _Base_type(
std::
move(__m), __a) { }
1886 _GLIBCXX_NODISCARD
bool
1907 {
return (*
this)[__sub].length(); }
1934 str(size_type __sub = 0)
const
1935 {
return string_type((*
this)[__sub]); }
1951 __glibcxx_assert(
ready() );
1952 return __sub <
size()
1954 : _M_unmatched_sub();
1968 __glibcxx_assert(
ready() );
1969 return !
empty() ? _M_prefix() : _M_unmatched_sub();
1983 __glibcxx_assert(
ready() );
1984 return !
empty() ? _M_suffix() : _M_unmatched_sub();
1999 {
return this->
begin(); }
2013 {
return this->
end(); }
2030 template<
typename _Out_iter>
2032 format(_Out_iter __out,
const char_type* __fmt_first,
2033 const char_type* __fmt_last,
2039 template<
typename _Out_iter,
typename _St,
typename _Sa>
2051 template<
typename _St,
typename _Sa>
2068 string_type __result;
2071 __fmt + char_traits<char_type>::length(__fmt),
2105 swap(_M_begin, __that._M_begin);
2110 template<
typename,
typename,
typename>
2115 template<
typename,
typename,
typename,
bool>
2118 template<
typename _Bp,
typename _Ap,
typename _Cp,
typename _Rp>
2123 __detail::_RegexExecutorPolicy,
bool);
2128 _M_resize(
unsigned int __size)
2133 _M_establish_failed_match(_Bi_iter __end)
2135 sub_match<_Bi_iter> __sm;
2136 __sm.first = __sm.second = __end;
2141 _M_unmatched_sub()
const
2144 sub_match<_Bi_iter>&
2152 sub_match<_Bi_iter>&
2160 sub_match<_Bi_iter>&
2164 _Bi_iter _M_begin {};
2170#ifdef _GLIBCXX_USE_WCHAR_T
2184 template<
typename _Bi_iter,
typename _Alloc>
2203#if ! __cpp_lib_three_way_comparison
2211 template<
typename _Bi_iter,
class _Alloc>
2215 {
return !(__m1 == __m2); }
2228 template<
typename _Bi_iter,
typename _Alloc>
2232 { __lhs.swap(__rhs); }
2234_GLIBCXX_END_NAMESPACE_CXX11
2258 template<
typename _Bi_iter,
typename _Alloc,
2259 typename _Ch_type,
typename _Rx_traits>
2268 return __detail::__regex_algo_impl(__s, __e, __m, __re, __flags,
2269 __detail::_RegexExecutorPolicy::_S_auto,
true);
2286 template<
typename _Bi_iter,
typename _Ch_type,
typename _Rx_traits>
2294 return regex_match(__first, __last, __what, __re, __flags);
2311 template<
typename _Ch_type,
typename _Alloc,
typename _Rx_traits>
2318 {
return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
2334 template<
typename _Ch_traits,
typename _Ch_alloc,
2335 typename _Alloc,
typename _Ch_type,
typename _Rx_traits>
2339 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2348 template<
typename _Ch_traits,
typename _Ch_alloc,
2349 typename _Alloc,
typename _Ch_type,
typename _Rx_traits>
2353 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2371 template<
typename _Ch_type,
class _Rx_traits>
2377 {
return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
2392 template<
typename _Ch_traits,
typename _Str_allocator,
2393 typename _Ch_type,
typename _Rx_traits>
2415 template<
typename _Bi_iter,
typename _Alloc,
2416 typename _Ch_type,
typename _Rx_traits>
2424 return __detail::__regex_algo_impl(__s, __e, __m, __re, __flags,
2425 __detail::_RegexExecutorPolicy::_S_auto,
false);
2439 template<
typename _Bi_iter,
typename _Ch_type,
typename _Rx_traits>
2447 return regex_search(__first, __last, __what, __re, __flags);
2462 template<
typename _Ch_type,
class _Alloc,
class _Rx_traits>
2469 {
return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
2481 template<
typename _Ch_type,
typename _Rx_traits>
2487 {
return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
2499 template<
typename _Ch_traits,
typename _String_allocator,
2500 typename _Ch_type,
typename _Rx_traits>
2503 _String_allocator>& __s,
2507 {
return regex_search(__s.begin(), __s.end(), __e, __flags); }
2521 template<
typename _Ch_traits,
typename _Ch_alloc,
2522 typename _Alloc,
typename _Ch_type,
2523 typename _Rx_traits>
2527 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2536 template<
typename _Ch_traits,
typename _Ch_alloc,
2537 typename _Alloc,
typename _Ch_type,
2538 typename _Rx_traits>
2542 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2550 template<
typename _Out_iter,
typename _Bi_iter,
2551 typename _Rx_traits,
typename _Ch_type>
2553 __regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
2555 const _Ch_type* __fmt,
size_t __len,
2572 template<
typename _Out_iter,
typename _Bi_iter,
2573 typename _Rx_traits,
typename _Ch_type,
2574 typename _St,
typename _Sa>
2582 return std::__regex_replace(__out, __first, __last, __e, __fmt.
c_str(),
2583 __fmt.
length(), __flags);
2599 template<
typename _Out_iter,
typename _Bi_iter,
2600 typename _Rx_traits,
typename _Ch_type>
2604 const _Ch_type* __fmt,
2608 return std::__regex_replace(__out, __first, __last, __e, __fmt,
2609 char_traits<_Ch_type>::length(__fmt),
2625 template<
typename _Rx_traits,
typename _Ch_type,
2626 typename _St,
typename _Sa,
typename _Fst,
typename _Fsa>
2627 inline basic_string<_Ch_type, _St, _Sa>
2636 __s.
begin(), __s.
end(), __e, __fmt, __flags);
2651 template<
typename _Rx_traits,
typename _Ch_type,
2652 typename _St,
typename _Sa>
2653 inline basic_string<_Ch_type, _St, _Sa>
2656 const _Ch_type* __fmt,
2662 __s.
begin(), __s.
end(), __e, __fmt, __flags);
2677 template<
typename _Rx_traits,
typename _Ch_type,
2678 typename _St,
typename _Sa>
2679 inline basic_string<_Ch_type>
2688 __s + char_traits<_Ch_type>::length(__s),
2689 __e, __fmt, __flags);
2704 template<
typename _Rx_traits,
typename _Ch_type>
2705 inline basic_string<_Ch_type>
2708 const _Ch_type* __fmt,
2714 __s + char_traits<_Ch_type>::length(__s),
2715 __e, __fmt, __flags);
2721_GLIBCXX_BEGIN_NAMESPACE_CXX11
2731 template<
typename _Bi_iter,
2732 typename _Ch_type =
typename iterator_traits<_Bi_iter>::value_type,
2733 typename _Rx_traits = regex_traits<_Ch_type> >
2739 typedef std::ptrdiff_t difference_type;
2740 typedef const value_type* pointer;
2741 typedef const value_type& reference;
2743#if __cplusplus > 201703L
2763 : _M_begin(__a), _M_end(__b), _M_pregex(&__re), _M_flags(__m), _M_match()
2765 if (!
regex_search(_M_begin, _M_end, _M_match, *_M_pregex, _M_flags))
2790#if __cplusplus >= 202002L
2794 {
return _M_pregex ==
nullptr; }
2797#if __cpp_impl_three_way_comparison < 201907L
2803 {
return !(*
this == __rhs); }
2811 {
return _M_match; }
2818 {
return &_M_match; }
2838 _Bi_iter _M_begin {};
2840 const regex_type* _M_pregex =
nullptr;
2842 match_results<_Bi_iter> _M_match;
2847#ifdef _GLIBCXX_USE_WCHAR_T
2863 template<
typename _Bi_iter,
2871 typedef std::ptrdiff_t difference_type;
2872 typedef const value_type* pointer;
2873 typedef const value_type& reference;
2875#if __cplusplus > 201703L
2888 : _M_position(), _M_subs(), _M_suffix(), _M_n(0), _M_result(nullptr),
2913 : _M_position(__a, __b, __re, __m), _M_subs(1, __submatch), _M_n(0)
2914 { _M_init(__a, __b); }
2926 const regex_type& __re,
2930 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2931 { _M_init(__a, __b); }
2943 const regex_type& __re,
2947 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2948 { _M_init(__a, __b); }
2959 template<std::
size_t _Nm>
2961 const regex_type& __re,
2962 const int (&__submatches)[_Nm],
2965 : _M_position(__a, __b, __re, __m),
2966 _M_subs(__submatches, __submatches + _Nm), _M_n(0)
2967 { _M_init(__a, __b); }
2982 template <std::
size_t _Nm>
2993 : _M_position(__rhs._M_position), _M_subs(__rhs._M_subs),
2994 _M_suffix(__rhs._M_suffix), _M_n(__rhs._M_n), _M_has_m1(__rhs._M_has_m1)
2995 { _M_normalize_result(); }
3010#if __cplusplus >= 202002L
3014 {
return _M_end_of_seq(); }
3017#if __cpp_impl_three_way_comparison < 201907L
3023 {
return !(*
this == __rhs); }
3031 {
return *_M_result; }
3038 {
return _M_result; }
3061 _M_init(_Bi_iter __a, _Bi_iter __b);
3064 _M_current_match()
const
3066 if (_M_subs[_M_n] == -1)
3067 return (*_M_position).prefix();
3069 return (*_M_position)[_M_subs[_M_n]];
3073 _M_end_of_seq() const noexcept
3074 {
return _M_result ==
nullptr; }
3078 _M_normalize_result()
3080 if (_M_position != _Position())
3081 _M_result = &_M_current_match();
3083 _M_result = &_M_suffix;
3085 _M_result =
nullptr;
3088 _Position _M_position;
3089 std::vector<int> _M_subs;
3090 value_type _M_suffix;
3092 const value_type* _M_result;
3104#ifdef _GLIBCXX_USE_WCHAR_T
3114_GLIBCXX_END_NAMESPACE_CXX11
3115_GLIBCXX_END_NAMESPACE_VERSION
basic_ostream< char > ostream
Base class for char output streams.
__bool_constant< true > true_type
The type used as a compile-time boolean with true value.
__bool_constant< false > false_type
The type used as a compile-time boolean with false value.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
const _Facet & use_facet(const locale &__loc)
Return a facet.
sub_match< wstring::const_iterator > wssub_match
Regex submatch over a standard wide string.
auto operator<=>(const sub_match< const char * > &__lhs, const sub_match< const char * > &__rhs) noexcept(__detail::__is_contiguous_iter< const char * >::value)
sub_match< string::const_iterator > ssub_match
Standard regex submatch over a standard string.
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.
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 equivalence of a regular expression submatch and a C string.
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.
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 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< _BidirectionalIterator, polymorphic_allocator< sub_match< _BidirectionalIterator > > > &__m1, const match_results< _BidirectionalIterator, polymorphic_allocator< sub_match< _BidirectionalIterator > > > &__m2)
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)
void swap(match_results< _BidirectionalIterator, polymorphic_allocator< sub_match< _BidirectionalIterator > > > &__lhs, match_results< _BidirectionalIterator, polymorphic_allocator< sub_match< _BidirectionalIterator > > > &__rhs) noexcept
basic_regex< wchar_t > wregex
Standard wide-character regular expressions.
bool operator==(const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)
Tests the equivalence of two regular expression submatches.
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
ISO C++ entities toplevel namespace is std.
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
constexpr 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.
constexpr bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
constexpr bitset< _Nb > operator&(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Implementation details not part of the namespace std interface.
__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
Template class basic_ostream.
typename _Size< _Alloc, difference_type >::type size_type
The allocator's size type.
The standard allocator, as per C++03 [20.4.1].
Managing sequences of characters and character-like objects.
constexpr const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
constexpr size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
constexpr const _CharT * data() const noexcept
Return const pointer to contents.
constexpr size_type length() const noexcept
constexpr iterator end() noexcept
constexpr iterator begin() noexcept
Basis for explicit traits specializations.
Traits class for iterators.
Container class for localization functionality.
Primary class template ctype facet.
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 & 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...
locale_type getloc() const noexcept
Gets the locale currently imbued in the regular expression object.
unsigned int mark_count() const noexcept
Gets the number of marked subexpressions within the regular expression.
basic_regex & assign(_InputIterator __first, _InputIterator __last, 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.
basic_regex & assign(initializer_list< _Ch_type > __l, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object.
basic_regex & assign(basic_regex &&__rhs) noexcept
Move-assigns one regular expression to another.
flag_type flags() const noexcept
Gets the flags used to construct the regular expression or in the last call to assign().
basic_regex & operator=(basic_regex &&)=default
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...
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(_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 & operator=(const basic_regex &)=default
Assigns one regular expression to another.
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 & operator=(initializer_list< _Ch_type > __l)
Replaces a regular expression with a new one constructed from an initializer list.
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(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=(const _Ch_type *__p)
Replaces a regular expression with a new one constructed from a C-style null-terminated string.
basic_regex & assign(const basic_regex &__rhs) noexcept
Assigns one regular expression to another.
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()
Destroys a basic regular expression.
The results of a match or search operation.
allocator_type get_allocator() const noexcept
void swap(match_results &__that) noexcept
difference_type position(size_type __sub=0) const
size_type size() const noexcept
_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
const_reference prefix() const
match_results(match_results &&__m, const polymorphic_allocator< sub_match< _BidirectionalIterator > > &__a) noexcept(noexcept(_Base_type(std::move(__m), __a)))
size_type max_size() const noexcept
basic_string< char_type, _St, _Sa > format(const basic_string< char_type, _St, _Sa > &__fmt, match_flag_type __flags=regex_constants::format_default) const
const_reference operator[](size_type __sub) const
match_results(match_results &&) noexcept=default
match_results(const polymorphic_allocator< sub_match< _BidirectionalIterator > > &__a) noexcept
match_results(const match_results &)=default
_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
string_type str(size_type __sub=0) const
const_iterator end() const noexcept
const_reference suffix() const
bool ready() const noexcept
bool empty() const noexcept
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
const_iterator begin() const noexcept
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.
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.
string_type lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
Gets a collation element by name.
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.
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.
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.
void swap(sub_match &__s) noexcept(__is_nothrow_swappable< _BiIter >::value)
Swap the values of two sub_match objects.
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.
const value_type * operator->() const noexcept
Selects a regex_iterator member.
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 & operator=(const regex_iterator &)=default
Copy assigns one regex_iterator to another.
regex_iterator()=default
Provides a singular iterator, useful for indicating one-past-the-end of a range.
const value_type & operator*() const noexcept
Dereferences a regex_iterator.
bool operator==(const regex_iterator &) const noexcept
Tests the equivalence of two regex iterators.
regex_iterator & operator++()
Increments a regex_iterator.
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.
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++(int)
Postincrements a regex_token_iterator.
const value_type * operator->() const
Selects a regex_token_iterator member.
regex_token_iterator & operator=(const regex_token_iterator &__rhs)
Assigns a regex_token_iterator to another.
regex_token_iterator & operator++()
Increments a regex_token_iterator.
regex_token_iterator()
Default constructs a regex_token_iterator.
const value_type & operator*() const
Dereferences a regex_token_iterator.
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.
Struct holding two objects of arbitrary type.
constexpr void swap(pair &__p) noexcept(__and_< __is_nothrow_swappable< _T1 >, __is_nothrow_swappable< _T2 > >::value)
Swap the first members and then the second members.
Forward iterators support a superset of input iterator operations.
A standard container which offers fixed time access to individual elements in any order.
constexpr iterator end() noexcept
constexpr iterator begin() noexcept
constexpr void assign(size_type __n, const value_type &__val)
constexpr void swap(vector &__x) noexcept
constexpr bool empty() const noexcept
constexpr allocator_type get_allocator() const noexcept
constexpr size_type size() const noexcept
constexpr reference operator[](size_type __n) noexcept
constexpr size_type max_size() const noexcept