Files
BayesNet/html/usr/include/c++/13/bits/regex.h.gcov.html

353 KiB

<html lang="en"> <head> </head>
LCOV - code coverage report
Current view: top level - /usr/include/c++/13/bits - regex.h (source / functions) Coverage Total Hit
Test: coverage.info Lines: 0.0 % 137 0
Test Date: 2024-04-30 13:17:26 Functions: 0.0 % 53 0

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

Generated by: LCOV version 2.0-1

</html>