Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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