Subversion Repositories Kolibri OS

// class template regex -*- C++ -*-

// Copyright (C) 2010-2015 Free Software Foundation, Inc.

//

// This file is part of the GNU ISO C++ Library.  This library is free

// software; you can redistribute it and/or modify it under the

// terms of the GNU General Public License as published by the

// Free Software Foundation; either version 3, or (at your option)

// any later version.

// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional

// permissions described in the GCC Runtime Library Exception, version

// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and

// a copy of the GCC Runtime Library Exception along with this program;

// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

// .

/**

 *  @file bits/regex.h

 *  This is an internal header file, included by other library headers.

 *  Do not attempt to use it directly. @headername{regex}

 */

namespace std _GLIBCXX_VISIBILITY(default)

{

_GLIBCXX_BEGIN_NAMESPACE_VERSION

_GLIBCXX_BEGIN_NAMESPACE_CXX11

  template

    class basic_regex;

  template

    class match_results;

_GLIBCXX_END_NAMESPACE_CXX11

_GLIBCXX_END_NAMESPACE_VERSION

namespace __detail

{

_GLIBCXX_BEGIN_NAMESPACE_VERSION

  enum class _RegexExecutorPolicy : int

    { _S_auto, _S_alternate };

  template

	   typename _CharT, typename _TraitsT,

	   _RegexExecutorPolicy __policy,

	   bool __match_mode>

    bool

    __regex_algo_impl(_BiIter                              __s,

		      _BiIter                              __e,

		      match_results<_BiIter, _Alloc>&      __m,

		      const basic_regex<_CharT, _TraitsT>& __re,

		      regex_constants::match_flag_type     __flags);

  template

    class _Executor;

_GLIBCXX_END_NAMESPACE_VERSION

}

_GLIBCXX_BEGIN_NAMESPACE_VERSION

_GLIBCXX_BEGIN_NAMESPACE_CXX11

  /**

   * @addtogroup regex

   * @{

   */

  /**

   * @brief Describes aspects of a regular expression.

   *

   * A regular expression traits class that satisfies the requirements of

   * section [28.7].

   *

   * The class %regex is parameterized around a set of related types and

   * functions used to complete the definition of its semantics.  This class

   * satisfies the requirements of such a traits class.

   */

  template

    struct regex_traits

    {

    public:

      typedef _Ch_type                     	char_type;

      typedef std::basic_string 	string_type;

      typedef std::locale                  	locale_type;

    private:

      struct _RegexMask

	{

	  typedef std::ctype_base::mask _BaseType;

	  _BaseType _M_base;

	  unsigned char _M_extended;

	  static constexpr unsigned char _S_under = 1 << 0;

	  static constexpr unsigned char _S_valid_mask = 0x1;

	  constexpr _RegexMask(_BaseType __base = 0,

			       unsigned char __extended = 0)

	  : _M_base(__base), _M_extended(__extended)

	  { }

	  constexpr _RegexMask

	  operator&(_RegexMask __other) const

	  {

	    return _RegexMask(_M_base & __other._M_base,

			      _M_extended & __other._M_extended);

	  }

	  constexpr _RegexMask

	  operator|(_RegexMask __other) const

	  {

	    return _RegexMask(_M_base | __other._M_base,

			      _M_extended | __other._M_extended);

	  }

	  constexpr _RegexMask

	  operator^(_RegexMask __other) const

	  {

	    return _RegexMask(_M_base ^ __other._M_base,

			      _M_extended ^ __other._M_extended);

	  }

	  constexpr _RegexMask

	  operator~() const

	  { return _RegexMask(~_M_base, ~_M_extended); }

	  _RegexMask&

	  operator&=(_RegexMask __other)

	  { return *this = (*this) & __other; }

	  _RegexMask&

	  operator|=(_RegexMask __other)

	  { return *this = (*this) | __other; }

	  _RegexMask&

	  operator^=(_RegexMask __other)

	  { return *this = (*this) ^ __other; }

	  constexpr bool

	  operator==(_RegexMask __other) const

	  {

	    return (_M_extended & _S_valid_mask)

		   == (__other._M_extended & _S_valid_mask)

		     && _M_base == __other._M_base;

	  }

	  constexpr bool

	  operator!=(_RegexMask __other) const

	  { return !((*this) == __other); }

	};

    public:

      typedef _RegexMask char_class_type;

    public:

      /**

       * @brief Constructs a default traits object.

       */

      regex_traits() { }

      /**

       * @brief Gives the length of a C-style string starting at @p __p.

       *

       * @param __p a pointer to the start of a character sequence.

       *

       * @returns the number of characters between @p *__p and the first

       * default-initialized value of type @p char_type.  In other words, uses

       * the C-string algorithm for determining the length of a sequence of

       * characters.

       */

      static std::size_t

      length(const char_type* __p)

      { return string_type::traits_type::length(__p); }

      /**

       * @brief Performs the identity translation.

       *

       * @param __c A character to the locale-specific character set.

       *

       * @returns __c.

       */

      char_type

      translate(char_type __c) const

      { return __c; }

      /**

       * @brief Translates a character into a case-insensitive equivalent.

       *

       * @param __c A character to the locale-specific character set.

       *

       * @returns the locale-specific lower-case equivalent of __c.

       * @throws std::bad_cast if the imbued locale does not support the ctype

       *         facet.

       */

      char_type

      translate_nocase(char_type __c) const

      {

	typedef std::ctype __ctype_type;

	const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));

	return __fctyp.tolower(__c);

      }

      /**

       * @brief Gets a sort key for a character sequence.

       *

       * @param __first beginning of the character sequence.

       * @param __last  one-past-the-end of the character sequence.

       *

       * Returns a sort key for the character sequence designated by the

       * iterator range [F1, F2) such that if the character sequence [G1, G2)

       * sorts before the character sequence [H1, H2) then

       * v.transform(G1, G2) < v.transform(H1, H2).

       *

       * What this really does is provide a more efficient way to compare a

       * string to multiple other strings in locales with fancy collation

       * rules and equivalence classes.

       *

       * @returns a locale-specific sort key equivalent to the input range.

       *

       * @throws std::bad_cast if the current locale does not have a collate

       *         facet.

       */

      template

	string_type

	transform(_Fwd_iter __first, _Fwd_iter __last) const

	{

	  typedef std::collate __collate_type;

	  const __collate_type& __fclt(use_facet<__collate_type>(_M_locale));

	  string_type __s(__first, __last);

	  return __fclt.transform(__s.data(), __s.data() + __s.size());

	}

      /**

       * @brief Gets a sort key for a character sequence, independent of case.

       *

       * @param __first beginning of the character sequence.

       * @param __last  one-past-the-end of the character sequence.

       *

       * Effects: if typeid(use_facet >) ==

       * typeid(collate_byname<_Ch_type>) and the form of the sort key

       * returned by collate_byname<_Ch_type>::transform(__first, __last)

       * is known and can be converted into a primary sort key

       * then returns that key, otherwise returns an empty string.

       *

       * @todo Implement this function correctly.

       */

      template

	string_type

	transform_primary(_Fwd_iter __first, _Fwd_iter __last) const

	{

	  // TODO : this is not entirely correct.

	  // This function requires extra support from the platform.

	  //

	  // Read http://gcc.gnu.org/ml/libstdc++/2013-09/msg00117.html and

	  // http://www.open-std.org/Jtc1/sc22/wg21/docs/papers/2003/n1429.htm

	  // for details.

	  typedef std::ctype __ctype_type;

	  const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));

	  std::vector __s(__first, __last);

	  __fctyp.tolower(__s.data(), __s.data() + __s.size());

	  return this->transform(__s.data(), __s.data() + __s.size());

	}

      /**

       * @brief Gets a collation element by name.

       *

       * @param __first beginning of the collation element name.

       * @param __last  one-past-the-end of the collation element name.

       *

       * @returns a sequence of one or more characters that represents the

       * collating element consisting of the character sequence designated by

       * the iterator range [__first, __last). Returns an empty string if the

       * character sequence is not a valid collating element.

       */

      template

	string_type

	lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const;

      /**

       * @brief Maps one or more characters to a named character

       *        classification.

       *

       * @param __first beginning of the character sequence.

       * @param __last  one-past-the-end of the character sequence.

       * @param __icase ignores the case of the classification name.

       *

       * @returns an unspecified value that represents the character

       * classification named by the character sequence designated by

       * the iterator range [__first, __last). If @p icase is true,

       * the returned mask identifies the classification regardless of

       * the case of the characters to be matched (for example,

       * [[:lower:]] is the same as [[:alpha:]]), otherwise a

       * case-dependent classification is returned.  The value

       * returned shall be independent of the case of the characters

       * in the character sequence. If the name is not recognized then

       * returns a value that compares equal to 0.

       *

       * At least the following names (or their wide-character equivalent) are

       * supported.

       * - d

       * - w

       * - s

       * - alnum

       * - alpha

       * - blank

       * - cntrl

       * - digit

       * - graph

       * - lower

       * - print

       * - punct

       * - space

       * - upper

       * - xdigit

       */

      template

	char_class_type

	lookup_classname(_Fwd_iter __first, _Fwd_iter __last,

			 bool __icase = false) const;

      /**

       * @brief Determines if @p c is a member of an identified class.

       *

       * @param __c a character.

       * @param __f a class type (as returned from lookup_classname).

       *

       * @returns true if the character @p __c is a member of the classification

       * represented by @p __f, false otherwise.

       *

       * @throws std::bad_cast if the current locale does not have a ctype

       *         facet.

       */

      bool

      isctype(_Ch_type __c, char_class_type __f) const;

      /**

       * @brief Converts a digit to an int.

       *

       * @param __ch    a character representing a digit.

       * @param __radix the radix if the numeric conversion (limited to 8, 10,

       *              or 16).

       *

       * @returns the value represented by the digit __ch in base radix if the

       * character __ch is a valid digit in base radix; otherwise returns -1.

       */

      int

      value(_Ch_type __ch, int __radix) const;

      /**

       * @brief Imbues the regex_traits object with a copy of a new locale.

       *

       * @param __loc A locale.

       *

       * @returns a copy of the previous locale in use by the regex_traits

       *          object.

       *

       * @note Calling imbue with a different locale than the one currently in

       *       use invalidates all cached data held by *this.

       */

      locale_type

      imbue(locale_type __loc)

      {

	std::swap(_M_locale, __loc);

	return __loc;

      }

      /**

       * @brief Gets a copy of the current locale in use by the regex_traits

       * object.

       */

      locale_type

      getloc() const

      { return _M_locale; }

    protected:

      locale_type _M_locale;

    };

  // [7.8] Class basic_regex

  /**

   * Objects of specializations of this class represent regular expressions

   * constructed from sequences of character type @p _Ch_type.

   *

   * Storage for the regular expression is allocated and deallocated as

   * necessary by the member functions of this class.

   */

  template>

    class basic_regex

    {

    public:

      static_assert(is_same<_Ch_type, typename _Rx_traits::char_type>::value,

		    "regex traits class must have the same char_type");

      // types:

      typedef _Ch_type                            value_type;

      typedef _Rx_traits                          traits_type;

      typedef typename traits_type::string_type   string_type;

      typedef regex_constants::syntax_option_type flag_type;

      typedef typename traits_type::locale_type   locale_type;

      /**

       * @name Constants

       * std [28.8.1](1)

       */

      //@{

      static constexpr flag_type icase = regex_constants::icase;

      static constexpr flag_type nosubs = regex_constants::nosubs;

      static constexpr flag_type optimize = regex_constants::optimize;

      static constexpr flag_type collate = regex_constants::collate;

      static constexpr flag_type ECMAScript = regex_constants::ECMAScript;

      static constexpr flag_type basic = regex_constants::basic;

      static constexpr flag_type extended = regex_constants::extended;

      static constexpr flag_type awk = regex_constants::awk;

      static constexpr flag_type grep = regex_constants::grep;

      static constexpr flag_type egrep = regex_constants::egrep;

      //@}

      // [7.8.2] construct/copy/destroy

      /**

       * Constructs a basic regular expression that does not match any

       * character sequence.

       */

      basic_regex()

      : _M_flags(ECMAScript), _M_loc(), _M_automaton(nullptr)

      { }

      /**

       * @brief Constructs a basic regular expression from the

       * sequence [__p, __p + char_traits<_Ch_type>::length(__p))

       * interpreted according to the flags in @p __f.

       *

       * @param __p A pointer to the start of a C-style null-terminated string

       *          containing a regular expression.

       * @param __f Flags indicating the syntax rules and options.

       *

       * @throws regex_error if @p __p is not a valid regular expression.

       */

      explicit

      basic_regex(const _Ch_type* __p, flag_type __f = ECMAScript)

      : basic_regex(__p, __p + char_traits<_Ch_type>::length(__p), __f)

      { }

      /**

       * @brief Constructs a basic regular expression from the sequence

       * [p, p + len) interpreted according to the flags in @p f.

       *

       * @param __p   A pointer to the start of a string containing a regular

       *              expression.

       * @param __len The length of the string containing the regular

       *              expression.

       * @param __f   Flags indicating the syntax rules and options.

       *

       * @throws regex_error if @p __p is not a valid regular expression.

       */

      basic_regex(const _Ch_type* __p, std::size_t __len,

		  flag_type __f = ECMAScript)

      : basic_regex(__p, __p + __len, __f)

      { }

      /**

       * @brief Copy-constructs a basic regular expression.

       *

       * @param __rhs A @p regex object.

       */

      basic_regex(const basic_regex& __rhs) = default;

      /**

       * @brief Move-constructs a basic regular expression.

       *

       * @param __rhs A @p regex object.

       */

      basic_regex(basic_regex&& __rhs) noexcept = default;

      /**

       * @brief Constructs a basic regular expression from the string

       * @p s interpreted according to the flags in @p f.

       *

       * @param __s A string containing a regular expression.

       * @param __f Flags indicating the syntax rules and options.

       *

       * @throws regex_error if @p __s is not a valid regular expression.

       */

      template

	explicit

	basic_regex(const std::basic_string<_Ch_type, _Ch_traits,

					    _Ch_alloc>& __s,

		    flag_type __f = ECMAScript)

	: basic_regex(__s.data(), __s.data() + __s.size(), __f)

	{ }

      /**

       * @brief Constructs a basic regular expression from the range

       * [first, last) interpreted according to the flags in @p f.

       *

       * @param __first The start of a range containing a valid regular

       *                expression.

       * @param __last  The end of a range containing a valid regular

       *                expression.

       * @param __f     The format flags of the regular expression.

       *

       * @throws regex_error if @p [__first, __last) is not a valid regular

       *         expression.

       */

      template

	basic_regex(_FwdIter __first, _FwdIter __last,

		    flag_type __f = ECMAScript)

	: basic_regex(std::move(__first), std::move(__last), locale_type(), __f)

	{ }

      /**

       * @brief Constructs a basic regular expression from an initializer list.

       *

       * @param __l  The initializer list.

       * @param __f  The format flags of the regular expression.

       *

       * @throws regex_error if @p __l is not a valid regular expression.

       */

      basic_regex(initializer_list<_Ch_type> __l, flag_type __f = ECMAScript)

      : basic_regex(__l.begin(), __l.end(), __f)

      { }

      /**

       * @brief Destroys a basic regular expression.

       */

      ~basic_regex()

      { }

      /**

       * @brief Assigns one regular expression to another.

       */

      basic_regex&

      operator=(const basic_regex& __rhs)

      { return this->assign(__rhs); }

      /**

       * @brief Move-assigns one regular expression to another.

       */

      basic_regex&

      operator=(basic_regex&& __rhs) noexcept

      { return this->assign(std::move(__rhs)); }

      /**

       * @brief Replaces a regular expression with a new one constructed from

       * a C-style null-terminated string.

       *

       * @param __p A pointer to the start of a null-terminated C-style string

       *        containing a regular expression.

       */

      basic_regex&

      operator=(const _Ch_type* __p)

      { return this->assign(__p); }

      /**

       * @brief Replaces a regular expression with a new one constructed from

       * an initializer list.

       *

       * @param __l  The initializer list.

       *

       * @throws regex_error if @p __l is not a valid regular expression.

       */

      basic_regex&

      operator=(initializer_list<_Ch_type> __l)

      { return this->assign(__l.begin(), __l.end()); }

      /**

       * @brief Replaces a regular expression with a new one constructed from

       * a string.

       *

       * @param __s A pointer to a string containing a regular expression.

       */

      template

	basic_regex&

	operator=(const basic_string<_Ch_type, _Ch_traits, _Alloc>& __s)

	{ return this->assign(__s); }

      // [7.8.3] assign

      /**

       * @brief the real assignment operator.

       *

       * @param __rhs Another regular expression object.

       */

      basic_regex&

      assign(const basic_regex& __rhs)

      {

	basic_regex __tmp(__rhs);

	this->swap(__tmp);

	return *this;

      }

      /**

       * @brief The move-assignment operator.

       *

       * @param __rhs Another regular expression object.

       */

      basic_regex&

      assign(basic_regex&& __rhs) noexcept

      {

	basic_regex __tmp(std::move(__rhs));

	this->swap(__tmp);

	return *this;

      }

      /**

       * @brief Assigns a new regular expression to a regex object from a

       * C-style null-terminated string containing a regular expression

       * pattern.

       *

       * @param __p     A pointer to a C-style null-terminated string containing

       *              a regular expression pattern.

       * @param __flags Syntax option flags.

       *

       * @throws regex_error if __p does not contain a valid regular

       * expression pattern interpreted according to @p __flags.  If

       * regex_error is thrown, *this remains unchanged.

       */

      basic_regex&

      assign(const _Ch_type* __p, flag_type __flags = ECMAScript)

      { return this->assign(string_type(__p), __flags); }

      /**

       * @brief Assigns a new regular expression to a regex object from a

       * C-style string containing a regular expression pattern.

       *

       * @param __p     A pointer to a C-style string containing a

       *                regular expression pattern.

       * @param __len   The length of the regular expression pattern string.

       * @param __flags Syntax option flags.

       *

       * @throws regex_error if p does not contain a valid regular

       * expression pattern interpreted according to @p __flags.  If

       * regex_error is thrown, *this remains unchanged.

       */

      basic_regex&

      assign(const _Ch_type* __p, std::size_t __len, flag_type __flags)

      { return this->assign(string_type(__p, __len), __flags); }

      /**

       * @brief Assigns a new regular expression to a regex object from a

       * string containing a regular expression pattern.

       *

       * @param __s     A string containing a regular expression pattern.

       * @param __flags Syntax option flags.

       *

       * @throws regex_error if __s does not contain a valid regular

       * expression pattern interpreted according to @p __flags.  If

       * regex_error is thrown, *this remains unchanged.

       */

      template

	basic_regex&

	assign(const basic_string<_Ch_type, _Ch_traits, _Alloc>& __s,

	       flag_type __flags = ECMAScript)

	{

	  return this->assign(basic_regex(__s.data(), __s.data() + __s.size(),

					  _M_loc, __flags));

	}

      /**

       * @brief Assigns a new regular expression to a regex object.

       *

       * @param __first The start of a range containing a valid regular

       *                expression.

       * @param __last  The end of a range containing a valid regular

       *                expression.

       * @param __flags Syntax option flags.

       *

       * @throws regex_error if p does not contain a valid regular

       * expression pattern interpreted according to @p __flags.  If

       * regex_error is thrown, the object remains unchanged.

       */

      template

	basic_regex&

	assign(_InputIterator __first, _InputIterator __last,

	       flag_type __flags = ECMAScript)

	{ return this->assign(string_type(__first, __last), __flags); }

      /**

       * @brief Assigns a new regular expression to a regex object.

       *

       * @param __l     An initializer list representing a regular expression.

       * @param __flags Syntax option flags.

       *

       * @throws regex_error if @p __l does not contain a valid

       * regular expression pattern interpreted according to @p

       * __flags.  If regex_error is thrown, the object remains

       * unchanged.

       */

      basic_regex&

      assign(initializer_list<_Ch_type> __l, flag_type __flags = ECMAScript)

      { return this->assign(__l.begin(), __l.end(), __flags); }

      // [7.8.4] const operations

      /**

       * @brief Gets the number of marked subexpressions within the regular

       * expression.

       */

      unsigned int

      mark_count() const

      {

	if (_M_automaton)

	  return _M_automaton->_M_sub_count() - 1;

	return 0;

      }

      /**

       * @brief Gets the flags used to construct the regular expression

       * or in the last call to assign().

       */

      flag_type

      flags() const

      { return _M_flags; }

      // [7.8.5] locale

      /**

       * @brief Imbues the regular expression object with the given locale.

       *

       * @param __loc A locale.

       */

      locale_type

      imbue(locale_type __loc)

      {

	std::swap(__loc, _M_loc);

	_M_automaton.reset();

	return __loc;

      }

      /**

       * @brief Gets the locale currently imbued in the regular expression

       *        object.

       */

      locale_type

      getloc() const

      { return _M_loc; }

      // [7.8.6] swap

      /**

       * @brief Swaps the contents of two regular expression objects.

       *

       * @param __rhs Another regular expression object.

       */

      void

      swap(basic_regex& __rhs)

      {

	std::swap(_M_flags, __rhs._M_flags);

	std::swap(_M_loc, __rhs._M_loc);

	std::swap(_M_automaton, __rhs._M_automaton);

      }

#ifdef _GLIBCXX_DEBUG

      void

      _M_dot(std::ostream& __ostr)

      { _M_automaton->_M_dot(__ostr); }

#endif

    private:

      typedef std::shared_ptr> _AutomatonPtr;

      template

	basic_regex(_FwdIter __first, _FwdIter __last, locale_type __loc,

		    flag_type __f)

	: _M_flags(__f), _M_loc(std::move(__loc)),

	_M_automaton(__detail::__compile_nfa<_FwdIter, _Rx_traits>(

	  std::move(__first), std::move(__last), _M_loc, _M_flags))

	{ }

      template

	__detail::_RegexExecutorPolicy, bool>

	friend bool

	__detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,

				    const basic_regex<_Cp, _Rp>&,

				    regex_constants::match_flag_type);

      template

	friend class __detail::_Executor;

      flag_type              _M_flags;

      locale_type            _M_loc;

      _AutomatonPtr          _M_automaton;

    };

  /** @brief Standard regular expressions. */

  typedef basic_regex    regex;

#ifdef _GLIBCXX_USE_WCHAR_T

  /** @brief Standard wide-character regular expressions. */

  typedef basic_regex wregex;

#endif

  // [7.8.6] basic_regex swap

  /**

   * @brief Swaps the contents of two regular expression objects.

   * @param __lhs First regular expression.

   * @param __rhs Second regular expression.

   */

  template

    inline void

    swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,

	 basic_regex<_Ch_type, _Rx_traits>& __rhs)

    { __lhs.swap(__rhs); }

  // [7.9] Class template sub_match

  /**

   * A sequence of characters matched by a particular marked sub-expression.

   *

   * An object of this class is essentially a pair of iterators marking a

   * matched subexpression within a regular expression pattern match. Such

   * objects can be converted to and compared with std::basic_string objects

   * of a similar base character type as the pattern matched by the regular

   * expression.

   *

   * The iterators that make up the pair are the usual half-open interval

   * referencing the actual original pattern matched.

   */

  template

    class sub_match : public std::pair<_BiIter, _BiIter>

    {

      typedef iterator_traits<_BiIter>			__iter_traits;

    public:

      typedef typename __iter_traits::value_type      	value_type;

      typedef typename __iter_traits::difference_type 	difference_type;

      typedef _BiIter                                   iterator;

      typedef std::basic_string             string_type;

      bool matched;

      constexpr sub_match() : matched() { }

      /**

       * Gets the length of the matching sequence.

       */

      difference_type

      length() const

      { return this->matched ? std::distance(this->first, this->second) : 0; }

      /**

       * @brief Gets the matching sequence as a string.

       *

       * @returns the matching sequence as a string.

       *

       * This is the implicit conversion operator.  It is identical to the

       * str() member function except that it will want to pop up in

       * unexpected places and cause a great deal of confusion and cursing

       * from the unwary.

       */

      operator string_type() const

      {

	return this->matched

	  ? string_type(this->first, this->second)

	  : string_type();

      }

      /**

       * @brief Gets the matching sequence as a string.

       *

       * @returns the matching sequence as a string.

       */

      string_type

      str() const

      {

	return this->matched

	  ? string_type(this->first, this->second)

	  : string_type();

      }

      /**

       * @brief Compares this and another matched sequence.

       *

       * @param __s Another matched sequence to compare to this one.

       *

       * @retval <0 this matched sequence will collate before @p __s.

       * @retval =0 this matched sequence is equivalent to @p __s.

       * @retval <0 this matched sequence will collate after @p __s.

       */

      int

      compare(const sub_match& __s) const

      { return this->str().compare(__s.str()); }

      /**

       * @brief Compares this sub_match to a string.

       *

       * @param __s A string to compare to this sub_match.

       *

       * @retval <0 this matched sequence will collate before @p __s.

       * @retval =0 this matched sequence is equivalent to @p __s.

       * @retval <0 this matched sequence will collate after @p __s.

       */

      int

      compare(const string_type& __s) const

      { return this->str().compare(__s); }

      /**

       * @brief Compares this sub_match to a C-style string.

       *

       * @param __s A C-style string to compare to this sub_match.

       *

       * @retval <0 this matched sequence will collate before @p __s.

       * @retval =0 this matched sequence is equivalent to @p __s.

       * @retval <0 this matched sequence will collate after @p __s.

       */

      int

      compare(const value_type* __s) const

      { return this->str().compare(__s); }

    };

  /** @brief Standard regex submatch over a C-style null-terminated string. */

  typedef sub_match             csub_match;

  /** @brief Standard regex submatch over a standard string. */

  typedef sub_match  ssub_match;

#ifdef _GLIBCXX_USE_WCHAR_T

  /** @brief Regex submatch over a C-style null-terminated wide string. */

  typedef sub_match          wcsub_match;

  /** @brief Regex submatch over a standard wide string. */

  typedef sub_match wssub_match;

#endif

  // [7.9.2] sub_match non-member operators

  /**

   * @brief Tests the equivalence of two regular expression submatches.

   * @param __lhs First regular expression submatch.

   * @param __rhs Second regular expression submatch.

   * @returns true if @a __lhs  is equivalent to @a __rhs, false otherwise.

   */

  template

    inline bool

    operator==(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)

    { return __lhs.compare(__rhs) == 0; }

  /**

   * @brief Tests the inequivalence of two regular expression submatches.

   * @param __lhs First regular expression submatch.

   * @param __rhs Second regular expression submatch.

   * @returns true if @a __lhs  is not equivalent to @a __rhs, false otherwise.

   */

  template

    inline bool

    operator!=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)

    { return __lhs.compare(__rhs) != 0; }

  /**

   * @brief Tests the ordering of two regular expression submatches.

   * @param __lhs First regular expression submatch.

   * @param __rhs Second regular expression submatch.

   * @returns true if @a __lhs precedes @a __rhs, false otherwise.

   */

  template

    inline bool

    operator<(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)

    { return __lhs.compare(__rhs) < 0; }

  /**

   * @brief Tests the ordering of two regular expression submatches.

   * @param __lhs First regular expression submatch.

   * @param __rhs Second regular expression submatch.

   * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.

   */

  template

    inline bool

    operator<=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)

    { return __lhs.compare(__rhs) <= 0; }

  /**

   * @brief Tests the ordering of two regular expression submatches.

   * @param __lhs First regular expression submatch.

   * @param __rhs Second regular expression submatch.

   * @returns true if @a __lhs does not precede @a __rhs, false otherwise.

   */

  template

    inline bool

    operator>=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)

    { return __lhs.compare(__rhs) >= 0; }

  /**

   * @brief Tests the ordering of two regular expression submatches.

   * @param __lhs First regular expression submatch.

   * @param __rhs Second regular expression submatch.

   * @returns true if @a __lhs succeeds @a __rhs, false otherwise.

   */

  template

    inline bool

    operator>(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)

    { return __lhs.compare(__rhs) > 0; }

  // Alias for sub_match'd string.

  template

    using __sub_match_string = basic_string<

			      typename iterator_traits<_Bi_iter>::value_type,

			      _Ch_traits, _Ch_alloc>;

  /**

   * @brief Tests the equivalence of a string and a regular expression

   *        submatch.

   * @param __lhs A string.

   * @param __rhs A regular expression submatch.

   * @returns true if @a __lhs  is equivalent to @a __rhs, false otherwise.

   */

  template

    inline bool

    operator==(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,

	       const sub_match<_Bi_iter>& __rhs)

    {

      typedef typename sub_match<_Bi_iter>::string_type string_type;

      return __rhs.compare(string_type(__lhs.data(), __lhs.size())) == 0;

    }

  /**

   * @brief Tests the inequivalence of a string and a regular expression

   *        submatch.

   * @param __lhs A string.

   * @param __rhs A regular expression submatch.

   * @returns true if @a __lhs  is not equivalent to @a __rhs, false otherwise.

   */

  template

    inline bool

    operator!=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,

	       const sub_match<_Bi_iter>& __rhs)

    { return !(__lhs == __rhs); }

  /**

   * @brief Tests the ordering of a string and a regular expression submatch.

   * @param __lhs A string.

   * @param __rhs A regular expression submatch.

   * @returns true if @a __lhs precedes @a __rhs, false otherwise.

   */

  template

    inline bool

    operator<(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,

	      const sub_match<_Bi_iter>& __rhs)

    {

      typedef typename sub_match<_Bi_iter>::string_type string_type;

      return __rhs.compare(string_type(__lhs.data(), __lhs.size())) > 0;

    }

  /**

   * @brief Tests the ordering of a string and a regular expression submatch.

   * @param __lhs A string.

   * @param __rhs A regular expression submatch.

   * @returns true if @a __lhs succeeds @a __rhs, false otherwise.

   */

  template

    inline bool

    operator>(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,

	      const sub_match<_Bi_iter>& __rhs)

    { return __rhs < __lhs; }

  /**

   * @brief Tests the ordering of a string and a regular expression submatch.

   * @param __lhs A string.

   * @param __rhs A regular expression submatch.

   * @returns true if @a __lhs does not precede @a __rhs, false otherwise.

   */

  template

    inline bool

    operator>=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,

	       const sub_match<_Bi_iter>& __rhs)

    { return !(__lhs < __rhs); }

  /**

   * @brief Tests the ordering of a string and a regular expression submatch.

   * @param __lhs A string.

   * @param __rhs A regular expression submatch.

   * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.

   */

  template

    inline bool

    operator<=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,

	       const sub_match<_Bi_iter>& __rhs)

    { return !(__rhs < __lhs); }

  /**

   * @brief Tests the equivalence of a regular expression submatch and a

   *        string.

   * @param __lhs A regular expression submatch.

   * @param __rhs A string.

   * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.

   */

  template

    inline bool

    operator==(const sub_match<_Bi_iter>& __lhs,

	       const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)

    {

      typedef typename sub_match<_Bi_iter>::string_type string_type;

      return __lhs.compare(string_type(__rhs.data(), __rhs.size())) == 0;

    }

  /**

   * @brief Tests the inequivalence of a regular expression submatch and a

   *        string.

   * @param __lhs A regular expression submatch.

   * @param __rhs A string.

   * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.

   */

  template

    inline bool

    operator!=(const sub_match<_Bi_iter>& __lhs,

	       const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)

    { return !(__lhs == __rhs); }

  /**

   * @brief Tests the ordering of a regular expression submatch and a string.

   * @param __lhs A regular expression submatch.

   * @param __rhs A string.

   * @returns true if @a __lhs precedes @a __rhs, false otherwise.

   */

  template

    inline bool

    operator<(const sub_match<_Bi_iter>& __lhs,

	      const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)

    {

      typedef typename sub_match<_Bi_iter>::string_type string_type;

      return __lhs.compare(string_type(__rhs.data(), __rhs.size())) < 0;