The C and C++ Include Header Files

/usr/include/c++/11/tr1/regex


$ cat -n /usr/include/c++/11/tr1/regex

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