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