Clang Project

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