libstdc++
regex.h
Go to the documentation of this file.
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 
38 namespace 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 
50 namespace __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,
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>
100  {
101  public:
102  typedef _Ch_type char_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  */
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
401  {
402  std::swap(_M_locale, __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>>
441  {
442  public:
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;
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(__p, __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(__p, __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(__s.data(), __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  */
573  { _M_compile(__l.begin(), __l.end(), __f); }
574 
575  /**
576  * @brief Destroys a basic regular expression.
577  */
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&
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&
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(__p, __p + _Rx_traits::length(__p), __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(__p, __p + __len, __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&
702  flag_type __flags = ECMAScript)
703  {
704  _M_compile(__s.data(), __s.data() + __s.size(), __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, __flags);
734  else // __normal_iterator<_T*, C>
735  _M_compile(__first.base(), __last.base(), __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(__l.begin(), __l.end(), __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(_M_flags, __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:
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>&,
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>
855 
856  template<typename _Ch, typename _Tr>
859 
860  template<typename _Ch, typename _Tr>
863 
864  template<typename _Ch, typename _Tr>
867 
868  template<typename _Ch, typename _Tr>
871 
872  template<typename _Ch, typename _Tr>
875 
876  template<typename _Ch, typename _Tr>
879 
880  template<typename _Ch, typename _Tr>
883 
884  template<typename _Ch, typename _Tr>
887 
888  template<typename _Ch, typename _Tr>
891 #endif // ! C++17
892 
893 #if __cpp_deduction_guides >= 201606
894  template<typename _ForwardIterator>
895  basic_regex(_ForwardIterator, _ForwardIterator,
897  -> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>;
898 #endif
899 
900  /** @brief Standard regular expressions. */
902 
903 #ifdef _GLIBCXX_USE_WCHAR_T
904  /** @brief Standard wide-character regular expressions. */
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
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  {
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;
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(matched, __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(_M_len, __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. */
1101 
1102  /** @brief Standard regex submatch over a standard string. */
1104 
1105 #ifdef _GLIBCXX_USE_WCHAR_T
1106  /** @brief Regex submatch over a C-style null-terminated wide string. */
1108 
1109  /** @brief Regex submatch over a standard wide string. */
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
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  {
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
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
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  {
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
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  {
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> > >
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  */
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;
1795 
1796  public:
1797  /**
1798  * @name 28.10 Public Types
1799  */
1800  ///@{
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;
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,
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,
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>
2077  {
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,
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>&,
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
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
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,
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,
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,
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
2360  match_results<typename basic_string<_Ch_type,
2361  _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
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
2374  match_results<typename basic_string<_Ch_type,
2375  _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
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,
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
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,
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,
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,
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,
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,
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
2548  match_results<typename basic_string<_Ch_type,
2549  _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
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
2563  match_results<typename basic_string<_Ch_type,
2564  _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
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,
2577  const _Ch_type* __fmt, size_t __len,
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,
2600  const basic_string<_Ch_type, _St, _Sa>& __fmt,
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,
2626  const _Ch_type* __fmt,
2629  {
2630  return std::__regex_replace(__out, __first, __last, __e, __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>
2655  {
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>
2678  const _Ch_type* __fmt,
2681  {
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,
2704  const basic_string<_Ch_type, _St, _Sa>& __fmt,
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,
2730  const _Ch_type* __fmt,
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> >
2757  {
2758  public:
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;
2765 #if __cplusplus > 201703L
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,
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&&,
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.
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  */
2846  operator++();
2847 
2848  /**
2849  * @brief Postincrements a %regex_iterator.
2850  */
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;
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> >
2889  {
2890  public:
2893  typedef std::ptrdiff_t difference_type;
2894  typedef const value_type* pointer;
2895  typedef const value_type& reference;
2897 #if __cplusplus > 201703L
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  */
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,
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,
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,
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],
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,
2996  regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2997  const std::vector<int>&,
3000  regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
3004  template <std::size_t _Nm>
3005  regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
3006  const int (&)[_Nm],
3009 
3010  /**
3011  * @brief Copy constructs a %regex_token_iterator.
3012  * @param __rhs [IN] A %regex_token_iterator to copy.
3013  */
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  */
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  */
3066  operator++();
3067 
3068  /**
3069  * @brief Postincrements a %regex_token_iterator.
3070  */
3073  {
3074  auto __tmp = *this;
3075  ++(*this);
3076  return __tmp;
3077  }
3078 
3079  private:
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. */
3122 
3123  /** @brief Token iterator for standard strings. */
3125 
3126 #ifdef _GLIBCXX_USE_WCHAR_T
3127  /** @brief Token iterator for C-style NULL-terminated wide strings. */
3129 
3130  /** @brief Token iterator for standard wide-character strings. */
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>
constexpr bool operator<=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
Definition: chrono.h:859
constexpr bool operator>=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
Definition: chrono.h:873
constexpr bool operator<(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
Definition: chrono.h:826
constexpr bool operator>(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
Definition: chrono.h:866
__bool_constant< true > true_type
The type used as a compile-time boolean with true value.
Definition: type_traits:116
__bool_constant< false > false_type
The type used as a compile-time boolean with false value.
Definition: type_traits:119
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Definition: move.h:52
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition: move.h:138
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:234
const _Facet & use_facet(const locale &__loc)
Return a facet.
sub_match< wstring::const_iterator > wssub_match
Regex submatch over a standard wide string.
Definition: regex.h:1110
sub_match< string::const_iterator > ssub_match
Standard regex submatch over a standard string.
Definition: regex.h:1103
sub_match< const char * > csub_match
Standard regex submatch over a C-style null-terminated string.
Definition: regex.h:1100
regex_token_iterator< const char * > cregex_token_iterator
Token iterator for C-style NULL-terminated strings.
Definition: regex.h:3121
bool operator==(const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)
Tests the equivalence of a regular expression submatch and a string.
Definition: regex.h:1296
regex_token_iterator< wstring::const_iterator > wsregex_token_iterator
Token iterator for standard wide-character strings.
Definition: regex.h:3131
bool operator==(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)
Tests the equivalence of a regular expression submatch and a character.
Definition: regex.h:1635
bool operator==(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)
Tests the equivalence of a regular expression submatch and a C string.
Definition: regex.h:1463
regex_token_iterator< const wchar_t * > wcregex_token_iterator
Token iterator for C-style NULL-terminated wide strings.
Definition: regex.h:3128
void swap(basic_regex< _Ch_type, _Rx_traits > &__lhs, basic_regex< _Ch_type, _Rx_traits > &__rhs) noexcept
Swaps the contents of two regular expression objects.
Definition: regex.h:918
basic_regex< char > regex
Standard regular expressions.
Definition: regex.h:901
_Out_iter regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, const basic_regex< _Ch_type, _Rx_traits > &__e, const basic_string< _Ch_type, _St, _Sa > &__fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)
Search for a regular expression within a range for multiple times, and replace the matched parts thro...
Definition: regex.h:2598
sub_match< const wchar_t * > wcsub_match
Regex submatch over a C-style null-terminated wide string.
Definition: regex.h:1107
regex_token_iterator< string::const_iterator > sregex_token_iterator
Token iterator for standard strings.
Definition: regex.h:3124
bool regex_match(_Bi_iter __s, _Bi_iter __e, match_results< _Bi_iter, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)
Determines if there is a match between the regular expression e and all of the character sequence [fi...
Definition: regex.h:2283
bool operator==(const match_results< _Bi_iter, _Alloc > &__m1, const match_results< _Bi_iter, _Alloc > &__m2)
Compares two match_results for equality.
Definition: regex.h:2208
bool regex_search(_Bi_iter __s, _Bi_iter __e, match_results< _Bi_iter, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)
Definition: regex.h:2440
void swap(match_results< _Bi_iter, _Alloc > &__lhs, match_results< _Bi_iter, _Alloc > &__rhs) noexcept
Swaps two match results.
Definition: regex.h:2252
basic_regex< wchar_t > wregex
Standard wide-character regular expressions.
Definition: regex.h:905
bool operator==(const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)
Tests the equivalence of two regular expression submatches.
Definition: regex.h:1125
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
ISO C++ entities toplevel namespace is std.
constexpr bitset< _Nb > operator&(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition: bitset:1562
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition: bitset:1692
constexpr bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition: bitset:1572
constexpr bitset< _Nb > operator^(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition: bitset:1582
GNU extensions for public use.
__numeric_traits_integer< _Tp > __int_traits
Convenience alias for __numeric_traits<integer-type>.
constexpr _Iterator __base(_Iterator __it)
constexpr syntax_option_type collate
constexpr syntax_option_type ECMAScript
constexpr syntax_option_type egrep
syntax_option_type
This is a bitmask type indicating how to interpret the regex.
constexpr syntax_option_type multiline
constexpr match_flag_type match_default
constexpr syntax_option_type awk
constexpr syntax_option_type extended
constexpr syntax_option_type basic
match_flag_type
This is a bitmask type indicating regex matching rules.
constexpr syntax_option_type icase
constexpr syntax_option_type optimize
constexpr match_flag_type format_default
constexpr syntax_option_type nosubs
constexpr syntax_option_type grep
initializer_list
is_same
Definition: type_traits:1540
typename _Size< _Alloc, difference_type >::type size_type
The allocator's size type.
Basis for explicit traits specializations.
Definition: char_traits.h:326
Managing sequences of characters and character-like objects.
Definition: cow_string.h:109
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
Definition: cow_string.h:2376
size_type length() const noexcept
Returns the number of characters in the string, not including any null-termination.
Definition: cow_string.h:967
size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
Definition: cow_string.h:955
const _CharT * data() const noexcept
Return const pointer to contents.
Definition: cow_string.h:2388
iterator begin()
Definition: cow_string.h:844
iterator end()
Definition: cow_string.h:863
Base class for all library exceptions.
Definition: exception.h:62
Container class for localization functionality.
Facet for localized string comparison.
Primary class template ctype facet.
A regular expression.
Definition: regex.h:441
locale_type getloc() const noexcept
Gets the locale currently imbued in the regular expression object.
Definition: regex.h:801
basic_regex & assign(const basic_string< _Ch_type, _Ch_traits, _Alloc > &__s, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object from a string containing a regular expression patt...
Definition: regex.h:701
basic_regex & assign(basic_regex &&__rhs) noexcept
Move-assigns one regular expression to another.
Definition: regex.h:643
unsigned int mark_count() const noexcept
Gets the number of marked subexpressions within the regular expression.
Definition: regex.h:767
basic_regex & assign(initializer_list< _Ch_type > __l, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object.
Definition: regex.h:755
locale_type imbue(locale_type __loc)
Imbues the regular expression object with the given locale.
Definition: regex.h:789
basic_regex(const basic_regex &__rhs)=default
Copy-constructs a basic regular expression.
flag_type flags() const noexcept
Gets the flags used to construct the regular expression or in the last call to assign().
Definition: regex.h:779
basic_regex & operator=(const basic_string< _Ch_type, _Ch_traits, _Alloc > &__s)
Replaces a regular expression with a new one constructed from a string.
Definition: regex.h:624
basic_regex(const _Ch_type *__p, flag_type __f=ECMAScript)
Constructs a basic regular expression from the sequence [__p, __p + char_traits<_Ch_type>::length(__p...
Definition: regex.h:494
void swap(basic_regex &__rhs) noexcept
Swaps the contents of two regular expression objects.
Definition: regex.h:811
basic_regex(const std::basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &__s, flag_type __f=ECMAScript)
Constructs a basic regular expression from the string s interpreted according to the flags in f.
Definition: regex.h:541
basic_regex & operator=(const _Ch_type *__p)
Replaces a regular expression with a new one constructed from a C-style null-terminated string.
Definition: regex.h:601
basic_regex & operator=(const basic_regex &)=default
Assigns one regular expression to another.
basic_regex(_FwdIter __first, _FwdIter __last, flag_type __f=ECMAScript)
Constructs a basic regular expression from the range [first, last) interpreted according to the flags...
Definition: regex.h:560
basic_regex & assign(const basic_regex &__rhs) noexcept
Assigns one regular expression to another.
Definition: regex.h:634
basic_regex & assign(const _Ch_type *__p, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object from a C-style null-terminated string containing a...
Definition: regex.h:660
basic_regex(const _Ch_type *__p, std::size_t __len, flag_type __f=ECMAScript)
Constructs a basic regular expression from the sequence [p, p + len) interpreted according to the fla...
Definition: regex.h:509
basic_regex & assign(_InputIterator __first, _InputIterator __last, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object.
Definition: regex.h:723
basic_regex & operator=(basic_regex &&)=default
Move-assigns one regular expression to another.
basic_regex & assign(const _Ch_type *__p, size_t __len, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object from a C-style string containing a regular express...
Definition: regex.h:682
basic_regex(basic_regex &&__rhs) noexcept=default
Move-constructs a basic regular expression.
basic_regex(initializer_list< _Ch_type > __l, flag_type __f=ECMAScript)
Constructs a basic regular expression from an initializer list.
Definition: regex.h:572
basic_regex() noexcept
Definition: regex.h:478
basic_regex & operator=(initializer_list< _Ch_type > __l)
Replaces a regular expression with a new one constructed from an initializer list.
Definition: regex.h:613
~basic_regex()
Destroys a basic regular expression.
Definition: regex.h:578
The results of a match or search operation.
Definition: regex.h:1772
allocator_type get_allocator() const noexcept
Gets a copy of the allocator.
Definition: regex.h:2109
void swap(match_results &__that) noexcept
Swaps the contents of two match_results.
Definition: regex.h:2123
difference_type position(size_type __sub=0) const
Gets the offset of the beginning of the indicated submatch.
Definition: regex.h:1943
size_type size() const noexcept
Gets the number of matches and submatches.
Definition: regex.h:1896
_Out_iter format(_Out_iter __out, const char_type *__fmt_first, const char_type *__fmt_last, match_flag_type __flags=regex_constants::format_default) const
difference_type length(size_type __sub=0) const
Gets the length of the indicated submatch.
Definition: regex.h:1928
const_reference prefix() const
Gets a sub_match representing the match prefix.
Definition: regex.h:1988
match_results(match_results &&__m, const _Alloc &__a) noexcept(noexcept(_Base_type(std::move(__m), __a)))
Constructs a default match_results container.
Definition: regex.h:1867
size_type max_size() const noexcept
Gets the number of matches and submatches.
Definition: regex.h:1900
const_reference operator[](size_type __sub) const
Gets a sub_match reference for the match or submatch.
Definition: regex.h:1971
match_results(match_results &&) noexcept=default
Move constructs a match_results.
basic_string< char_type, _St, _Sa > format(const basic_string< char_type, _St, _Sa > &__fmt, match_flag_type __flags=regex_constants::format_default) const
Definition: regex.h:2075
match_results(const _Alloc &__a) noexcept
Constructs a default match_results container.
Definition: regex.h:1830
match_results(const match_results &)=default
Copy constructs a match_results.
_Out_iter format(_Out_iter __out, const basic_string< char_type, _St, _Sa > &__fmt, match_flag_type __flags=regex_constants::format_default) const
Definition: regex.h:2063
const_iterator cbegin() const noexcept
Gets an iterator to the start of the sub_match collection.
Definition: regex.h:2020
string_type str(size_type __sub=0) const
Gets the match or submatch converted to a string type.
Definition: regex.h:1956
const_iterator end() const noexcept
Gets an iterator to one-past-the-end of the collection.
Definition: regex.h:2027
const_reference suffix() const
Gets a sub_match representing the match suffix.
Definition: regex.h:2003
bool ready() const noexcept
Indicates if the match_results is ready.
Definition: regex.h:1879
bool empty() const noexcept
Indicates if the match_results contains no results.
Definition: regex.h:1909
string_type format(const char_type *__fmt, match_flag_type __flags=regex_constants::format_default) const
Definition: regex.h:2087
match_results()
Constructs a default match_results container.
Definition: regex.h:1823
const_iterator cend() const noexcept
Gets an iterator to one-past-the-end of the collection.
Definition: regex.h:2034
const_iterator begin() const noexcept
Gets an iterator to the start of the sub_match collection.
Definition: regex.h:2013
Takes a regex and an input string and does the matching.
Describes aspects of a regular expression.
Definition: regex.h:100
char_type translate(char_type __c) const
Performs the identity translation.
Definition: regex.h:203
static std::size_t length(const char_type *__p)
Gives the length of a C-style string starting at __p.
Definition: regex.h:192
string_type transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
Gets a sort key for a character sequence, independent of case.
Definition: regex.h:269
regex_traits()
Constructs a default traits object.
Definition: regex.h:179
int value(_Ch_type __ch, int __radix) const
Converts a digit to an int.
Definition: regex.tcc:337
char_type translate_nocase(char_type __c) const
Translates a character into a case-insensitive equivalent.
Definition: regex.h:216
string_type lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
Gets a collation element by name.
Definition: regex.tcc:123
locale_type getloc() const
Gets a copy of the current locale in use by the regex_traits object.
Definition: regex.h:411
bool isctype(_Ch_type __c, char_class_type __f) const
Determines if c is a member of an identified class.
Definition: regex.tcc:323
locale_type imbue(locale_type __loc)
Imbues the regex_traits object with a copy of a new locale.
Definition: regex.h:400
char_class_type lookup_classname(_Fwd_iter __first, _Fwd_iter __last, bool __icase=false) const
Maps one or more characters to a named character classification.
Definition: regex.tcc:279
string_type transform(_Fwd_iter __first, _Fwd_iter __last) const
Gets a sort key for a character sequence.
Definition: regex.h:245
difference_type length() const noexcept
Gets the length of the matching sequence.
Definition: regex.h:963
void swap(sub_match &__s) noexcept(__is_nothrow_swappable< _BiIter >::value)
Swap the values of two sub_match objects.
Definition: regex.h:1035
int compare(const value_type *__s) const
Compares this sub_match to a string.
Definition: regex.h:1020
string_type str() const
Gets the matching sequence as a string.
Definition: regex.h:985
int compare(const sub_match &__s) const
Compares this and another matched sequence.
Definition: regex.h:1002
int compare(const string_type &__s) const
Compares this sub_match to a string.
Definition: regex.h:1016
regex_iterator operator++(int)
Postincrements a regex_iterator.
Definition: regex.h:2852
regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, regex_constants::match_flag_type __m=regex_constants::match_default)
Definition: regex.h:2782
regex_iterator(const regex_iterator &)=default
Copy constructs a regex_iterator.
regex_iterator()=default
Provides a singular iterator, useful for indicating one-past-the-end of a range.
regex_iterator & operator=(const regex_iterator &)=default
Copy assigns one regex_iterator to another.
const value_type & operator*() const noexcept
Dereferences a regex_iterator.
Definition: regex.h:2832
const value_type * operator->() const noexcept
Selects a regex_iterator member.
Definition: regex.h:2839
bool operator==(const regex_iterator &) const noexcept
Tests the equivalence of two regex iterators.
Definition: regex.tcc:499
regex_iterator & operator++()
Increments a regex_iterator.
Definition: regex.tcc:515
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, const int(&__submatches)[_Nm], regex_constants::match_flag_type __m=regex_constants::match_default)
Definition: regex.h:2982
bool operator==(const regex_token_iterator &__rhs) const
Compares a regex_token_iterator to another for equality.
Definition: regex.tcc:590
const value_type & operator*() const
Dereferences a regex_token_iterator.
Definition: regex.h:3052
regex_token_iterator(const regex_token_iterator &__rhs)
Copy constructs a regex_token_iterator.
Definition: regex.h:3014
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, const std::vector< int > &__submatches, regex_constants::match_flag_type __m=regex_constants::match_default)
Definition: regex.h:2947
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, initializer_list< int > __submatches, regex_constants::match_flag_type __m=regex_constants::match_default)
Definition: regex.h:2964
regex_token_iterator operator++(int)
Postincrements a regex_token_iterator.
Definition: regex.h:3072
regex_token_iterator & operator=(const regex_token_iterator &__rhs)
Assigns a regex_token_iterator to another.
Definition: regex.tcc:574
regex_token_iterator & operator++()
Increments a regex_token_iterator.
Definition: regex.tcc:610
regex_token_iterator()
Default constructs a regex_token_iterator.
Definition: regex.h:2909
const value_type * operator->() const
Selects a regex_token_iterator member.
Definition: regex.h:3059
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, int __submatch=0, regex_constants::match_flag_type __m=regex_constants::match_default)
Definition: regex.h:2931
A smart pointer with reference-counted copy semantics.
Struct holding two objects of arbitrary type.
Definition: stl_pair.h:304
constexpr void swap(pair &__p) noexcept(__and_< __is_nothrow_swappable< _T1 >, __is_nothrow_swappable< _T2 >>::value)
Swap the first members and then the second members.
Definition: stl_pair.h:321
Marking input iterators.
Forward iterators support a superset of input iterator operations.
Traits class for iterators.
A standard container which offers fixed time access to individual elements in any order.
Definition: stl_vector.h:459
constexpr iterator end() noexcept
Definition: stl_vector.h:1018
constexpr iterator begin() noexcept
Definition: stl_vector.h:998
constexpr void assign(size_type __n, const value_type &__val)
Assigns a given value to a vector.
Definition: stl_vector.h:875
constexpr void swap(vector &__x) noexcept
Swaps data with another vector.
Definition: stl_vector.h:1844
constexpr bool empty() const noexcept
Definition: stl_vector.h:1223
constexpr allocator_type get_allocator() const noexcept
Get a copy of the memory allocation object.
Definition: stl_vector.h:317
constexpr size_type size() const noexcept
Definition: stl_vector.h:1117
constexpr reference operator[](size_type __n) noexcept
Subscript access to the data contained in the vector.
Definition: stl_vector.h:1261
constexpr size_type max_size() const noexcept
Definition: stl_vector.h:1128