1	// class template regex -*- C++ -*-
2
3	// Copyright (C) 2010-2021 Free Software Foundation, Inc.
4	//
5	// This file is part of the GNU ISO C++ Library. This library is free
6	// software; you can redistribute it and/or modify it under the
7	// terms of the GNU General Public License as published by the
8	// Free Software Foundation; either version 3, or (at your option)
9	// any later version.
10
11	// This library is distributed in the hope that it will be useful,
12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	// GNU General Public License for more details.
15
16	// Under Section 7 of GPL version 3, you are granted additional
17	// permissions described in the GCC Runtime Library Exception, version
18	// 3.1, as published by the Free Software Foundation.
19
20	// You should have received a copy of the GNU General Public License and
21	// a copy of the GCC Runtime Library Exception along with this program;
22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23	// <http://www.gnu.org/licenses/>.
24
25	/**
26	* @file bits/regex.h
27	* This is an internal header file, included by other library headers.
28	* Do not attempt to use it directly. @headername{regex}
29	*/
30
31	namespace std _GLIBCXX_VISIBILITY(default)
32	{
33	_GLIBCXX_BEGIN_NAMESPACE_VERSION
34	_GLIBCXX_BEGIN_NAMESPACE_CXX11
35	template<typename, typename>
36	class basic_regex;
37
38	template<typename _Bi_iter, typename _Alloc>
39	class match_results;
40
41	_GLIBCXX_END_NAMESPACE_CXX11
42
43	namespace __detail
44	{
45	enum class _RegexExecutorPolicy : int { _S_auto, _S_alternate };
46
47	template<typename _BiIter, typename _Alloc,
48	typename _CharT, typename _TraitsT,
49	_RegexExecutorPolicy __policy,
50	bool __match_mode>
51	bool
52	__regex_algo_impl(_BiIter __s,
53	_BiIter __e,
54	match_results<_BiIter, _Alloc>& __m,
55	const basic_regex<_CharT, _TraitsT>& __re,
56	regex_constants::match_flag_type __flags);
57
58	template<typename, typename, typename, bool>
59	class _Executor;
60
61	template<typename _Tp>
62	struct __is_contiguous_iter : false_type { };
63
64	template<typename _Tp>
65	struct __is_contiguous_iter<_Tp*> : true_type { };
66
67	template<typename _Tp, typename _Cont>
68	struct __is_contiguous_iter<__gnu_cxx::__normal_iterator<_Tp*, _Cont>>
69	: true_type { };
70	}
71
72	_GLIBCXX_BEGIN_NAMESPACE_CXX11
73
74	/**
75	* @addtogroup regex
76	* @{
77	*/
78
79	/**
80	* @brief Describes aspects of a regular expression.
81	*
82	* A regular expression traits class that satisfies the requirements of
83	* section [28.7].
84	*
85	* The class %regex is parameterized around a set of related types and
86	* functions used to complete the definition of its semantics. This class
87	* satisfies the requirements of such a traits class.
88	*/
89	template<typename _Ch_type>
90	class regex_traits
91	{
92	public:
93	typedef _Ch_type char_type;
94	typedef std::basic_string<char_type> string_type;
95	typedef std::locale locale_type;
96
97	private:
98	struct _RegexMask
99	{
100	typedef std::ctype_base::mask _BaseType;
101	_BaseType _M_base;
102	unsigned char _M_extended;
103	static constexpr unsigned char _S_under = 1 << 0;
104	static constexpr unsigned char _S_valid_mask = 0x1;
105
106	constexpr _RegexMask(_BaseType __base = 0,
107	unsigned char __extended = 0)
108	: _M_base(__base), _M_extended(__extended)
109	{ }
110
111	constexpr _RegexMask
112	operator&(_RegexMask __other) const
113	{
114	return _RegexMask(_M_base & __other._M_base,
115	_M_extended & __other._M_extended);
116	}
117
118	constexpr _RegexMask
119	operator|(_RegexMask __other) const
120	{
121	return _RegexMask(_M_base | __other._M_base,
122	_M_extended | __other._M_extended);
123	}
124
125	constexpr _RegexMask
126	operator^(_RegexMask __other) const
127	{
128	return _RegexMask(_M_base ^ __other._M_base,
129	_M_extended ^ __other._M_extended);
130	}
131
132	constexpr _RegexMask
133	operator~() const
134	{ return _RegexMask(~_M_base, ~_M_extended); }
135
136	_RegexMask&
137	operator&=(_RegexMask __other)
138	{ return *this = (*this) & __other; }
139
140	_RegexMask&
141	operator|=(_RegexMask __other)
142	{ return *this = (*this) | __other; }
143
144	_RegexMask&
145	operator^=(_RegexMask __other)
146	{ return *this = (*this) ^ __other; }
147
148	constexpr bool
149	operator==(_RegexMask __other) const
150	{
151	return (_M_extended & _S_valid_mask)
152	== (__other._M_extended & _S_valid_mask)
153	&& _M_base == __other._M_base;
154	}
155
156	#if __cpp_impl_three_way_comparison < 201907L
157	constexpr bool
158	operator!=(_RegexMask __other) const
159	{ return !((*this) == __other); }
160	#endif
161	};
162
163	public:
164	typedef _RegexMask char_class_type;
165
166	public:
167	/**
168	* @brief Constructs a default traits object.
169	*/
170	regex_traits() { }
171
172	/**
173	* @brief Gives the length of a C-style string starting at @p __p.
174	*
175	* @param __p a pointer to the start of a character sequence.
176	*
177	* @returns the number of characters between @p *__p and the first
178	* default-initialized value of type @p char_type. In other words, uses
179	* the C-string algorithm for determining the length of a sequence of
180	* characters.
181	*/
182	static std::size_t
183	length(const char_type* __p)
184	{ return string_type::traits_type::length(__p); }
185
186	/**
187	* @brief Performs the identity translation.
188	*
189	* @param __c A character to the locale-specific character set.
190	*
191	* @returns __c.
192	*/
193	char_type
194	translate(char_type __c) const
195	{ return __c; }
196
197	/**
198	* @brief Translates a character into a case-insensitive equivalent.
199	*
200	* @param __c A character to the locale-specific character set.
201	*
202	* @returns the locale-specific lower-case equivalent of __c.
203	* @throws std::bad_cast if the imbued locale does not support the ctype
204	* facet.
205	*/
206	char_type
207	translate_nocase(char_type __c) const
208	{
209	typedef std::ctype<char_type> __ctype_type;
210	const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
211	return __fctyp.tolower(__c);
212	}
213
214	/**
215	* @brief Gets a sort key for a character sequence.
216	*
217	* @param __first beginning of the character sequence.
218	* @param __last one-past-the-end of the character sequence.
219	*
220	* Returns a sort key for the character sequence designated by the
221	* iterator range [F1, F2) such that if the character sequence [G1, G2)
222	* sorts before the character sequence [H1, H2) then
223	* v.transform(G1, G2) < v.transform(H1, H2).
224	*
225	* What this really does is provide a more efficient way to compare a
226	* string to multiple other strings in locales with fancy collation
227	* rules and equivalence classes.
228	*
229	* @returns a locale-specific sort key equivalent to the input range.
230	*
231	* @throws std::bad_cast if the current locale does not have a collate
232	* facet.
233	*/
234	template<typename _Fwd_iter>
235	string_type
236	transform(_Fwd_iter __first, _Fwd_iter __last) const
237	{
238	typedef std::collate<char_type> __collate_type;
239	const __collate_type& __fclt(use_facet<__collate_type>(_M_locale));
240	string_type __s(__first, __last);
241	return __fclt.transform(__s.data(), __s.data() + __s.size());
242	}
243
244	/**
245	* @brief Gets a sort key for a character sequence, independent of case.
246	*
247	* @param __first beginning of the character sequence.
248	* @param __last one-past-the-end of the character sequence.
249	*
250	* Effects: if typeid(use_facet<collate<_Ch_type> >) ==
251	* typeid(collate_byname<_Ch_type>) and the form of the sort key
252	* returned by collate_byname<_Ch_type>::transform(__first, __last)
253	* is known and can be converted into a primary sort key
254	* then returns that key, otherwise returns an empty string.
255	*
256	* @todo Implement this function correctly.
257	*/
258	template<typename _Fwd_iter>
259	string_type
260	transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
261	{
262	// TODO : this is not entirely correct.
263	// This function requires extra support from the platform.
264	//
265	// Read http://gcc.gnu.org/ml/libstdc++/2013-09/msg00117.html and
266	// http://www.open-std.org/Jtc1/sc22/wg21/docs/papers/2003/n1429.htm
267	// for details.
268	typedef std::ctype<char_type> __ctype_type;
269	const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
270	std::vector<char_type> __s(__first, __last);
271	__fctyp.tolower(__s.data(), __s.data() + __s.size());
272	return this->transform(__s.data(), __s.data() + __s.size());
273	}
274
275	/**
276	* @brief Gets a collation element by name.
277	*
278	* @param __first beginning of the collation element name.
279	* @param __last one-past-the-end of the collation element name.
280	*
281	* @returns a sequence of one or more characters that represents the
282	* collating element consisting of the character sequence designated by
283	* the iterator range [__first, __last). Returns an empty string if the
284	* character sequence is not a valid collating element.
285	*/
286	template<typename _Fwd_iter>
287	string_type
288	lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const;
289
290	/**
291	* @brief Maps one or more characters to a named character
292	* classification.
293	*
294	* @param __first beginning of the character sequence.
295	* @param __last one-past-the-end of the character sequence.
296	* @param __icase ignores the case of the classification name.
297	*
298	* @returns an unspecified value that represents the character
299	* classification named by the character sequence designated by
300	* the iterator range [__first, __last). If @p icase is true,
301	* the returned mask identifies the classification regardless of
302	* the case of the characters to be matched (for example,
303	* [[:lower:]] is the same as [[:alpha:]]), otherwise a
304	* case-dependent classification is returned. The value
305	* returned shall be independent of the case of the characters
306	* in the character sequence. If the name is not recognized then
307	* returns a value that compares equal to 0.
308	*
309	* At least the following names (or their wide-character equivalent) are
310	* supported.
311	* - d
312	* - w
313	* - s
314	* - alnum
315	* - alpha
316	* - blank
317	* - cntrl
318	* - digit
319	* - graph
320	* - lower
321	* - print
322	* - punct
323	* - space
324	* - upper
325	* - xdigit
326	*/
327	template<typename _Fwd_iter>
328	char_class_type
329	lookup_classname(_Fwd_iter __first, _Fwd_iter __last,
330	bool __icase = false) const;
331
332	/**
333	* @brief Determines if @p c is a member of an identified class.
334	*
335	* @param __c a character.
336	* @param __f a class type (as returned from lookup_classname).
337	*
338	* @returns true if the character @p __c is a member of the classification
339	* represented by @p __f, false otherwise.
340	*
341	* @throws std::bad_cast if the current locale does not have a ctype
342	* facet.
343	*/
344	bool
345	isctype(_Ch_type __c, char_class_type __f) const;
346
347	/**
348	* @brief Converts a digit to an int.
349	*
350	* @param __ch a character representing a digit.
351	* @param __radix the radix if the numeric conversion (limited to 8, 10,
352	* or 16).
353	*
354	* @returns the value represented by the digit __ch in base radix if the
355	* character __ch is a valid digit in base radix; otherwise returns -1.
356	*/
357	int
358	value(_Ch_type __ch, int __radix) const;
359
360	/**
361	* @brief Imbues the regex_traits object with a copy of a new locale.
362	*
363	* @param __loc A locale.
364	*
365	* @returns a copy of the previous locale in use by the regex_traits
366	* object.
367	*
368	* @note Calling imbue with a different locale than the one currently in
369	* use invalidates all cached data held by *this.
370	*/
371	locale_type
372	imbue(locale_type __loc)
373	{
374	std::swap(a&: _M_locale, b&: __loc);
375	return __loc;
376	}
377
378	/**
379	* @brief Gets a copy of the current locale in use by the regex_traits
380	* object.
381	*/
382	locale_type
383	getloc() const
384	{ return _M_locale; }
385
386	protected:
387	locale_type _M_locale;
388	};
389
390	// [7.8] Class basic_regex
391	/**
392	* Objects of specializations of this class represent regular expressions
393	* constructed from sequences of character type @p _Ch_type.
394	*
395	* Storage for the regular expression is allocated and deallocated as
396	* necessary by the member functions of this class.
397	*/
398	template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>>
399	class basic_regex
400	{
401	public:
402	static_assert(is_same<_Ch_type, typename _Rx_traits::char_type>::value,
403	"regex traits class must have the same char_type");
404
405	// types:
406	typedef _Ch_type value_type;
407	typedef _Rx_traits traits_type;
408	typedef typename traits_type::string_type string_type;
409	typedef regex_constants::syntax_option_type flag_type;
410	typedef typename traits_type::locale_type locale_type;
411
412	/**
413	* @name Constants
414	* std [28.8.1](1)
415	*/
416	///@{
417	static constexpr flag_type icase = regex_constants::icase;
418	static constexpr flag_type nosubs = regex_constants::nosubs;
419	static constexpr flag_type optimize = regex_constants::optimize;
420	static constexpr flag_type collate = regex_constants::collate;
421	static constexpr flag_type ECMAScript = regex_constants::ECMAScript;
422	static constexpr flag_type basic = regex_constants::basic;
423	static constexpr flag_type extended = regex_constants::extended;
424	static constexpr flag_type awk = regex_constants::awk;
425	static constexpr flag_type grep = regex_constants::grep;
426	static constexpr flag_type egrep = regex_constants::egrep;
427	#if __cplusplus >= 201703L || !defined __STRICT_ANSI__
428	static constexpr flag_type multiline = regex_constants::multiline;
429	#endif
430	///@}
431
432	// [7.8.2] construct/copy/destroy
433	/**
434	* Constructs a basic regular expression that does not match any
435	* character sequence.
436	*/
437	basic_regex() noexcept
438	: _M_flags(ECMAScript), _M_loc(), _M_automaton(nullptr)
439	{ }
440
441	/**
442	* @brief Constructs a basic regular expression from the
443	* sequence [__p, __p + char_traits<_Ch_type>::length(__p))
444	* interpreted according to the flags in @p __f.
445	*
446	* @param __p A pointer to the start of a C-style null-terminated string
447	* containing a regular expression.
448	* @param __f Flags indicating the syntax rules and options.
449	*
450	* @throws regex_error if @p __p is not a valid regular expression.
451	*/
452	explicit
453	basic_regex(const _Ch_type* __p, flag_type __f = ECMAScript)
454	{ _M_compile(first: __p, last: __p + _Rx_traits::length(__p), __f); }
455
456	/**
457	* @brief Constructs a basic regular expression from the sequence
458	* [p, p + len) interpreted according to the flags in @p f.
459	*
460	* @param __p A pointer to the start of a string containing a regular
461	* expression.
462	* @param __len The length of the string containing the regular
463	* expression.
464	* @param __f Flags indicating the syntax rules and options.
465	*
466	* @throws regex_error if @p __p is not a valid regular expression.
467	*/
468	basic_regex(const _Ch_type* __p, std::size_t __len,
469	flag_type __f = ECMAScript)
470	{ _M_compile(first: __p, last: __p + __len, __f); }
471
472	/**
473	* @brief Copy-constructs a basic regular expression.
474	*
475	* @param __rhs A @p regex object.
476	*/
477	basic_regex(const basic_regex& __rhs) = default;
478
479	/**
480	* @brief Move-constructs a basic regular expression.
481	*
482	* @param __rhs A @p regex object.
483	*/
484	basic_regex(basic_regex&& __rhs) noexcept = default;
485
486	/**
487	* @brief Constructs a basic regular expression from the string
488	* @p s interpreted according to the flags in @p f.
489	*
490	* @param __s A string containing a regular expression.
491	* @param __f Flags indicating the syntax rules and options.
492	*
493	* @throws regex_error if @p __s is not a valid regular expression.
494	*/
495	template<typename _Ch_traits, typename _Ch_alloc>
496	explicit
497	basic_regex(const std::basic_string<_Ch_type, _Ch_traits,
498	_Ch_alloc>& __s,
499	flag_type __f = ECMAScript)
500	{ _M_compile(first: __s.data(), last: __s.data() + __s.size(), __f); }
501
502	/**
503	* @brief Constructs a basic regular expression from the range
504	* [first, last) interpreted according to the flags in @p f.
505	*
506	* @param __first The start of a range containing a valid regular
507	* expression.
508	* @param __last The end of a range containing a valid regular
509	* expression.
510	* @param __f The format flags of the regular expression.
511	*
512	* @throws regex_error if @p [__first, __last) is not a valid regular
513	* expression.
514	*/
515	template<typename _FwdIter>
516	basic_regex(_FwdIter __first, _FwdIter __last,
517	flag_type __f = ECMAScript)
518	{ this->assign(__first, __last, __f); }
519
520	/**
521	* @brief Constructs a basic regular expression from an initializer list.
522	*
523	* @param __l The initializer list.
524	* @param __f The format flags of the regular expression.
525	*
526	* @throws regex_error if @p __l is not a valid regular expression.
527	*/
528	basic_regex(initializer_list<_Ch_type> __l, flag_type __f = ECMAScript)
529	{ _M_compile(first: __l.begin(), last: __l.end(), __f); }
530
531	/**
532	* @brief Destroys a basic regular expression.
533	*/
534	~basic_regex()
535	{ }
536
537	/**
538	* @brief Assigns one regular expression to another.
539	*/
540	basic_regex&
541	operator=(const basic_regex&) = default;
542
543	/**
544	* @brief Move-assigns one regular expression to another.
545	*/
546	basic_regex&
547	operator=(basic_regex&&) = default;
548
549	/**
550	* @brief Replaces a regular expression with a new one constructed from
551	* a C-style null-terminated string.
552	*
553	* @param __p A pointer to the start of a null-terminated C-style string
554	* containing a regular expression.
555	*/
556	basic_regex&
557	operator=(const _Ch_type* __p)
558	{ return this->assign(__p); }
559
560	/**
561	* @brief Replaces a regular expression with a new one constructed from
562	* an initializer list.
563	*
564	* @param __l The initializer list.
565	*
566	* @throws regex_error if @p __l is not a valid regular expression.
567	*/
568	basic_regex&
569	operator=(initializer_list<_Ch_type> __l)
570	{ return this->assign(__l); }
571
572	/**
573	* @brief Replaces a regular expression with a new one constructed from
574	* a string.
575	*
576	* @param __s A pointer to a string containing a regular expression.
577	*/
578	template<typename _Ch_traits, typename _Alloc>
579	basic_regex&
580	operator=(const basic_string<_Ch_type, _Ch_traits, _Alloc>& __s)
581	{ return this->assign(__s); }
582
583	// [7.8.3] assign
584	/**
585	* @brief Assigns one regular expression to another.
586	*
587	* @param __rhs Another regular expression object.
588	*/
589	basic_regex&
590	assign(const basic_regex& __rhs) noexcept
591	{ return *this = __rhs; }
592
593	/**
594	* @brief Move-assigns one regular expression to another.
595	*
596	* @param __rhs Another regular expression object.
597	*/
598	basic_regex&
599	assign(basic_regex&& __rhs) noexcept
600	{ return *this = std::move(__rhs); }
601
602	/**
603	* @brief Assigns a new regular expression to a regex object from a
604	* C-style null-terminated string containing a regular expression
605	* pattern.
606	*
607	* @param __p A pointer to a C-style null-terminated string containing
608	* a regular expression pattern.
609	* @param __flags Syntax option flags.
610	*
611	* @throws regex_error if __p does not contain a valid regular
612	* expression pattern interpreted according to @p __flags. If
613	* regex_error is thrown, *this remains unchanged.
614	*/
615	basic_regex&
616	assign(const _Ch_type* __p, flag_type __flags = ECMAScript)
617	{
618	_M_compile(first: __p, last: __p + _Rx_traits::length(__p), f: __flags);
619	return *this;
620	}
621
622	/**
623	* @brief Assigns a new regular expression to a regex object from a
624	* C-style string containing a regular expression pattern.
625	*
626	* @param __p A pointer to a C-style string containing a
627	* regular expression pattern.
628	* @param __len The length of the regular expression pattern string.
629	* @param __flags Syntax option flags.
630	*
631	* @throws regex_error if p does not contain a valid regular
632	* expression pattern interpreted according to @p __flags. If
633	* regex_error is thrown, *this remains unchanged.
634	*/
635	// _GLIBCXX_RESOLVE_LIB_DEFECTS
636	// 3296. Inconsistent default argument for basic_regex<>::assign
637	basic_regex&
638	assign(const _Ch_type* __p, size_t __len, flag_type __flags = ECMAScript)
639	{
640	_M_compile(first: __p, last: __p + __len, f: __flags);
641	return *this;
642	}
643
644	/**
645	* @brief Assigns a new regular expression to a regex object from a
646	* string containing a regular expression pattern.
647	*
648	* @param __s A string containing a regular expression pattern.
649	* @param __flags Syntax option flags.
650	*
651	* @throws regex_error if __s does not contain a valid regular
652	* expression pattern interpreted according to @p __flags. If
653	* regex_error is thrown, *this remains unchanged.
654	*/
655	template<typename _Ch_traits, typename _Alloc>
656	basic_regex&
657	assign(const basic_string<_Ch_type, _Ch_traits, _Alloc>& __s,
658	flag_type __flags = ECMAScript)
659	{
660	_M_compile(first: __s.data(), last: __s.data() + __s.size(), f: __flags);
661	return *this;
662	}
663
664	/**
665	* @brief Assigns a new regular expression to a regex object.
666	*
667	* @param __first The start of a range containing a valid regular
668	* expression.
669	* @param __last The end of a range containing a valid regular
670	* expression.
671	* @param __flags Syntax option flags.
672	*
673	* @throws regex_error if p does not contain a valid regular
674	* expression pattern interpreted according to @p __flags. If
675	* regex_error is thrown, the object remains unchanged.
676	*/
677	template<typename _InputIterator>
678	basic_regex&
679	assign(_InputIterator __first, _InputIterator __last,
680	flag_type __flags = ECMAScript)
681	{
682	#if __cplusplus >= 201703L
683	using _ValT = typename iterator_traits<_InputIterator>::value_type;
684	if constexpr (__detail::__is_contiguous_iter<_InputIterator>::value
685	&& is_same_v<_ValT, value_type>)
686	{
687	const auto __len = __last - __first;
688	const _Ch_type* __p = std::__to_address(__first);
689	_M_compile(first: __p, last: __p + __len, f: __flags);
690	}
691	else
692	#endif
693	this->assign(string_type(__first, __last), __flags);
694	return *this;
695	}
696
697	/**
698	* @brief Assigns a new regular expression to a regex object.
699	*
700	* @param __l An initializer list representing a regular expression.
701	* @param __flags Syntax option flags.
702	*
703	* @throws regex_error if @p __l does not contain a valid
704	* regular expression pattern interpreted according to @p
705	* __flags. If regex_error is thrown, the object remains
706	* unchanged.
707	*/
708	basic_regex&
709	assign(initializer_list<_Ch_type> __l, flag_type __flags = ECMAScript)
710	{
711	_M_compile(first: __l.begin(), last: __l.end(), f: __flags);
712	return *this;
713	}
714
715	// [7.8.4] const operations
716	/**
717	* @brief Gets the number of marked subexpressions within the regular
718	* expression.
719	*/
720	unsigned int
721	mark_count() const noexcept
722	{
723	if (_M_automaton)
724	return _M_automaton->_M_sub_count() - 1;
725	return 0;
726	}
727
728	/**
729	* @brief Gets the flags used to construct the regular expression
730	* or in the last call to assign().
731	*/
732	flag_type
733	flags() const noexcept
734	{ return _M_flags; }
735
736	// [7.8.5] locale
737	/**
738	* @brief Imbues the regular expression object with the given locale.
739	*
740	* @param __loc A locale.
741	*/
742	locale_type
743	imbue(locale_type __loc)
744	{
745	std::swap(__loc, _M_loc);
746	_M_automaton.reset();
747	return __loc;
748	}
749
750	/**
751	* @brief Gets the locale currently imbued in the regular expression
752	* object.
753	*/
754	locale_type
755	getloc() const noexcept
756	{ return _M_loc; }
757
758	// [7.8.6] swap
759	/**
760	* @brief Swaps the contents of two regular expression objects.
761	*
762	* @param __rhs Another regular expression object.
763	*/
764	void
765	swap(basic_regex& __rhs) noexcept
766	{
767	std::swap(_M_flags, __rhs._M_flags);
768	std::swap(_M_loc, __rhs._M_loc);
769	std::swap(_M_automaton, __rhs._M_automaton);
770	}
771
772	#ifdef _GLIBCXX_DEBUG
773	void
774	_M_dot(std::ostream& __ostr)
775	{ _M_automaton->_M_dot(__ostr); }
776	#endif
777
778	private:
779	typedef std::shared_ptr<const __detail::_NFA<_Rx_traits>> _AutomatonPtr;
780
781	void
782	_M_compile(const _Ch_type* __first, const _Ch_type* __last,
783	flag_type __f)
784	{
785	__detail::_Compiler<_Rx_traits> __c(__first, __last, _M_loc, __f);
786	_M_automaton = __c._M_get_nfa();
787	_M_flags = __f;
788	}
789
790	template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
791	__detail::_RegexExecutorPolicy, bool>
792	friend bool
793	__detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
794	const basic_regex<_Cp, _Rp>&,
795	regex_constants::match_flag_type);
796
797	template<typename, typename, typename, bool>
798	friend class __detail::_Executor;
799
800	flag_type _M_flags;
801	locale_type _M_loc;
802	_AutomatonPtr _M_automaton;
803	};
804
805	#if __cplusplus < 201703L
806	template<typename _Ch, typename _Tr>
807	constexpr regex_constants::syntax_option_type
808	basic_regex<_Ch, _Tr>::icase;
809
810	template<typename _Ch, typename _Tr>
811	constexpr regex_constants::syntax_option_type
812	basic_regex<_Ch, _Tr>::nosubs;
813
814	template<typename _Ch, typename _Tr>
815	constexpr regex_constants::syntax_option_type
816	basic_regex<_Ch, _Tr>::optimize;
817
818	template<typename _Ch, typename _Tr>
819	constexpr regex_constants::syntax_option_type
820	basic_regex<_Ch, _Tr>::collate;
821
822	template<typename _Ch, typename _Tr>
823	constexpr regex_constants::syntax_option_type
824	basic_regex<_Ch, _Tr>::ECMAScript;
825
826	template<typename _Ch, typename _Tr>
827	constexpr regex_constants::syntax_option_type
828	basic_regex<_Ch, _Tr>::basic;
829
830	template<typename _Ch, typename _Tr>
831	constexpr regex_constants::syntax_option_type
832	basic_regex<_Ch, _Tr>::extended;
833
834	template<typename _Ch, typename _Tr>
835	constexpr regex_constants::syntax_option_type
836	basic_regex<_Ch, _Tr>::awk;
837
838	template<typename _Ch, typename _Tr>
839	constexpr regex_constants::syntax_option_type
840	basic_regex<_Ch, _Tr>::grep;
841
842	template<typename _Ch, typename _Tr>
843	constexpr regex_constants::syntax_option_type
844	basic_regex<_Ch, _Tr>::egrep;
845	#endif // ! C++17
846
847	#if __cpp_deduction_guides >= 201606
848	template<typename _ForwardIterator>
849	basic_regex(_ForwardIterator, _ForwardIterator,
850	regex_constants::syntax_option_type = {})
851	-> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>;
852	#endif
853
854	/** @brief Standard regular expressions. */
855	typedef basic_regex<char> regex;
856
857	#ifdef _GLIBCXX_USE_WCHAR_T
858	/** @brief Standard wide-character regular expressions. */
859	typedef basic_regex<wchar_t> wregex;
860	#endif
861
862
863	// [7.8.6] basic_regex swap
864	/**
865	* @brief Swaps the contents of two regular expression objects.
866	* @param __lhs First regular expression.
867	* @param __rhs Second regular expression.
868	* @relates basic_regex
869	*/
870	template<typename _Ch_type, typename _Rx_traits>
871	inline void
872	swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
873	basic_regex<_Ch_type, _Rx_traits>& __rhs) noexcept
874	{ __lhs.swap(__rhs); }
875
876
877	// C++11 28.9 [re.submatch] Class template sub_match
878	/**
879	* A sequence of characters matched by a particular marked sub-expression.
880	*
881	* An object of this class is essentially a pair of iterators marking a
882	* matched subexpression within a regular expression pattern match. Such
883	* objects can be converted to and compared with std::basic_string objects
884	* of a similar base character type as the pattern matched by the regular
885	* expression.
886	*
887	* The iterators that make up the pair are the usual half-open interval
888	* referencing the actual original pattern matched.
889	*/
890	template<typename _BiIter>
891	class sub_match : public std::pair<_BiIter, _BiIter>
892	{
893	typedef iterator_traits<_BiIter> __iter_traits;
894
895	public:
896	typedef typename __iter_traits::value_type value_type;
897	typedef typename __iter_traits::difference_type difference_type;
898	typedef _BiIter iterator;
899	typedef basic_string<value_type> string_type;
900
901	bool matched;
902
903	constexpr sub_match() noexcept : matched() { }
904
905	/// Gets the length of the matching sequence.
906	difference_type
907	length() const noexcept
908	{ return this->matched ? std::distance(this->first, this->second) : 0; }
909
910	/**
911	* @brief Gets the matching sequence as a string.
912	*
913	* @returns the matching sequence as a string.
914	*
915	* This is the implicit conversion operator. It is identical to the
916	* str() member function except that it will want to pop up in
917	* unexpected places and cause a great deal of confusion and cursing
918	* from the unwary.
919	*/
920	operator string_type() const
921	{ return str(); }
922
923	/**
924	* @brief Gets the matching sequence as a string.
925	*
926	* @returns the matching sequence as a string.
927	*/
928	string_type
929	str() const
930	{
931	return this->matched
932	? string_type(this->first, this->second)
933	: string_type();
934	}
935
936	/**
937	* @brief Compares this and another matched sequence.
938	*
939	* @param __s Another matched sequence to compare to this one.
940	*
941	* @retval negative This matched sequence will collate before `__s`.
942	* @retval zero This matched sequence is equivalent to `__s`.
943	* @retval positive This matched sequence will collate after `__s`.
944	*/
945	int
946	compare(const sub_match& __s) const
947	{ return this->_M_str().compare(__s._M_str()); }
948
949	/**
950	* @{
951	* @brief Compares this `sub_match` to a string.
952	*
953	* @param __s A string to compare to this `sub_match`.
954	*
955	* @retval negative This matched sequence will collate before `__s`.
956	* @retval zero This matched sequence is equivalent to `__s`.
957	* @retval positive This matched sequence will collate after `__s`.
958	*/
959	int
960	compare(const string_type& __s) const
961	{ return this->_M_str().compare(__s); }
962
963	int
964	compare(const value_type* __s) const
965	{ return this->_M_str().compare(__s); }
966	/// @}
967
968	/// @cond undocumented
969	// Non-standard, used by comparison operators
970	int
971	_M_compare(const value_type* __s, size_t __n) const
972	{ return this->_M_str().compare({__s, __n}); }
973	/// @endcond
974
975	private:
976	// Simplified basic_string_view for C++11
977	struct __string_view
978	{
979	using traits_type = typename string_type::traits_type;
980
981	__string_view() = default;
982
983	__string_view(const value_type* __s, size_t __n) noexcept
984	: _M_data(__s), _M_len(__n) { }
985
986	__string_view(const value_type* __s) noexcept
987	: _M_data(__s), _M_len(traits_type::length(__s)) { }
988
989	__string_view(const string_type& __s) noexcept
990	: _M_data(__s.data()), _M_len(__s.length()) { }
991
992	int
993	compare(__string_view __s) const noexcept
994	{
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))
997	return __ret;
998	using __limits = __gnu_cxx::__int_traits<int>;
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);
1005	}
1006
1007	private:
1008	const value_type* _M_data = nullptr;
1009	size_t _M_len = 0;
1010	};
1011
1012	// Create a __string_view over the iterator range.
1013	template<typename _Iter = _BiIter>
1014	__enable_if_t<__detail::__is_contiguous_iter<_Iter>::value,
1015	__string_view>
1016	_M_str() const noexcept
1017	{
1018	if (this->matched)
1019	if (size_t __len = this->second - this->first)
1020	return { std::__addressof(*this->first), __len };
1021	return {};
1022	}
1023
1024	// Create a temporary string that can be converted to __string_view.
1025	template<typename _Iter = _BiIter>
1026	__enable_if_t<!__detail::__is_contiguous_iter<_Iter>::value,
1027	string_type>
1028	_M_str() const
1029	{ return str(); }
1030	};
1031
1032
1033	/** @brief Standard regex submatch over a C-style null-terminated string. */
1034	typedef sub_match<const char*> csub_match;
1035
1036	/** @brief Standard regex submatch over a standard string. */
1037	typedef sub_match<string::const_iterator> ssub_match;
1038
1039	#ifdef _GLIBCXX_USE_WCHAR_T
1040	/** @brief Regex submatch over a C-style null-terminated wide string. */
1041	typedef sub_match<const wchar_t*> wcsub_match;
1042
1043	/** @brief Regex submatch over a standard wide string. */
1044	typedef sub_match<wstring::const_iterator> wssub_match;
1045	#endif
1046
1047	// [7.9.2] sub_match non-member operators
1048
1049	/// @relates sub_match @{
1050
1051	/**
1052	* @brief Tests the equivalence of two regular expression submatches.
1053	* @param __lhs First regular expression submatch.
1054	* @param __rhs Second regular expression submatch.
1055	* @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1056	*/
1057	template<typename _BiIter>
1058	inline bool
1059	operator==(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1060	{ return __lhs.compare(__rhs) == 0; }
1061
1062	#if __cpp_lib_three_way_comparison
1063	/**
1064	* @brief Three-way comparison of two regular expression submatches.
1065	* @param __lhs First regular expression submatch.
1066	* @param __rhs Second regular expression submatch.
1067	* @returns A value indicating whether `__lhs` is less than, equal to,
1068	* greater than, or incomparable with `__rhs`.
1069	*/
1070	template<typename _BiIter>
1071	inline auto
1072	operator<=>(const sub_match<_BiIter>& __lhs,
1073	const sub_match<_BiIter>& __rhs)
1074	noexcept(__detail::__is_contiguous_iter<_BiIter>::value)
1075	{
1076	using _Tr = char_traits<typename iterator_traits<_BiIter>::value_type>;
1077	return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
1078	}
1079	#else
1080	/**
1081	* @brief Tests the inequivalence of two regular expression submatches.
1082	* @param __lhs First regular expression submatch.
1083	* @param __rhs Second regular expression submatch.
1084	* @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1085	*/
1086	template<typename _BiIter>
1087	inline bool
1088	operator!=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1089	{ return __lhs.compare(__rhs) != 0; }
1090
1091	/**
1092	* @brief Tests the ordering of two regular expression submatches.
1093	* @param __lhs First regular expression submatch.
1094	* @param __rhs Second regular expression submatch.
1095	* @returns true if @a __lhs precedes @a __rhs, false otherwise.
1096	*/
1097	template<typename _BiIter>
1098	inline bool
1099	operator<(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1100	{ return __lhs.compare(__rhs) < 0; }
1101
1102	/**
1103	* @brief Tests the ordering of two regular expression submatches.
1104	* @param __lhs First regular expression submatch.
1105	* @param __rhs Second regular expression submatch.
1106	* @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1107	*/
1108	template<typename _BiIter>
1109	inline bool
1110	operator<=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1111	{ return __lhs.compare(__rhs) <= 0; }
1112
1113	/**
1114	* @brief Tests the ordering of two regular expression submatches.
1115	* @param __lhs First regular expression submatch.
1116	* @param __rhs Second regular expression submatch.
1117	* @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1118	*/
1119	template<typename _BiIter>
1120	inline bool
1121	operator>=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1122	{ return __lhs.compare(__rhs) >= 0; }
1123
1124	/**
1125	* @brief Tests the ordering of two regular expression submatches.
1126	* @param __lhs First regular expression submatch.
1127	* @param __rhs Second regular expression submatch.
1128	* @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1129	*/
1130	template<typename _BiIter>
1131	inline bool
1132	operator>(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1133	{ return __lhs.compare(__rhs) > 0; }
1134	#endif // three-way comparison
1135
1136	/// @cond undocumented
1137
1138	// Alias for a basic_string that can be compared to a sub_match.
1139	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1140	using __sub_match_string = basic_string<
1141	typename iterator_traits<_Bi_iter>::value_type,
1142	_Ch_traits, _Ch_alloc>;
1143	/// @endcond
1144
1145	#if ! __cpp_lib_three_way_comparison
1146	/**
1147	* @brief Tests the equivalence of a string and a regular expression
1148	* submatch.
1149	* @param __lhs A string.
1150	* @param __rhs A regular expression submatch.
1151	* @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1152	*/
1153	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1154	inline bool
1155	operator==(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1156	const sub_match<_Bi_iter>& __rhs)
1157	{ return __rhs._M_compare(__lhs.data(), __lhs.size()) == 0; }
1158
1159	/**
1160	* @brief Tests the inequivalence of a string and a regular expression
1161	* submatch.
1162	* @param __lhs A string.
1163	* @param __rhs A regular expression submatch.
1164	* @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1165	*/
1166	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1167	inline bool
1168	operator!=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1169	const sub_match<_Bi_iter>& __rhs)
1170	{ return !(__lhs == __rhs); }
1171
1172	/**
1173	* @brief Tests the ordering of a string and a regular expression submatch.
1174	* @param __lhs A string.
1175	* @param __rhs A regular expression submatch.
1176	* @returns true if @a __lhs precedes @a __rhs, false otherwise.
1177	*/
1178	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1179	inline bool
1180	operator<(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1181	const sub_match<_Bi_iter>& __rhs)
1182	{ return __rhs._M_compare(__lhs.data(), __lhs.size()) > 0; }
1183
1184	/**
1185	* @brief Tests the ordering of a string and a regular expression submatch.
1186	* @param __lhs A string.
1187	* @param __rhs A regular expression submatch.
1188	* @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1189	*/
1190	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1191	inline bool
1192	operator>(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1193	const sub_match<_Bi_iter>& __rhs)
1194	{ return __rhs < __lhs; }
1195
1196	/**
1197	* @brief Tests the ordering of a string and a regular expression submatch.
1198	* @param __lhs A string.
1199	* @param __rhs A regular expression submatch.
1200	* @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1201	*/
1202	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1203	inline bool
1204	operator>=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1205	const sub_match<_Bi_iter>& __rhs)
1206	{ return !(__lhs < __rhs); }
1207
1208	/**
1209	* @brief Tests the ordering of a string and a regular expression submatch.
1210	* @param __lhs A string.
1211	* @param __rhs A regular expression submatch.
1212	* @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1213	*/
1214	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1215	inline bool
1216	operator<=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1217	const sub_match<_Bi_iter>& __rhs)
1218	{ return !(__rhs < __lhs); }
1219	#endif // three-way comparison
1220
1221	/**
1222	* @brief Tests the equivalence of a regular expression submatch and a
1223	* string.
1224	* @param __lhs A regular expression submatch.
1225	* @param __rhs A string.
1226	* @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1227	*/
1228	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1229	inline bool
1230	operator==(const sub_match<_Bi_iter>& __lhs,
1231	const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1232	{ return __lhs._M_compare(__rhs.data(), __rhs.size()) == 0; }
1233
1234	#if __cpp_lib_three_way_comparison
1235	/**
1236	* @brief Three-way comparison of a regular expression submatch and a string.
1237	* @param __lhs A regular expression submatch.
1238	* @param __rhs A string.
1239	* @returns A value indicating whether `__lhs` is less than, equal to,
1240	* greater than, or incomparable with `__rhs`.
1241	*/
1242	template<typename _Bi_iter, typename _Ch_traits, typename _Alloc>
1243	inline auto
1244	operator<=>(const sub_match<_Bi_iter>& __lhs,
1245	const __sub_match_string<_Bi_iter, _Ch_traits, _Alloc>& __rhs)
1246	noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1247	{
1248	return __detail::__char_traits_cmp_cat<_Ch_traits>(
1249	__lhs._M_compare(__rhs.data(), __rhs.size()));
1250	}
1251	#else
1252	/**
1253	* @brief Tests the inequivalence of a regular expression submatch and a
1254	* string.
1255	* @param __lhs A regular expression submatch.
1256	* @param __rhs A string.
1257	* @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1258	*/
1259	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1260	inline bool
1261	operator!=(const sub_match<_Bi_iter>& __lhs,
1262	const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1263	{ return !(__lhs == __rhs); }
1264
1265	/**
1266	* @brief Tests the ordering of a regular expression submatch and a string.
1267	* @param __lhs A regular expression submatch.
1268	* @param __rhs A string.
1269	* @returns true if @a __lhs precedes @a __rhs, false otherwise.
1270	*/
1271	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1272	inline bool
1273	operator<(const sub_match<_Bi_iter>& __lhs,
1274	const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1275	{ return __lhs._M_compare(__rhs.data(), __rhs.size()) < 0; }
1276
1277	/**
1278	* @brief Tests the ordering of a regular expression submatch and a string.
1279	* @param __lhs A regular expression submatch.
1280	* @param __rhs A string.
1281	* @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1282	*/
1283	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1284	inline bool
1285	operator>(const sub_match<_Bi_iter>& __lhs,
1286	const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1287	{ return __rhs < __lhs; }
1288
1289	/**
1290	* @brief Tests the ordering of a regular expression submatch and a string.
1291	* @param __lhs A regular expression submatch.
1292	* @param __rhs A string.
1293	* @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1294	*/
1295	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1296	inline bool
1297	operator>=(const sub_match<_Bi_iter>& __lhs,
1298	const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1299	{ return !(__lhs < __rhs); }
1300
1301	/**
1302	* @brief Tests the ordering of a regular expression submatch and a string.
1303	* @param __lhs A regular expression submatch.
1304	* @param __rhs A string.
1305	* @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1306	*/
1307	template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1308	inline bool
1309	operator<=(const sub_match<_Bi_iter>& __lhs,
1310	const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1311	{ return !(__rhs < __lhs); }
1312
1313	/**
1314	* @brief Tests the equivalence of a C string and a regular expression
1315	* submatch.
1316	* @param __lhs A null-terminated string.
1317	* @param __rhs A regular expression submatch.
1318	* @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1319	*/
1320	template<typename _Bi_iter>
1321	inline bool
1322	operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1323	const sub_match<_Bi_iter>& __rhs)
1324	{ return __rhs.compare(__lhs) == 0; }
1325
1326	/**
1327	* @brief Tests the inequivalence of a C string and a regular
1328	* expression submatch.
1329	* @param __lhs A null-terminated string.
1330	* @param __rhs A regular expression submatch.
1331	* @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1332	*/
1333	template<typename _Bi_iter>
1334	inline bool
1335	operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1336	const sub_match<_Bi_iter>& __rhs)
1337	{ return !(__lhs == __rhs); }
1338
1339	/**
1340	* @brief Tests the ordering of a C string and a regular expression submatch.
1341	* @param __lhs A null-terminated string.
1342	* @param __rhs A regular expression submatch.
1343	* @returns true if @a __lhs precedes @a __rhs, false otherwise.
1344	*/
1345	template<typename _Bi_iter>
1346	inline bool
1347	operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1348	const sub_match<_Bi_iter>& __rhs)
1349	{ return __rhs.compare(__lhs) > 0; }
1350
1351	/**
1352	* @brief Tests the ordering of a C string and a regular expression submatch.
1353	* @param __lhs A null-terminated string.
1354	* @param __rhs A regular expression submatch.
1355	* @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1356	*/
1357	template<typename _Bi_iter>
1358	inline bool
1359	operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1360	const sub_match<_Bi_iter>& __rhs)
1361	{ return __rhs < __lhs; }
1362
1363	/**
1364	* @brief Tests the ordering of a C string and a regular expression submatch.
1365	* @param __lhs A null-terminated string.
1366	* @param __rhs A regular expression submatch.
1367	* @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1368	*/
1369	template<typename _Bi_iter>
1370	inline bool
1371	operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1372	const sub_match<_Bi_iter>& __rhs)
1373	{ return !(__lhs < __rhs); }
1374
1375	/**
1376	* @brief Tests the ordering of a C string and a regular expression submatch.
1377	* @param __lhs A null-terminated string.
1378	* @param __rhs A regular expression submatch.
1379	* @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1380	*/
1381	template<typename _Bi_iter>
1382	inline bool
1383	operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1384	const sub_match<_Bi_iter>& __rhs)
1385	{ return !(__rhs < __lhs); }
1386	#endif // three-way comparison
1387
1388	/**
1389	* @brief Tests the equivalence of a regular expression submatch and a C
1390	* string.
1391	* @param __lhs A regular expression submatch.
1392	* @param __rhs A null-terminated string.
1393	* @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1394	*/
1395	template<typename _Bi_iter>
1396	inline bool
1397	operator==(const sub_match<_Bi_iter>& __lhs,
1398	typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1399	{ return __lhs.compare(__rhs) == 0; }
1400
1401	#if __cpp_lib_three_way_comparison
1402	/**
1403	* @brief Three-way comparison of a regular expression submatch and a C
1404	* string.
1405	* @param __lhs A regular expression submatch.
1406	* @param __rhs A null-terminated string.
1407	* @returns A value indicating whether `__lhs` is less than, equal to,
1408	* greater than, or incomparable with `__rhs`.
1409	*/
1410	template<typename _Bi_iter>
1411	inline auto
1412	operator<=>(const sub_match<_Bi_iter>& __lhs,
1413	typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1414	noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1415	{
1416	using _Tr = char_traits<typename iterator_traits<_Bi_iter>::value_type>;
1417	return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
1418	}
1419	#else
1420	/**
1421	* @brief Tests the inequivalence of a regular expression submatch and a
1422	* string.
1423	* @param __lhs A regular expression submatch.
1424	* @param __rhs A null-terminated string.
1425	* @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1426	*/
1427	template<typename _Bi_iter>
1428	inline bool
1429	operator!=(const sub_match<_Bi_iter>& __lhs,
1430	typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1431	{ return !(__lhs == __rhs); }
1432
1433	/**
1434	* @brief Tests the ordering of a regular expression submatch and a C string.
1435	* @param __lhs A regular expression submatch.
1436	* @param __rhs A null-terminated string.
1437	* @returns true if @a __lhs precedes @a __rhs, false otherwise.
1438	*/
1439	template<typename _Bi_iter>
1440	inline bool
1441	operator<(const sub_match<_Bi_iter>& __lhs,
1442	typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1443	{ return __lhs.compare(__rhs) < 0; }
1444
1445	/**
1446	* @brief Tests the ordering of a regular expression submatch and a C string.
1447	* @param __lhs A regular expression submatch.
1448	* @param __rhs A null-terminated string.
1449	* @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1450	*/
1451	template<typename _Bi_iter>
1452	inline bool
1453	operator>(const sub_match<_Bi_iter>& __lhs,
1454	typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1455	{ return __rhs < __lhs; }
1456
1457	/**
1458	* @brief Tests the ordering of a regular expression submatch and a C string.
1459	* @param __lhs A regular expression submatch.
1460	* @param __rhs A null-terminated string.
1461	* @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1462	*/
1463	template<typename _Bi_iter>
1464	inline bool
1465	operator>=(const sub_match<_Bi_iter>& __lhs,
1466	typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1467	{ return !(__lhs < __rhs); }
1468
1469	/**
1470	* @brief Tests the ordering of a regular expression submatch and a C string.
1471	* @param __lhs A regular expression submatch.
1472	* @param __rhs A null-terminated string.
1473	* @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1474	*/
1475	template<typename _Bi_iter>
1476	inline bool
1477	operator<=(const sub_match<_Bi_iter>& __lhs,
1478	typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1479	{ return !(__rhs < __lhs); }
1480
1481	/**
1482	* @brief Tests the equivalence of a character and a regular expression
1483	* submatch.
1484	* @param __lhs A character.
1485	* @param __rhs A regular expression submatch.
1486	* @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1487	*/
1488	template<typename _Bi_iter>
1489	inline bool
1490	operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1491	const sub_match<_Bi_iter>& __rhs)
1492	{ return __rhs._M_compare(std::__addressof(__lhs), 1) == 0; }
1493
1494	/**
1495	* @brief Tests the inequivalence of a character and a regular expression
1496	* submatch.
1497	* @param __lhs A character.
1498	* @param __rhs A regular expression submatch.
1499	* @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1500	*/
1501	template<typename _Bi_iter>
1502	inline bool
1503	operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1504	const sub_match<_Bi_iter>& __rhs)
1505	{ return !(__lhs == __rhs); }
1506
1507	/**
1508	* @brief Tests the ordering of a character and a regular expression
1509	* submatch.
1510	* @param __lhs A character.
1511	* @param __rhs A regular expression submatch.
1512	* @returns true if @a __lhs precedes @a __rhs, false otherwise.
1513	*/
1514	template<typename _Bi_iter>
1515	inline bool
1516	operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1517	const sub_match<_Bi_iter>& __rhs)
1518	{ return __rhs._M_compare(std::__addressof(__lhs), 1) > 0; }
1519
1520	/**
1521	* @brief Tests the ordering of a character and a regular expression
1522	* submatch.
1523	* @param __lhs A character.
1524	* @param __rhs A regular expression submatch.
1525	* @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1526	*/
1527	template<typename _Bi_iter>
1528	inline bool
1529	operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1530	const sub_match<_Bi_iter>& __rhs)
1531	{ return __rhs < __lhs; }
1532
1533	/**
1534	* @brief Tests the ordering of a character and a regular expression
1535	* submatch.
1536	* @param __lhs A character.
1537	* @param __rhs A regular expression submatch.
1538	* @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1539	*/
1540	template<typename _Bi_iter>
1541	inline bool
1542	operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1543	const sub_match<_Bi_iter>& __rhs)
1544	{ return !(__lhs < __rhs); }
1545
1546	/**
1547	* @brief Tests the ordering of a character and a regular expression
1548	* submatch.
1549	* @param __lhs A character.
1550	* @param __rhs A regular expression submatch.
1551	* @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1552	*/
1553	template<typename _Bi_iter>
1554	inline bool
1555	operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1556	const sub_match<_Bi_iter>& __rhs)
1557	{ return !(__rhs < __lhs); }
1558	#endif // three-way comparison
1559
1560	/**
1561	* @brief Tests the equivalence of a regular expression submatch and a
1562	* character.
1563	* @param __lhs A regular expression submatch.
1564	* @param __rhs A character.
1565	* @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1566	*/
1567	template<typename _Bi_iter>
1568	inline bool
1569	operator==(const sub_match<_Bi_iter>& __lhs,
1570	typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1571	{ return __lhs._M_compare(std::__addressof(__rhs), 1) == 0; }
1572
1573	#if __cpp_lib_three_way_comparison
1574	/**
1575	* @brief Three-way comparison of a regular expression submatch and a
1576	* character.
1577	* @param __lhs A regular expression submatch.
1578	* @param __rhs A character.
1579	* @returns A value indicating whether `__lhs` is less than, equal to,
1580	* greater than, or incomparable with `__rhs`.
1581	*/
1582
1583	template<typename _Bi_iter>
1584	inline auto
1585	operator<=>(const sub_match<_Bi_iter>& __lhs,
1586	typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1587	noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1588	{
1589	using _Tr = char_traits<typename iterator_traits<_Bi_iter>::value_type>;
1590	return __detail::__char_traits_cmp_cat<_Tr>(
1591	__lhs._M_compare(std::__addressof(__rhs), 1));
1592	}
1593	#else
1594	/**
1595	* @brief Tests the inequivalence of a regular expression submatch and a
1596	* character.
1597	* @param __lhs A regular expression submatch.
1598	* @param __rhs A character.
1599	* @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1600	*/
1601	template<typename _Bi_iter>
1602	inline bool
1603	operator!=(const sub_match<_Bi_iter>& __lhs,
1604	typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1605	{ return !(__lhs == __rhs); }
1606
1607	/**
1608	* @brief Tests the ordering of a regular expression submatch and a
1609	* character.
1610	* @param __lhs A regular expression submatch.
1611	* @param __rhs A character.
1612	* @returns true if @a __lhs precedes @a __rhs, false otherwise.
1613	*/
1614	template<typename _Bi_iter>
1615	inline bool
1616	operator<(const sub_match<_Bi_iter>& __lhs,
1617	typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1618	{ return __lhs._M_compare(std::__addressof(__rhs), 1) < 0; }
1619
1620	/**
1621	* @brief Tests the ordering of a regular expression submatch and a
1622	* character.
1623	* @param __lhs A regular expression submatch.
1624	* @param __rhs A character.
1625	* @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1626	*/
1627	template<typename _Bi_iter>
1628	inline bool
1629	operator>(const sub_match<_Bi_iter>& __lhs,
1630	typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1631	{ return __rhs < __lhs; }
1632
1633	/**
1634	* @brief Tests the ordering of a regular expression submatch and a
1635	* character.
1636	* @param __lhs A regular expression submatch.
1637	* @param __rhs A character.
1638	* @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1639	*/
1640	template<typename _Bi_iter>
1641	inline bool
1642	operator>=(const sub_match<_Bi_iter>& __lhs,
1643	typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1644	{ return !(__lhs < __rhs); }
1645
1646	/**
1647	* @brief Tests the ordering of a regular expression submatch and a
1648	* character.
1649	* @param __lhs A regular expression submatch.
1650	* @param __rhs A character.
1651	* @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1652	*/
1653	template<typename _Bi_iter>
1654	inline bool
1655	operator<=(const sub_match<_Bi_iter>& __lhs,
1656	typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1657	{ return !(__rhs < __lhs); }
1658	#endif // three-way comparison
1659
1660	/**
1661	* @brief Inserts a matched string into an output stream.
1662	*
1663	* @param __os The output stream.
1664	* @param __m A submatch string.
1665	*
1666	* @returns the output stream with the submatch string inserted.
1667	*/
1668	template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
1669	inline
1670	basic_ostream<_Ch_type, _Ch_traits>&
1671	operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
1672	const sub_match<_Bi_iter>& __m)
1673	{ return __os << __m.str(); }
1674
1675	/// @} relates sub_match
1676
1677	// [7.10] Class template match_results
1678
1679	/**
1680	* @brief The results of a match or search operation.
1681	*
1682	* A collection of character sequences representing the result of a regular
1683	* expression match. Storage for the collection is allocated and freed as
1684	* necessary by the member functions of class template match_results.
1685	*
1686	* This class satisfies the Sequence requirements, with the exception that
1687	* only the operations defined for a const-qualified Sequence are supported.
1688	*
1689	* The sub_match object stored at index 0 represents sub-expression 0, i.e.
1690	* the whole match. In this case the %sub_match member matched is always true.
1691	* The sub_match object stored at index n denotes what matched the marked
1692	* sub-expression n within the matched expression. If the sub-expression n
1693	* participated in a regular expression match then the %sub_match member
1694	* matched evaluates to true, and members first and second denote the range
1695	* of characters [first, second) which formed that match. Otherwise matched
1696	* is false, and members first and second point to the end of the sequence
1697	* that was searched.
1698	*/
1699	template<typename _Bi_iter,
1700	typename _Alloc = allocator<sub_match<_Bi_iter> > >
1701	class match_results
1702	: private std::vector<sub_match<_Bi_iter>, _Alloc>
1703	{
1704	private:
1705	/*
1706	* The vector base is empty if this does not represent a match (!ready());
1707	* Otherwise if it's a match failure, it contains 3 elements:
1708	* [0] unmatched
1709	* [1] prefix
1710	* [2] suffix
1711	* Otherwise it contains n+4 elements where n is the number of marked
1712	* sub-expressions:
1713	* [0] entire match
1714	* [1] 1st marked subexpression
1715	* ...
1716	* [n] nth marked subexpression
1717	* [n+1] unmatched
1718	* [n+2] prefix
1719	* [n+3] suffix
1720	*/
1721	typedef std::vector<sub_match<_Bi_iter>, _Alloc> _Base_type;
1722	typedef std::iterator_traits<_Bi_iter> __iter_traits;
1723	typedef regex_constants::match_flag_type match_flag_type;
1724
1725	public:
1726	/**
1727	* @name 28.10 Public Types
1728	*/
1729	///@{
1730	typedef sub_match<_Bi_iter> value_type;
1731	typedef const value_type& const_reference;
1732	typedef value_type& reference;
1733	typedef typename _Base_type::const_iterator const_iterator;
1734	typedef const_iterator iterator;
1735	typedef typename __iter_traits::difference_type difference_type;
1736	typedef typename allocator_traits<_Alloc>::size_type size_type;
1737	typedef _Alloc allocator_type;
1738	typedef typename __iter_traits::value_type char_type;
1739	typedef std::basic_string<char_type> string_type;
1740	///@}
1741
1742	public:
1743	/**
1744	* @name 28.10.1 Construction, Copying, and Destruction
1745	*/
1746	///@{
1747
1748	/**
1749	* @brief Constructs a default %match_results container.
1750	* @post size() returns 0 and str() returns an empty string.
1751	*/
1752	match_results() : match_results(_Alloc()) { }
1753
1754	/**
1755	* @brief Constructs a default %match_results container.
1756	* @post size() returns 0 and str() returns an empty string.
1757	*/
1758	explicit
1759	match_results(const _Alloc& __a) noexcept
1760	: _Base_type(__a)
1761	{ }
1762
1763	/**
1764	* @brief Copy constructs a %match_results.
1765	*/
1766	match_results(const match_results&) = default;
1767
1768	/**
1769	* @brief Move constructs a %match_results.
1770	*/
1771	match_results(match_results&&) noexcept = default;
1772
1773	/**
1774	* @brief Assigns rhs to *this.
1775	*/
1776	match_results&
1777	operator=(const match_results&) = default;
1778
1779	/**
1780	* @brief Move-assigns rhs to *this.
1781	*/
1782	match_results&
1783	operator=(match_results&&) = default;
1784
1785	/**
1786	* @brief Destroys a %match_results object.
1787	*/
1788	~match_results() = default;
1789
1790	///@}
1791
1792	// 28.10.2, state:
1793	/**
1794	* @brief Indicates if the %match_results is ready.
1795	* @retval true The object has a fully-established result state.
1796	* @retval false The object is not ready.
1797	*/
1798	bool ready() const noexcept { return !_Base_type::empty(); }
1799
1800	/**
1801	* @name 28.10.2 Size
1802	*/
1803	///@{
1804
1805	/**
1806	* @brief Gets the number of matches and submatches.
1807	*
1808	* The number of matches for a given regular expression will be either 0
1809	* if there was no match or mark_count() + 1 if a match was successful.
1810	* Some matches may be empty.
1811	*
1812	* @returns the number of matches found.
1813	*/
1814	size_type
1815	size() const noexcept
1816	{ return _Base_type::empty() ? 0 : _Base_type::size() - 3; }
1817
1818	size_type
1819	max_size() const noexcept
1820	{ return _Base_type::max_size() - 3; }
1821
1822	/**
1823	* @brief Indicates if the %match_results contains no results.
1824	* @retval true The %match_results object is empty.
1825	* @retval false The %match_results object is not empty.
1826	*/
1827	_GLIBCXX_NODISCARD bool
1828	empty() const noexcept
1829	{ return _Base_type::size() <= 3; }
1830
1831	///@}
1832
1833	/**
1834	* @name 28.10.4 Element Access
1835	*/
1836	///@{
1837
1838	/**
1839	* @brief Gets the length of the indicated submatch.
1840	* @param __sub indicates the submatch.
1841	* @pre ready() == true
1842	*
1843	* This function returns the length of the indicated submatch, or the
1844	* length of the entire match if @p __sub is zero (the default).
1845	*/
1846	difference_type
1847	length(size_type __sub = 0) const
1848	{ return (*this)[__sub].length(); }
1849
1850	/**
1851	* @brief Gets the offset of the beginning of the indicated submatch.
1852	* @param __sub indicates the submatch.
1853	* @pre ready() == true
1854	*
1855	* This function returns the offset from the beginning of the target
1856	* sequence to the beginning of the submatch, unless the value of @p __sub
1857	* is zero (the default), in which case this function returns the offset
1858	* from the beginning of the target sequence to the beginning of the
1859	* match.
1860	*/
1861	difference_type
1862	position(size_type __sub = 0) const
1863	{ return std::distance(_M_begin, (*this)[__sub].first); }
1864
1865	/**
1866	* @brief Gets the match or submatch converted to a string type.
1867	* @param __sub indicates the submatch.
1868	* @pre ready() == true
1869	*
1870	* This function gets the submatch (or match, if @p __sub is
1871	* zero) extracted from the target range and converted to the
1872	* associated string type.
1873	*/
1874	string_type
1875	str(size_type __sub = 0) const
1876	{ return string_type((*this)[__sub]); }
1877
1878	/**
1879	* @brief Gets a %sub_match reference for the match or submatch.
1880	* @param __sub indicates the submatch.
1881	* @pre ready() == true
1882	*
1883	* This function gets a reference to the indicated submatch, or
1884	* the entire match if @p __sub is zero.
1885	*
1886	* If @p __sub >= size() then this function returns a %sub_match with a
1887	* special value indicating no submatch.
1888	*/
1889	const_reference
1890	operator[](size_type __sub) const
1891	{
1892	__glibcxx_assert( ready() );
1893	return __sub < size()
1894	? _Base_type::operator[](__sub)
1895	: _M_unmatched_sub();
1896	}
1897
1898	/**
1899	* @brief Gets a %sub_match representing the match prefix.
1900	* @pre ready() == true
1901	*
1902	* This function gets a reference to a %sub_match object representing the
1903	* part of the target range between the start of the target range and the
1904	* start of the match.
1905	*/
1906	const_reference
1907	prefix() const
1908	{
1909	__glibcxx_assert( ready() );
1910	return !empty() ? _M_prefix() : _M_unmatched_sub();
1911	}
1912
1913	/**
1914	* @brief Gets a %sub_match representing the match suffix.
1915	* @pre ready() == true
1916	*
1917	* This function gets a reference to a %sub_match object representing the
1918	* part of the target range between the end of the match and the end of
1919	* the target range.
1920	*/
1921	const_reference
1922	suffix() const
1923	{
1924	__glibcxx_assert( ready() );
1925	return !empty() ? _M_suffix() : _M_unmatched_sub();
1926	}
1927
1928	/**
1929	* @brief Gets an iterator to the start of the %sub_match collection.
1930	*/
1931	const_iterator
1932	begin() const noexcept
1933	{ return _Base_type::begin(); }
1934
1935	/**
1936	* @brief Gets an iterator to the start of the %sub_match collection.
1937	*/
1938	const_iterator
1939	cbegin() const noexcept
1940	{ return this->begin(); }
1941
1942	/**
1943	* @brief Gets an iterator to one-past-the-end of the collection.
1944	*/
1945	const_iterator
1946	end() const noexcept
1947	{ return _Base_type::end() - (_Base_type::empty() ? 0 : 3); }
1948
1949	/**
1950	* @brief Gets an iterator to one-past-the-end of the collection.
1951	*/
1952	const_iterator
1953	cend() const noexcept
1954	{ return this->end(); }
1955
1956	///@}
1957
1958	/**
1959	* @name 28.10.5 Formatting
1960	*
1961	* These functions perform formatted substitution of the matched
1962	* character sequences into their target. The format specifiers and
1963	* escape sequences accepted by these functions are determined by
1964	* their @p flags parameter as documented above.
1965	*/
1966	///@{
1967
1968	/**
1969	* @pre ready() == true
1970	*/
1971	template<typename _Out_iter>
1972	_Out_iter
1973	format(_Out_iter __out, const char_type* __fmt_first,
1974	const char_type* __fmt_last,
1975	match_flag_type __flags = regex_constants::format_default) const;
1976
1977	/**
1978	* @pre ready() == true
1979	*/
1980	template<typename _Out_iter, typename _St, typename _Sa>
1981	_Out_iter
1982	format(_Out_iter __out, const basic_string<char_type, _St, _Sa>& __fmt,
1983	match_flag_type __flags = regex_constants::format_default) const
1984	{
1985	return format(__out, __fmt.data(), __fmt.data() + __fmt.size(),
1986	__flags);
1987	}
1988
1989	/**
1990	* @pre ready() == true
1991	*/
1992	template<typename _St, typename _Sa>
1993	basic_string<char_type, _St, _Sa>
1994	format(const basic_string<char_type, _St, _Sa>& __fmt,
1995	match_flag_type __flags = regex_constants::format_default) const
1996	{
1997	basic_string<char_type, _St, _Sa> __result;
1998	format(std::back_inserter(__result), __fmt, __flags);
1999	return __result;
2000	}
2001
2002	/**
2003	* @pre ready() == true
2004	*/
2005	string_type
2006	format(const char_type* __fmt,
2007	match_flag_type __flags = regex_constants::format_default) const
2008	{
2009	string_type __result;
2010	format(std::back_inserter(__result),
2011	__fmt,
2012	__fmt + char_traits<char_type>::length(__fmt),
2013	__flags);
2014	return __result;
2015	}
2016
2017	///@}
2018
2019	/**
2020	* @name 28.10.6 Allocator
2021	*/
2022	///@{
2023
2024	/**
2025	* @brief Gets a copy of the allocator.
2026	*/
2027	allocator_type
2028	get_allocator() const noexcept
2029	{ return _Base_type::get_allocator(); }
2030
2031	///@}
2032
2033	/**
2034	* @name 28.10.7 Swap
2035	*/
2036	///@{
2037
2038	/**
2039	* @brief Swaps the contents of two match_results.
2040	*/
2041	void
2042	swap(match_results& __that) noexcept
2043	{
2044	using std::swap;
2045	_Base_type::swap(__that);
2046	swap(_M_begin, __that._M_begin);
2047	}
2048	///@}
2049
2050	private:
2051	template<typename, typename, typename>
2052	friend class regex_iterator;
2053
2054	/// @cond undocumented
2055
2056	template<typename, typename, typename, bool>
2057	friend class __detail::_Executor;
2058
2059	template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
2060	__detail::_RegexExecutorPolicy, bool>
2061	friend bool
2062	__detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
2063	const basic_regex<_Cp, _Rp>&,
2064	regex_constants::match_flag_type);
2065
2066	// Reset contents to __size unmatched sub_match objects
2067	// (plus additional objects for prefix, suffix and unmatched sub).
2068	void
2069	_M_resize(unsigned int __size)
2070	{ _Base_type::assign(__size + 3, sub_match<_Bi_iter>{}); }
2071
2072	// Set state to a failed match for the given past-the-end iterator.
2073	void
2074	_M_establish_failed_match(_Bi_iter __end)
2075	{
2076	sub_match<_Bi_iter> __sm;
2077	__sm.first = __sm.second = __end;
2078	_Base_type::assign(3, __sm);
2079	}
2080
2081	const_reference
2082	_M_unmatched_sub() const
2083	{ return _Base_type::operator[](_Base_type::size() - 3); }
2084
2085	sub_match<_Bi_iter>&
2086	_M_unmatched_sub()
2087	{ return _Base_type::operator[](_Base_type::size() - 3); }
2088
2089	const_reference
2090	_M_prefix() const
2091	{ return _Base_type::operator[](_Base_type::size() - 2); }
2092
2093	sub_match<_Bi_iter>&
2094	_M_prefix()
2095	{ return _Base_type::operator[](_Base_type::size() - 2); }
2096
2097	const_reference
2098	_M_suffix() const
2099	{ return _Base_type::operator[](_Base_type::size() - 1); }
2100
2101	sub_match<_Bi_iter>&
2102	_M_suffix()
2103	{ return _Base_type::operator[](_Base_type::size() - 1); }
2104
2105	_Bi_iter _M_begin {};
2106	/// @endcond
2107	};
2108
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;
2114	#endif
2115
2116	// match_results comparisons
2117
2118	/**
2119	* @brief Compares two match_results for equality.
2120	* @returns true if the two objects refer to the same match,
2121	* false otherwise.
2122	*/
2123	template<typename _Bi_iter, typename _Alloc>
2124	inline bool
2125	operator==(const match_results<_Bi_iter, _Alloc>& __m1,
2126	const match_results<_Bi_iter, _Alloc>& __m2)
2127	{
2128	if (__m1.ready() != __m2.ready())
2129	return false;
2130	if (!__m1.ready()) // both are not ready
2131	return true;
2132	if (__m1.empty() != __m2.empty())
2133	return false;
2134	if (__m1.empty()) // both are empty
2135	return true;
2136	return __m1.prefix() == __m2.prefix()
2137	&& __m1.size() == __m2.size()
2138	&& std::equal(__m1.begin(), __m1.end(), __m2.begin())
2139	&& __m1.suffix() == __m2.suffix();
2140	}
2141
2142	#if ! __cpp_lib_three_way_comparison
2143	/**
2144	* @brief Compares two match_results for inequality.
2145	* @returns true if the two objects do not refer to the same match,
2146	* false otherwise.
2147	*/
2148	template<typename _Bi_iter, class _Alloc>
2149	inline bool
2150	operator!=(const match_results<_Bi_iter, _Alloc>& __m1,
2151	const match_results<_Bi_iter, _Alloc>& __m2)
2152	{ return !(__m1 == __m2); }
2153	#endif
2154
2155	// [7.10.6] match_results swap
2156	/**
2157	* @brief Swaps two match results.
2158	* @param __lhs A match result.
2159	* @param __rhs A match result.
2160	*
2161	* The contents of the two match_results objects are swapped.
2162	*/
2163	template<typename _Bi_iter, typename _Alloc>
2164	inline void
2165	swap(match_results<_Bi_iter, _Alloc>& __lhs,
2166	match_results<_Bi_iter, _Alloc>& __rhs) noexcept
2167	{ __lhs.swap(__rhs); }
2168
2169	_GLIBCXX_END_NAMESPACE_CXX11
2170
2171	// [28.11.2] Function template regex_match
2172	/**
2173	* @name Matching, Searching, and Replacing
2174	*/
2175	///@{
2176
2177	/**
2178	* @brief Determines if there is a match between the regular expression @p e
2179	* and all of the character sequence [first, last).
2180	*
2181	* @param __s Start of the character sequence to match.
2182	* @param __e One-past-the-end of the character sequence to match.
2183	* @param __m The match results.
2184	* @param __re The regular expression.
2185	* @param __flags Controls how the regular expression is matched.
2186	*
2187	* @retval true A match exists.
2188	* @retval false Otherwise.
2189	*
2190	* @throws an exception of type regex_error.
2191	*/
2192	template<typename _Bi_iter, typename _Alloc,
2193	typename _Ch_type, typename _Rx_traits>
2194	inline bool
2195	regex_match(_Bi_iter __s,
2196	_Bi_iter __e,
2197	match_results<_Bi_iter, _Alloc>& __m,
2198	const basic_regex<_Ch_type, _Rx_traits>& __re,
2199	regex_constants::match_flag_type __flags
2200	= regex_constants::match_default)
2201	{
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);
2205	}
2206
2207	/**
2208	* @brief Indicates if there is a match between the regular expression @p e
2209	* and all of the character sequence [first, last).
2210	*
2211	* @param __first Beginning of the character sequence to match.
2212	* @param __last One-past-the-end of the character sequence to match.
2213	* @param __re The regular expression.
2214	* @param __flags Controls how the regular expression is matched.
2215	*
2216	* @retval true A match exists.
2217	* @retval false Otherwise.
2218	*
2219	* @throws an exception of type regex_error.
2220	*/
2221	template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
2222	inline bool
2223	regex_match(_Bi_iter __first, _Bi_iter __last,
2224	const basic_regex<_Ch_type, _Rx_traits>& __re,
2225	regex_constants::match_flag_type __flags
2226	= regex_constants::match_default)
2227	{
2228	match_results<_Bi_iter> __what;
2229	return regex_match(__first, __last, __what, __re, __flags);
2230	}
2231
2232	/**
2233	* @brief Determines if there is a match between the regular expression @p e
2234	* and a C-style null-terminated string.
2235	*
2236	* @param __s The C-style null-terminated string to match.
2237	* @param __m The match results.
2238	* @param __re The regular expression.
2239	* @param __f Controls how the regular expression is matched.
2240	*
2241	* @retval true A match exists.
2242	* @retval false Otherwise.
2243	*
2244	* @throws an exception of type regex_error.
2245	*/
2246	template<typename _Ch_type, typename _Alloc, typename _Rx_traits>
2247	inline bool
2248	regex_match(const _Ch_type* __s,
2249	match_results<const _Ch_type*, _Alloc>& __m,
2250	const basic_regex<_Ch_type, _Rx_traits>& __re,
2251	regex_constants::match_flag_type __f
2252	= regex_constants::match_default)
2253	{ return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
2254
2255	/**
2256	* @brief Determines if there is a match between the regular expression @p e
2257	* and a string.
2258	*
2259	* @param __s The string to match.
2260	* @param __m The match results.
2261	* @param __re The regular expression.
2262	* @param __flags Controls how the regular expression is matched.
2263	*
2264	* @retval true A match exists.
2265	* @retval false Otherwise.
2266	*
2267	* @throws an exception of type regex_error.
2268	*/
2269	template<typename _Ch_traits, typename _Ch_alloc,
2270	typename _Alloc, typename _Ch_type, typename _Rx_traits>
2271	inline bool
2272	regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
2273	match_results<typename basic_string<_Ch_type,
2274	_Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2275	const basic_regex<_Ch_type, _Rx_traits>& __re,
2276	regex_constants::match_flag_type __flags
2277	= regex_constants::match_default)
2278	{ return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
2279
2280	// _GLIBCXX_RESOLVE_LIB_DEFECTS
2281	// 2329. regex_match() with match_results should forbid temporary strings
2282	/// Prevent unsafe attempts to get match_results from a temporary string.
2283	template<typename _Ch_traits, typename _Ch_alloc,
2284	typename _Alloc, typename _Ch_type, typename _Rx_traits>
2285	bool
2286	regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>&&,
2287	match_results<typename basic_string<_Ch_type,
2288	_Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2289	const basic_regex<_Ch_type, _Rx_traits>&,
2290	regex_constants::match_flag_type
2291	= regex_constants::match_default) = delete;
2292
2293	/**
2294	* @brief Indicates if there is a match between the regular expression @p e
2295	* and a C-style null-terminated string.
2296	*
2297	* @param __s The C-style null-terminated string to match.
2298	* @param __re The regular expression.
2299	* @param __f Controls how the regular expression is matched.
2300	*
2301	* @retval true A match exists.
2302	* @retval false Otherwise.
2303	*
2304	* @throws an exception of type regex_error.
2305	*/
2306	template<typename _Ch_type, class _Rx_traits>
2307	inline bool
2308	regex_match(const _Ch_type* __s,
2309	const basic_regex<_Ch_type, _Rx_traits>& __re,
2310	regex_constants::match_flag_type __f
2311	= regex_constants::match_default)
2312	{ return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
2313
2314	/**
2315	* @brief Indicates if there is a match between the regular expression @p e
2316	* and a string.
2317	*
2318	* @param __s [IN] The string to match.
2319	* @param __re [IN] The regular expression.
2320	* @param __flags [IN] Controls how the regular expression is matched.
2321	*
2322	* @retval true A match exists.
2323	* @retval false Otherwise.
2324	*
2325	* @throws an exception of type regex_error.
2326	*/
2327	template<typename _Ch_traits, typename _Str_allocator,
2328	typename _Ch_type, typename _Rx_traits>
2329	inline bool
2330	regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
2331	const basic_regex<_Ch_type, _Rx_traits>& __re,
2332	regex_constants::match_flag_type __flags
2333	= regex_constants::match_default)
2334	{ return regex_match(__s.begin(), __s.end(), __re, __flags); }
2335
2336	// [7.11.3] Function template regex_search
2337	/**
2338	* Searches for a regular expression within a range.
2339	* @param __s [IN] The start of the string to search.
2340	* @param __e [IN] One-past-the-end of the string to search.
2341	* @param __m [OUT] The match results.
2342	* @param __re [IN] The regular expression to search for.
2343	* @param __flags [IN] Search policy flags.
2344	* @retval true A match was found within the string.
2345	* @retval false No match was found within the string, the content of %m is
2346	* undefined.
2347	*
2348	* @throws an exception of type regex_error.
2349	*/
2350	template<typename _Bi_iter, typename _Alloc,
2351	typename _Ch_type, typename _Rx_traits>
2352	inline bool
2353	regex_search(_Bi_iter __s, _Bi_iter __e,
2354	match_results<_Bi_iter, _Alloc>& __m,
2355	const basic_regex<_Ch_type, _Rx_traits>& __re,
2356	regex_constants::match_flag_type __flags
2357	= regex_constants::match_default)
2358	{
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);
2362	}
2363
2364	/**
2365	* Searches for a regular expression within a range.
2366	* @param __first [IN] The start of the string to search.
2367	* @param __last [IN] One-past-the-end of the string to search.
2368	* @param __re [IN] The regular expression to search for.
2369	* @param __flags [IN] Search policy flags.
2370	* @retval true A match was found within the string.
2371	* @retval false No match was found within the string.
2372	*
2373	* @throws an exception of type regex_error.
2374	*/
2375	template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
2376	inline bool
2377	regex_search(_Bi_iter __first, _Bi_iter __last,
2378	const basic_regex<_Ch_type, _Rx_traits>& __re,
2379	regex_constants::match_flag_type __flags
2380	= regex_constants::match_default)
2381	{
2382	match_results<_Bi_iter> __what;
2383	return regex_search(__first, __last, __what, __re, __flags);
2384	}
2385
2386	/**
2387	* @brief Searches for a regular expression within a C-string.
2388	* @param __s [IN] A C-string to search for the regex.
2389	* @param __m [OUT] The set of regex matches.
2390	* @param __e [IN] The regex to search for in @p s.
2391	* @param __f [IN] The search flags.
2392	* @retval true A match was found within the string.
2393	* @retval false No match was found within the string, the content of %m is
2394	* undefined.
2395	*
2396	* @throws an exception of type regex_error.
2397	*/
2398	template<typename _Ch_type, class _Alloc, class _Rx_traits>
2399	inline bool
2400	regex_search(const _Ch_type* __s,
2401	match_results<const _Ch_type*, _Alloc>& __m,
2402	const basic_regex<_Ch_type, _Rx_traits>& __e,
2403	regex_constants::match_flag_type __f
2404	= regex_constants::match_default)
2405	{ return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
2406
2407	/**
2408	* @brief Searches for a regular expression within a C-string.
2409	* @param __s [IN] The C-string to search.
2410	* @param __e [IN] The regular expression to search for.
2411	* @param __f [IN] Search policy flags.
2412	* @retval true A match was found within the string.
2413	* @retval false No match was found within the string.
2414	*
2415	* @throws an exception of type regex_error.
2416	*/
2417	template<typename _Ch_type, typename _Rx_traits>
2418	inline bool
2419	regex_search(const _Ch_type* __s,
2420	const basic_regex<_Ch_type, _Rx_traits>& __e,
2421	regex_constants::match_flag_type __f
2422	= regex_constants::match_default)
2423	{ return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
2424
2425	/**
2426	* @brief Searches for a regular expression within a string.
2427	* @param __s [IN] The string to search.
2428	* @param __e [IN] The regular expression to search for.
2429	* @param __flags [IN] Search policy flags.
2430	* @retval true A match was found within the string.
2431	* @retval false No match was found within the string.
2432	*
2433	* @throws an exception of type regex_error.
2434	*/
2435	template<typename _Ch_traits, typename _String_allocator,
2436	typename _Ch_type, typename _Rx_traits>
2437	inline bool
2438	regex_search(const basic_string<_Ch_type, _Ch_traits,
2439	_String_allocator>& __s,
2440	const basic_regex<_Ch_type, _Rx_traits>& __e,
2441	regex_constants::match_flag_type __flags
2442	= regex_constants::match_default)
2443	{ return regex_search(__s.begin(), __s.end(), __e, __flags); }
2444
2445	/**
2446	* @brief Searches for a regular expression within a string.
2447	* @param __s [IN] A C++ string to search for the regex.
2448	* @param __m [OUT] The set of regex matches.
2449	* @param __e [IN] The regex to search for in @p s.
2450	* @param __f [IN] The search flags.
2451	* @retval true A match was found within the string.
2452	* @retval false No match was found within the string, the content of %m is
2453	* undefined.
2454	*
2455	* @throws an exception of type regex_error.
2456	*/
2457	template<typename _Ch_traits, typename _Ch_alloc,
2458	typename _Alloc, typename _Ch_type,
2459	typename _Rx_traits>
2460	inline bool
2461	regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
2462	match_results<typename basic_string<_Ch_type,
2463	_Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2464	const basic_regex<_Ch_type, _Rx_traits>& __e,
2465	regex_constants::match_flag_type __f
2466	= regex_constants::match_default)
2467	{ return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
2468
2469	// _GLIBCXX_RESOLVE_LIB_DEFECTS
2470	// 2329. regex_search() with match_results should forbid temporary strings
2471	/// Prevent unsafe attempts to get match_results from a temporary string.
2472	template<typename _Ch_traits, typename _Ch_alloc,
2473	typename _Alloc, typename _Ch_type,
2474	typename _Rx_traits>
2475	bool
2476	regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>&&,
2477	match_results<typename basic_string<_Ch_type,
2478	_Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2479	const basic_regex<_Ch_type, _Rx_traits>&,
2480	regex_constants::match_flag_type
2481	= regex_constants::match_default) = delete;
2482
2483	// std [28.11.4] Function template regex_replace
2484
2485	template<typename _Out_iter, typename _Bi_iter,
2486	typename _Rx_traits, typename _Ch_type>
2487	_Out_iter
2488	__regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
2489	const basic_regex<_Ch_type, _Rx_traits>& __e,
2490	const _Ch_type* __fmt, size_t __len,
2491	regex_constants::match_flag_type __flags);
2492
2493	/**
2494	* @brief Search for a regular expression within a range for multiple times,
2495	and replace the matched parts through filling a format string.
2496	* @param __out [OUT] The output iterator.
2497	* @param __first [IN] The start of the string to search.
2498	* @param __last [IN] One-past-the-end of the string to search.
2499	* @param __e [IN] The regular expression to search for.
2500	* @param __fmt [IN] The format string.
2501	* @param __flags [IN] Search and replace policy flags.
2502	*
2503	* @returns __out
2504	* @throws an exception of type regex_error.
2505	*/
2506	template<typename _Out_iter, typename _Bi_iter,
2507	typename _Rx_traits, typename _Ch_type,
2508	typename _St, typename _Sa>
2509	inline _Out_iter
2510	regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
2511	const basic_regex<_Ch_type, _Rx_traits>& __e,
2512	const basic_string<_Ch_type, _St, _Sa>& __fmt,
2513	regex_constants::match_flag_type __flags
2514	= regex_constants::match_default)
2515	{
2516	return std::__regex_replace(__out, __first, __last, __e, __fmt.c_str(),
2517	__fmt.length(), __flags);
2518	}
2519
2520	/**
2521	* @brief Search for a regular expression within a range for multiple times,
2522	and replace the matched parts through filling a format C-string.
2523	* @param __out [OUT] The output iterator.
2524	* @param __first [IN] The start of the string to search.
2525	* @param __last [IN] One-past-the-end of the string to search.
2526	* @param __e [IN] The regular expression to search for.
2527	* @param __fmt [IN] The format C-string.
2528	* @param __flags [IN] Search and replace policy flags.
2529	*
2530	* @returns __out
2531	* @throws an exception of type regex_error.
2532	*/
2533	template<typename _Out_iter, typename _Bi_iter,
2534	typename _Rx_traits, typename _Ch_type>
2535	_Out_iter
2536	regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
2537	const basic_regex<_Ch_type, _Rx_traits>& __e,
2538	const _Ch_type* __fmt,
2539	regex_constants::match_flag_type __flags
2540	= regex_constants::match_default)
2541	{
2542	return std::__regex_replace(__out, __first, __last, __e, __fmt,
2543	char_traits<_Ch_type>::length(__fmt),
2544	__flags);
2545	}
2546
2547
2548	/**
2549	* @brief Search for a regular expression within a string for multiple times,
2550	and replace the matched parts through filling a format string.
2551	* @param __s [IN] The string to search and replace.
2552	* @param __e [IN] The regular expression to search for.
2553	* @param __fmt [IN] The format string.
2554	* @param __flags [IN] Search and replace policy flags.
2555	*
2556	* @returns The string after replacing.
2557	* @throws an exception of type regex_error.
2558	*/
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>
2562	regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s,
2563	const basic_regex<_Ch_type, _Rx_traits>& __e,
2564	const basic_string<_Ch_type, _Fst, _Fsa>& __fmt,
2565	regex_constants::match_flag_type __flags
2566	= regex_constants::match_default)
2567	{
2568	basic_string<_Ch_type, _St, _Sa> __result;
2569	regex_replace(std::back_inserter(__result),
2570	__s.begin(), __s.end(), __e, __fmt, __flags);
2571	return __result;
2572	}
2573
2574	/**
2575	* @brief Search for a regular expression within a string for multiple times,
2576	and replace the matched parts through filling a format C-string.
2577	* @param __s [IN] The string to search and replace.
2578	* @param __e [IN] The regular expression to search for.
2579	* @param __fmt [IN] The format C-string.
2580	* @param __flags [IN] Search and replace policy flags.
2581	*
2582	* @returns The string after replacing.
2583	* @throws an exception of type regex_error.
2584	*/
2585	template<typename _Rx_traits, typename _Ch_type,
2586	typename _St, typename _Sa>
2587	inline basic_string<_Ch_type, _St, _Sa>
2588	regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s,
2589	const basic_regex<_Ch_type, _Rx_traits>& __e,
2590	const _Ch_type* __fmt,
2591	regex_constants::match_flag_type __flags
2592	= regex_constants::match_default)
2593	{
2594	basic_string<_Ch_type, _St, _Sa> __result;
2595	regex_replace(std::back_inserter(__result),
2596	__s.begin(), __s.end(), __e, __fmt, __flags);
2597	return __result;
2598	}
2599
2600	/**
2601	* @brief Search for a regular expression within a C-string for multiple
2602	times, and replace the matched parts through filling a format string.
2603	* @param __s [IN] The C-string to search and replace.
2604	* @param __e [IN] The regular expression to search for.
2605	* @param __fmt [IN] The format string.
2606	* @param __flags [IN] Search and replace policy flags.
2607	*
2608	* @returns The string after replacing.
2609	* @throws an exception of type regex_error.
2610	*/
2611	template<typename _Rx_traits, typename _Ch_type,
2612	typename _St, typename _Sa>
2613	inline basic_string<_Ch_type>
2614	regex_replace(const _Ch_type* __s,
2615	const basic_regex<_Ch_type, _Rx_traits>& __e,
2616	const basic_string<_Ch_type, _St, _Sa>& __fmt,
2617	regex_constants::match_flag_type __flags
2618	= regex_constants::match_default)
2619	{
2620	basic_string<_Ch_type> __result;
2621	regex_replace(std::back_inserter(__result), __s,
2622	__s + char_traits<_Ch_type>::length(__s),
2623	__e, __fmt, __flags);
2624	return __result;
2625	}
2626
2627	/**
2628	* @brief Search for a regular expression within a C-string for multiple
2629	times, and replace the matched parts through filling a format C-string.
2630	* @param __s [IN] The C-string to search and replace.
2631	* @param __e [IN] The regular expression to search for.
2632	* @param __fmt [IN] The format C-string.
2633	* @param __flags [IN] Search and replace policy flags.
2634	*
2635	* @returns The string after replacing.
2636	* @throws an exception of type regex_error.
2637	*/
2638	template<typename _Rx_traits, typename _Ch_type>
2639	inline basic_string<_Ch_type>
2640	regex_replace(const _Ch_type* __s,
2641	const basic_regex<_Ch_type, _Rx_traits>& __e,
2642	const _Ch_type* __fmt,
2643	regex_constants::match_flag_type __flags
2644	= regex_constants::match_default)
2645	{
2646	basic_string<_Ch_type> __result;
2647	regex_replace(std::back_inserter(__result), __s,
2648	__s + char_traits<_Ch_type>::length(__s),
2649	__e, __fmt, __flags);
2650	return __result;
2651	}
2652
2653	///@}
2654
2655	_GLIBCXX_BEGIN_NAMESPACE_CXX11
2656
2657	// std [28.12] Class template regex_iterator
2658	/**
2659	* An iterator adaptor that will provide repeated calls of regex_search over
2660	* a range until no more matches remain.
2661	*/
2662	template<typename _Bi_iter,
2663	typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
2664	typename _Rx_traits = regex_traits<_Ch_type> >
2665	class regex_iterator
2666	{
2667	public:
2668	typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
2669	typedef match_results<_Bi_iter> value_type;
2670	typedef std::ptrdiff_t difference_type;
2671	typedef const value_type* pointer;
2672	typedef const value_type& reference;
2673	typedef std::forward_iterator_tag iterator_category;
2674
2675	/**
2676	* @brief Provides a singular iterator, useful for indicating
2677	* one-past-the-end of a range.
2678	*/
2679	regex_iterator() = default;
2680
2681	/**
2682	* Constructs a %regex_iterator...
2683	* @param __a [IN] The start of a text range to search.
2684	* @param __b [IN] One-past-the-end of the text range to search.
2685	* @param __re [IN] The regular expression to match.
2686	* @param __m [IN] Policy flags for match rules.
2687	*/
2688	regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
2689	regex_constants::match_flag_type __m
2690	= regex_constants::match_default)
2691	: _M_begin(__a), _M_end(__b), _M_pregex(&__re), _M_flags(__m), _M_match()
2692	{
2693	if (!regex_search(_M_begin, _M_end, _M_match, *_M_pregex, _M_flags))
2694	*this = regex_iterator();
2695	}
2696
2697	// _GLIBCXX_RESOLVE_LIB_DEFECTS
2698	// 2332. regex_iterator should forbid temporary regexes
2699	regex_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2700	regex_constants::match_flag_type
2701	= regex_constants::match_default) = delete;
2702
2703	/// Copy constructs a %regex_iterator.
2704	regex_iterator(const regex_iterator&) = default;
2705
2706	/// Copy assigns one %regex_iterator to another.
2707	regex_iterator&
2708	operator=(const regex_iterator&) = default;
2709
2710	~regex_iterator() = default;
2711
2712	/**
2713	* @brief Tests the equivalence of two regex iterators.
2714	*/
2715	bool
2716	operator==(const regex_iterator&) const noexcept;
2717
2718	/**
2719	* @brief Tests the inequivalence of two regex iterators.
2720	*/
2721	bool
2722	operator!=(const regex_iterator& __rhs) const noexcept
2723	{ return !(*this == __rhs); }
2724
2725	/**
2726	* @brief Dereferences a %regex_iterator.
2727	*/
2728	const value_type&
2729	operator*() const noexcept
2730	{ return _M_match; }
2731
2732	/**
2733	* @brief Selects a %regex_iterator member.
2734	*/
2735	const value_type*
2736	operator->() const noexcept
2737	{ return &_M_match; }
2738
2739	/**
2740	* @brief Increments a %regex_iterator.
2741	*/
2742	regex_iterator&
2743	operator++();
2744
2745	/**
2746	* @brief Postincrements a %regex_iterator.
2747	*/
2748	regex_iterator
2749	operator++(int)
2750	{
2751	auto __tmp = *this;
2752	++(*this);
2753	return __tmp;
2754	}
2755
2756	private:
2757	_Bi_iter _M_begin {};
2758	_Bi_iter _M_end {};
2759	const regex_type* _M_pregex = nullptr;
2760	regex_constants::match_flag_type _M_flags {};
2761	match_results<_Bi_iter> _M_match;
2762	};
2763
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;
2769	#endif
2770
2771	// [7.12.2] Class template regex_token_iterator
2772	/**
2773	* Iterates over submatches in a range (or @a splits a text string).
2774	*
2775	* The purpose of this iterator is to enumerate all, or all specified,
2776	* matches of a regular expression within a text range. The dereferenced
2777	* value of an iterator of this class is a std::sub_match object.
2778	*/
2779	template<typename _Bi_iter,
2780	typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
2781	typename _Rx_traits = regex_traits<_Ch_type> >
2782	class regex_token_iterator
2783	{
2784	public:
2785	typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
2786	typedef sub_match<_Bi_iter> value_type;
2787	typedef std::ptrdiff_t difference_type;
2788	typedef const value_type* pointer;
2789	typedef const value_type& reference;
2790	typedef std::forward_iterator_tag iterator_category;
2791
2792	public:
2793	/**
2794	* @brief Default constructs a %regex_token_iterator.
2795	*
2796	* A default-constructed %regex_token_iterator is a singular iterator
2797	* that will compare equal to the one-past-the-end value for any
2798	* iterator of the same type.
2799	*/
2800	regex_token_iterator()
2801	: _M_position(), _M_subs(), _M_suffix(), _M_n(0), _M_result(nullptr),
2802	_M_has_m1(false)
2803	{ }
2804
2805	/**
2806	* Constructs a %regex_token_iterator...
2807	* @param __a [IN] The start of the text to search.
2808	* @param __b [IN] One-past-the-end of the text to search.
2809	* @param __re [IN] The regular expression to search for.
2810	* @param __submatch [IN] Which submatch to return. There are some
2811	* special values for this parameter:
2812	* - -1 each enumerated subexpression does NOT
2813	* match the regular expression (aka field
2814	* splitting)
2815	* - 0 the entire string matching the
2816	* subexpression is returned for each match
2817	* within the text.
2818	* - >0 enumerates only the indicated
2819	* subexpression from a match within the text.
2820	* @param __m [IN] Policy flags for match rules.
2821	*/
2822	regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
2823	int __submatch = 0,
2824	regex_constants::match_flag_type __m
2825	= regex_constants::match_default)
2826	: _M_position(__a, __b, __re, __m), _M_subs(1, __submatch), _M_n(0)
2827	{ _M_init(__a, __b); }
2828
2829	/**
2830	* Constructs a %regex_token_iterator...
2831	* @param __a [IN] The start of the text to search.
2832	* @param __b [IN] One-past-the-end of the text to search.
2833	* @param __re [IN] The regular expression to search for.
2834	* @param __submatches [IN] A list of subexpressions to return for each
2835	* regular expression match within the text.
2836	* @param __m [IN] Policy flags for match rules.
2837	*/
2838	regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
2839	const regex_type& __re,
2840	const std::vector<int>& __submatches,
2841	regex_constants::match_flag_type __m
2842	= regex_constants::match_default)
2843	: _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2844	{ _M_init(__a, __b); }
2845
2846	/**
2847	* Constructs a %regex_token_iterator...
2848	* @param __a [IN] The start of the text to search.
2849	* @param __b [IN] One-past-the-end of the text to search.
2850	* @param __re [IN] The regular expression to search for.
2851	* @param __submatches [IN] A list of subexpressions to return for each
2852	* regular expression match within the text.
2853	* @param __m [IN] Policy flags for match rules.
2854	*/
2855	regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
2856	const regex_type& __re,
2857	initializer_list<int> __submatches,
2858	regex_constants::match_flag_type __m
2859	= regex_constants::match_default)
2860	: _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2861	{ _M_init(__a, __b); }
2862
2863	/**
2864	* Constructs a %regex_token_iterator...
2865	* @param __a [IN] The start of the text to search.
2866	* @param __b [IN] One-past-the-end of the text to search.
2867	* @param __re [IN] The regular expression to search for.
2868	* @param __submatches [IN] A list of subexpressions to return for each
2869	* regular expression match within the text.
2870	* @param __m [IN] Policy flags for match rules.
2871	*/
2872	template<std::size_t _Nm>
2873	regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
2874	const regex_type& __re,
2875	const int (&__submatches)[_Nm],
2876	regex_constants::match_flag_type __m
2877	= regex_constants::match_default)
2878	: _M_position(__a, __b, __re, __m),
2879	_M_subs(__submatches, __submatches + _Nm), _M_n(0)
2880	{ _M_init(__a, __b); }
2881
2882	// _GLIBCXX_RESOLVE_LIB_DEFECTS
2883	// 2332. regex_token_iterator should forbid temporary regexes
2884	regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&, int = 0,
2885	regex_constants::match_flag_type =
2886	regex_constants::match_default) = delete;
2887	regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2888	const std::vector<int>&,
2889	regex_constants::match_flag_type =
2890	regex_constants::match_default) = delete;
2891	regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2892	initializer_list<int>,
2893	regex_constants::match_flag_type =
2894	regex_constants::match_default) = delete;
2895	template <std::size_t _Nm>
2896	regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2897	const int (&)[_Nm],
2898	regex_constants::match_flag_type =
2899	regex_constants::match_default) = delete;
2900
2901	/**
2902	* @brief Copy constructs a %regex_token_iterator.
2903	* @param __rhs [IN] A %regex_token_iterator to copy.
2904	*/
2905	regex_token_iterator(const regex_token_iterator& __rhs)
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(); }
2909
2910	/**
2911	* @brief Assigns a %regex_token_iterator to another.
2912	* @param __rhs [IN] A %regex_token_iterator to copy.
2913	*/
2914	regex_token_iterator&
2915	operator=(const regex_token_iterator& __rhs);
2916
2917	/**
2918	* @brief Compares a %regex_token_iterator to another for equality.
2919	*/
2920	bool
2921	operator==(const regex_token_iterator& __rhs) const;
2922
2923	/**
2924	* @brief Compares a %regex_token_iterator to another for inequality.
2925	*/
2926	bool
2927	operator!=(const regex_token_iterator& __rhs) const
2928	{ return !(*this == __rhs); }
2929
2930	/**
2931	* @brief Dereferences a %regex_token_iterator.
2932	*/
2933	const value_type&
2934	operator*() const
2935	{ return *_M_result; }
2936
2937	/**
2938	* @brief Selects a %regex_token_iterator member.
2939	*/
2940	const value_type*
2941	operator->() const
2942	{ return _M_result; }
2943
2944	/**
2945	* @brief Increments a %regex_token_iterator.
2946	*/
2947	regex_token_iterator&
2948	operator++();
2949
2950	/**
2951	* @brief Postincrements a %regex_token_iterator.
2952	*/
2953	regex_token_iterator
2954	operator++(int)
2955	{
2956	auto __tmp = *this;
2957	++(*this);
2958	return __tmp;
2959	}
2960
2961	private:
2962	typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> _Position;
2963
2964	void
2965	_M_init(_Bi_iter __a, _Bi_iter __b);
2966
2967	const value_type&
2968	_M_current_match() const
2969	{
2970	if (_M_subs[_M_n] == -1)
2971	return (*_M_position).prefix();
2972	else
2973	return (*_M_position)[_M_subs[_M_n]];
2974	}
2975
2976	constexpr bool
2977	_M_end_of_seq() const
2978	{ return _M_result == nullptr; }
2979
2980	// [28.12.2.2.4]
2981	void
2982	_M_normalize_result()
2983	{
2984	if (_M_position != _Position())
2985	_M_result = &_M_current_match();
2986	else if (_M_has_m1)
2987	_M_result = &_M_suffix;
2988	else
2989	_M_result = nullptr;
2990	}
2991
2992	_Position _M_position;
2993	std::vector<int> _M_subs;
2994	value_type _M_suffix;
2995	std::size_t _M_n;
2996	const value_type* _M_result;
2997
2998	// Show whether _M_subs contains -1
2999	bool _M_has_m1;
3000	};
3001
3002	/** @brief Token iterator for C-style NULL-terminated strings. */
3003	typedef regex_token_iterator<const char*> cregex_token_iterator;
3004
3005	/** @brief Token iterator for standard strings. */
3006	typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
3007
3008	#ifdef _GLIBCXX_USE_WCHAR_T
3009	/** @brief Token iterator for C-style NULL-terminated wide strings. */
3010	typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
3011
3012	/** @brief Token iterator for standard wide-character strings. */
3013	typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
3014	#endif
3015
3016	///@} // group regex
3017
3018	_GLIBCXX_END_NAMESPACE_CXX11
3019	_GLIBCXX_END_NAMESPACE_VERSION
3020	} // namespace
3021
3022	#include <bits/regex.tcc>
3023