tr1_impl/regex

Go to the documentation of this file.
00001 // class template regex -*- C++ -*-
00002 
00003 // Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
00004 //
00005 // This file is part of the GNU ISO C++ Library.  This library is free
00006 // software; you can redistribute it and/or modify it under the
00007 // terms of the GNU General Public License as published by the
00008 // Free Software Foundation; either version 3, or (at your option)
00009 // any later version.
00010 
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 // GNU General Public License for more details.
00015 
00016 // Under Section 7 of GPL version 3, you are granted additional
00017 // permissions described in the GCC Runtime Library Exception, version
00018 // 3.1, as published by the Free Software Foundation.
00019 
00020 // You should have received a copy of the GNU General Public License and
00021 // a copy of the GCC Runtime Library Exception along with this program;
00022 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00023 // <http://www.gnu.org/licenses/>.
00024 
00025 /**
00026  * @file tr1_impl/regex
00027  * @brief The common implementation file for tr1 and std regular expressions.
00028  *
00029  *  This is an internal header file, included by other library headers.
00030  *  You should not attempt to use it directly.
00031  */
00032 
00033 namespace std
00034 {
00035 _GLIBCXX_BEGIN_NAMESPACE_TR1
00036 
00037 /**
00038  * @defgroup tr1_regex Regular Expressions
00039  * A facility for performing regular expression pattern matching.
00040  */
00041  //@{
00042 
00043 /** @namespace std::regex_constants
00044  *  @brief ISO C++ 0x entities sub namespace for regex.
00045  */
00046 namespace regex_constants
00047 {
00048   /**
00049    * @name 5.1 Regular Expression Syntax Options
00050    */
00051   //@{
00052   enum __syntax_option
00053     {
00054       _S_icase,
00055       _S_nosubs,
00056       _S_optimize,
00057       _S_collate,
00058       _S_ECMAScript,
00059       _S_basic,
00060       _S_extended,
00061       _S_awk,
00062       _S_grep,
00063       _S_egrep,
00064       _S_syntax_last
00065     };
00066 
00067   /**
00068    * @brief This is a bitmask type indicating how to interpret the regex.
00069    *
00070    * The @c syntax_option_type is implementation defined but it is valid to
00071    * perform bitwise operations on these values and expect the right thing to
00072    * happen.
00073    *
00074    * A valid value of type syntax_option_type shall have exactly one of the
00075    * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep
00076    * %set.
00077    */
00078   typedef unsigned int syntax_option_type;
00079 
00080   /** 
00081    * Specifies that the matching of regular expressions against a character
00082    * sequence shall be performed without regard to case.
00083    */
00084   static const syntax_option_type icase      = 1 << _S_icase;
00085 
00086   /**
00087    * Specifies that when a regular expression is matched against a character
00088    * container sequence, no sub-expression matches are to be stored in the
00089    * supplied match_results structure.
00090    */
00091   static const syntax_option_type nosubs     = 1 << _S_nosubs;
00092 
00093   /**
00094    * Specifies that the regular expression engine should pay more attention to
00095    * the speed with which regular expressions are matched, and less to the
00096    * speed with which regular expression objects are constructed. Otherwise
00097    * it has no detectable effect on the program output.
00098    */
00099   static const syntax_option_type optimize   = 1 << _S_optimize;
00100 
00101   /**
00102    * Specifies that character ranges of the form [a-b] should be locale
00103    * sensitive.
00104    */
00105   static const syntax_option_type collate    = 1 << _S_collate;
00106 
00107   /**
00108    * Specifies that the grammar recognized by the regular expression engine is
00109    * that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript
00110    * Language Specification, Standard Ecma-262, third edition, 1999], as
00111    * modified in tr1 section [7.13].  This grammar is similar to that defined
00112    * in the PERL scripting language but extended with elements found in the
00113    * POSIX regular expression grammar.
00114    */
00115   static const syntax_option_type ECMAScript = 1 << _S_ECMAScript;
00116 
00117   /**
00118    * Specifies that the grammar recognized by the regular expression engine is
00119    * that used by POSIX basic regular expressions in IEEE Std 1003.1-2001,
00120    * Portable Operating System Interface (POSIX), Base Definitions and
00121    * Headers, Section 9, Regular Expressions [IEEE, Information Technology --
00122    * Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
00123    */
00124   static const syntax_option_type basic      = 1 << _S_basic;
00125 
00126   /**
00127    * Specifies that the grammar recognized by the regular expression engine is
00128    * that used by POSIX extended regular expressions in IEEE Std 1003.1-2001,
00129    * Portable Operating System Interface (POSIX), Base Definitions and Headers,
00130    * Section 9, Regular Expressions.
00131    */
00132   static const syntax_option_type extended   = 1 << _S_extended;
00133 
00134   /**
00135    * Specifies that the grammar recognized by the regular expression engine is
00136    * that used by POSIX utility awk in IEEE Std 1003.1-2001.  This option is
00137    * identical to syntax_option_type extended, except that C-style escape
00138    * sequences are supported.  These sequences are, explicitly, "\\", "\a",
00139    * "\b", "\f", "\n", "\r", "\t" , "\v", "\"", "'",
00140    * and "\ddd" (where ddd is one, two, or three octal digits).  
00141    */
00142   static const syntax_option_type awk        = 1 << _S_awk;
00143 
00144   /**
00145    * Specifies that the grammar recognized by the regular expression engine is
00146    * that used by POSIX utility grep in IEEE Std 1003.1-2001.  This option is
00147    * identical to syntax_option_type basic, except that newlines are treated
00148    * as whitespace.
00149    */
00150   static const syntax_option_type grep       = 1 << _S_grep;
00151 
00152   /**
00153    * Specifies that the grammar recognized by the regular expression engine is
00154    * that used by POSIX utility grep when given the -E option in
00155    * IEEE Std 1003.1-2001.  This option is identical to syntax_option_type 
00156    * extended, except that newlines are treated as whitespace.
00157    */
00158   static const syntax_option_type egrep      = 1 << _S_egrep;
00159 
00160   //@}
00161 
00162   /**
00163    * @name 5.2 Matching Rules
00164    *
00165    * Matching a regular expression against a sequence of characters [first,
00166    * last) proceeds according to the rules of the grammar specified for the
00167    * regular expression object, modified according to the effects listed
00168    * below for any bitmask elements set.
00169    *
00170    */
00171   //@{
00172 
00173   enum __match_flag
00174     {
00175       _S_not_bol,
00176       _S_not_eol,
00177       _S_not_bow,
00178       _S_not_eow,
00179       _S_any,
00180       _S_not_null,
00181       _S_continuous,
00182       _S_prev_avail,
00183       _S_sed,
00184       _S_no_copy,
00185       _S_first_only,
00186       _S_match_flag_last
00187     };
00188 
00189   /**
00190    * @brief This is a bitmask type indicating regex matching rules.
00191    *
00192    * The @c match_flag_type is implementation defined but it is valid to
00193    * perform bitwise operations on these values and expect the right thing to
00194    * happen.
00195    */
00196   typedef std::bitset<_S_match_flag_last> match_flag_type;
00197 
00198   /**
00199    * The default matching rules.
00200    */
00201   static const match_flag_type match_default     = 0;
00202 
00203   /**
00204    * The first character in the sequence [first, last) is treated as though it
00205    * is not at the beginning of a line, so the character "^" in the regular
00206    * expression shall not match [first, first).
00207    */
00208   static const match_flag_type match_not_bol     = 1 << _S_not_bol;
00209 
00210   /**
00211    * The last character in the sequence [first, last) is treated as though it
00212    * is not at the end of a line, so the character "$" in the regular
00213    * expression shall not match [last, last).
00214    */
00215   static const match_flag_type match_not_eol     = 1 << _S_not_eol;
00216    
00217   /**
00218    * The expression "\b" is not matched against the sub-sequence
00219    * [first,first).
00220    */
00221   static const match_flag_type match_not_bow     = 1 << _S_not_bow;
00222    
00223   /**
00224    * The expression "\b" should not be matched against the sub-sequence
00225    * [last,last).
00226    */
00227   static const match_flag_type match_not_eow     = 1 << _S_not_eow;
00228    
00229   /**
00230    * If more than one match is possible then any match is an acceptable
00231    * result.
00232    */
00233   static const match_flag_type match_any         = 1 << _S_any;
00234    
00235   /**
00236    * The expression does not match an empty sequence.
00237    */
00238   static const match_flag_type match_not_null    = 1 << _S_not_null;
00239    
00240   /**
00241    * The expression only matches a sub-sequence that begins at first .
00242    */
00243   static const match_flag_type match_continuous  = 1 << _S_continuous;
00244    
00245   /**
00246    * --first is a valid iterator position.  When this flag is set then the
00247    * flags match_not_bol and match_not_bow are ignored by the regular
00248    * expression algorithms 7.11 and iterators 7.12.
00249    */
00250   static const match_flag_type match_prev_avail  = 1 << _S_prev_avail;
00251 
00252   /**
00253    * When a regular expression match is to be replaced by a new string, the
00254    * new string is constructed using the rules used by the ECMAScript replace
00255    * function in ECMA- 262 [Ecma International, ECMAScript Language
00256    * Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11
00257    * String.prototype.replace. In addition, during search and replace
00258    * operations all non-overlapping occurrences of the regular expression
00259    * are located and replaced, and sections of the input that did not match
00260    * the expression are copied unchanged to the output string.
00261    * 
00262    * Format strings (from ECMA-262 [15.5.4.11]):
00263    * @li $$  The dollar-sign itself ($)
00264    * @li $&  The matched substring.
00265    * @li $`  The portion of <em>string</em> that precedes the matched substring.
00266    *         This would be match_results::prefix().
00267    * @li $'  The portion of <em>string</em> that follows the matched substring.
00268    *         This would be match_results::suffix().
00269    * @li $n  The nth capture, where n is in [1,9] and $n is not followed by a
00270    *         decimal digit.  If n <= match_results::size() and the nth capture
00271    *         is undefined, use the empty string instead.  If n >
00272    *         match_results::size(), the result is implementation-defined.
00273    * @li $nn The nnth capture, where nn is a two-digit decimal number on
00274    *         [01, 99].  If nn <= match_results::size() and the nth capture is
00275    *         undefined, use the empty string instead. If
00276    *         nn > match_results::size(), the result is implementation-defined.
00277    */
00278   static const match_flag_type format_default    = 0;
00279 
00280   /**
00281    * When a regular expression match is to be replaced by a new string, the
00282    * new string is constructed using the rules used by the POSIX sed utility
00283    * in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable
00284    * Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
00285    */
00286   static const match_flag_type format_sed        = 1 << _S_sed;
00287 
00288   /**
00289    * During a search and replace operation, sections of the character
00290    * container sequence being searched that do not match the regular
00291    * expression shall not be copied to the output string.
00292    */
00293   static const match_flag_type format_no_copy    = 1 << _S_no_copy;
00294 
00295   /**
00296    * When specified during a search and replace operation, only the first
00297    * occurrence of the regular expression shall be replaced.
00298    */
00299   static const match_flag_type format_first_only = 1 << _S_first_only;
00300 
00301   //@}
00302 
00303   /**
00304    * @name 5.3 Error Types
00305    */
00306   //@{
00307  
00308   enum error_type
00309     {
00310       _S_error_collate,
00311       _S_error_ctype,
00312       _S_error_escape,
00313       _S_error_backref,
00314       _S_error_brack,
00315       _S_error_paren,
00316       _S_error_brace,
00317       _S_error_badbrace,
00318       _S_error_range,
00319       _S_error_space,
00320       _S_error_badrepeat,
00321       _S_error_complexity,
00322       _S_error_stack,
00323       _S_error_last
00324     };
00325 
00326   /** The expression contained an invalid collating element name. */
00327   static const error_type error_collate(_S_error_collate);
00328 
00329   /** The expression contained an invalid character class name. */
00330   static const error_type error_ctype(_S_error_ctype);
00331 
00332   /**
00333    * The expression contained an invalid escaped character, or a trailing
00334    * escape.
00335    */
00336   static const error_type error_escape(_S_error_escape);
00337 
00338   /** The expression contained an invalid back reference. */
00339   static const error_type error_backref(_S_error_backref);
00340 
00341   /** The expression contained mismatched [ and ]. */
00342   static const error_type error_brack(_S_error_brack);
00343 
00344   /** The expression contained mismatched ( and ). */
00345   static const error_type error_paren(_S_error_paren);
00346 
00347   /** The expression contained mismatched { and } */
00348   static const error_type error_brace(_S_error_brace);
00349 
00350   /** The expression contained an invalid range in a {} expression. */
00351   static const error_type error_badbrace(_S_error_badbrace);
00352 
00353   /**
00354    * The expression contained an invalid character range,
00355    * such as [b-a] in most encodings.
00356    */
00357   static const error_type error_range(_S_error_range);
00358 
00359   /**
00360    * There was insufficient memory to convert the expression into a
00361    * finite state machine.
00362    */
00363   static const error_type error_space(_S_error_space);
00364 
00365   /**
00366    * One of "*?+{" was not preceded by a valid regular expression.
00367    */
00368   static const error_type error_badrepeat(_S_error_badrepeat);
00369 
00370   /**
00371    * The complexity of an attempted match against a regular expression
00372    * exceeded a pre-set level.
00373    */
00374   static const error_type error_complexity(_S_error_complexity);
00375 
00376   /**
00377    * There was insufficient memory to determine whether the
00378    * regular expression could match the specified character sequence.
00379    */
00380   static const error_type error_stack(_S_error_stack);
00381 
00382   //@}
00383 }
00384 
00385 
00386   // [7.8] Class regex_error
00387   /**
00388    *  @brief A regular expression exception class.
00389    *  @ingroup exceptions
00390    *
00391    *  The regular expression library throws objects of this class on error.
00392    */
00393   class regex_error
00394   : public std::runtime_error
00395   {
00396   public:
00397     /**
00398      * @brief Constructs a regex_error object.
00399      *
00400      * @param ecode the regex error code.
00401      */
00402     explicit
00403     regex_error(regex_constants::error_type __ecode)
00404     : std::runtime_error("regex_error"), _M_code(__ecode)
00405     { }
00406 
00407     /**
00408      * @brief Gets the regex error code.
00409      *
00410      * @returns the regex error code.
00411      */
00412     regex_constants::error_type
00413     code() const
00414     { return _M_code; }
00415 
00416   protected:
00417     regex_constants::error_type _M_code;
00418   };
00419 
00420   // [7.7] Class regex_traits
00421   /**
00422    * @brief Describes aspects of a regular expression.
00423    *
00424    * A regular expression traits class that satisfies the requirements of tr1
00425    * section [7.2].
00426    *
00427    * The class %regex is parameterized around a set of related types and
00428    * functions used to complete the definition of its semantics.  This class
00429    * satisfies the requirements of such a traits class.
00430    */
00431   template<typename _Ch_type>
00432     struct regex_traits
00433     {
00434     public:
00435       typedef _Ch_type                     char_type;
00436       typedef std::basic_string<char_type> string_type;
00437       typedef std::locale                  locale_type;
00438       typedef std::ctype_base::mask        char_class_type;
00439 
00440     public:
00441       /**
00442        * @brief Constructs a default traits object.
00443        */
00444       regex_traits()
00445       { }
00446       
00447       /**
00448        * @brief Gives the length of a C-style string starting at @p __p.
00449        *
00450        * @param __p a pointer to the start of a character sequence.
00451        *
00452        * @returns the number of characters between @p *__p and the first
00453        * default-initialized value of type @p char_type.  In other words, uses
00454        * the C-string algorithm for determining the length of a sequence of
00455        * characters.
00456        */
00457       static std::size_t
00458       length(const char_type* __p)
00459       { return string_type::traits_type::length(__p); }
00460 
00461       /**
00462        * @brief Performs the identity translation.
00463        *
00464        * @param c A character to the locale-specific character set.
00465        *
00466        * @returns c.
00467        */
00468       char_type
00469       translate(char_type __c) const
00470       { return __c; }
00471       
00472       /**
00473        * @brief Translates a character into a case-insensitive equivalent.
00474        *
00475        * @param c A character to the locale-specific character set.
00476        *
00477        * @returns the locale-specific lower-case equivalent of c.
00478        * @throws std::bad_cast if the imbued locale does not support the ctype
00479        *         facet.
00480        */
00481       char_type
00482       translate_nocase(char_type __c) const
00483       {
00484     using std::ctype;
00485     using std::use_facet;
00486     return use_facet<ctype<char_type> >(_M_locale).tolower(__c);
00487       }
00488       
00489       /**
00490        * @brief Gets a sort key for a character sequence.
00491        *
00492        * @param first beginning of the character sequence.
00493        * @param last  one-past-the-end of the character sequence.
00494        *
00495        * Returns a sort key for the character sequence designated by the
00496        * iterator range [F1, F2) such that if the character sequence [G1, G2)
00497        * sorts before the character sequence [H1, H2) then
00498        * v.transform(G1, G2) < v.transform(H1, H2).
00499        *
00500        * What this really does is provide a more efficient way to compare a
00501        * string to multiple other strings in locales with fancy collation
00502        * rules and equivalence classes.
00503        *
00504        * @returns a locale-specific sort key equivalent to the input range.
00505        *
00506        * @throws std::bad_cast if the current locale does not have a collate
00507        *         facet.
00508        */
00509       template<typename _Fwd_iter>
00510         string_type
00511         transform(_Fwd_iter __first, _Fwd_iter __last) const
00512         {
00513       using std::collate;
00514       using std::use_facet;
00515       const collate<_Ch_type>& __c(use_facet<
00516                        collate<_Ch_type> >(_M_locale));
00517       string_type __s(__first, __last);
00518       return __c.transform(__s.data(), __s.data() + __s.size());
00519     }
00520 
00521       /**
00522        * @brief Dunno.
00523        *
00524        * @param first beginning of the character sequence.
00525        * @param last  one-past-the-end of the character sequence.
00526        *
00527        * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
00528        * typeid(collate_byname<_Ch_type>) and the form of the sort key
00529        * returned by collate_byname<_Ch_type>::transform(first, last) is known
00530        * and can be converted into a primary sort key then returns that key,
00531        * otherwise returns an empty string. WTF??
00532        *
00533        * @todo Implement this function.
00534        */
00535       template<typename _Fwd_iter>
00536         string_type
00537         transform_primary(_Fwd_iter __first, _Fwd_iter __last) const;
00538 
00539       /**
00540        * @brief Gets a collation element by name.
00541        *
00542        * @param first beginning of the collation element name.
00543        * @param last  one-past-the-end of the collation element name.
00544        * 
00545        * @returns a sequence of one or more characters that represents the
00546        * collating element consisting of the character sequence designated by
00547        * the iterator range [first, last). Returns an empty string if the
00548        * character sequence is not a valid collating element.
00549        *
00550        * @todo Implement this function.
00551        */
00552       template<typename _Fwd_iter>
00553         string_type
00554         lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const;
00555 
00556       /**
00557        * @brief Maps one or more characters to a named character
00558        *        classification.
00559        *
00560        * @param first beginning of the character sequence.
00561        * @param last  one-past-the-end of the character sequence.
00562        *
00563        * @returns an unspecified value that represents the character
00564        * classification named by the character sequence designated by the
00565        * iterator range [first, last). The value returned shall be independent
00566        * of the case of the characters in the character sequence. If the name
00567        * is not recognized then returns a value that compares equal to 0.
00568        *
00569        * At least the following names (or their wide-character equivalent) are
00570        * supported.
00571        * - d
00572        * - w
00573        * - s
00574        * - alnum
00575        * - alpha
00576        * - blank
00577        * - cntrl
00578        * - digit
00579        * - graph
00580        * - lower
00581        * - print
00582        * - punct
00583        * - space
00584        * - upper
00585        * - xdigit
00586        *
00587        * @todo Implement this function.
00588        */
00589       template<typename _Fwd_iter>
00590         char_class_type
00591         lookup_classname(_Fwd_iter __first, _Fwd_iter __last) const;
00592 
00593       /**
00594        * @brief Determines if @p c is a member of an identified class.
00595        *
00596        * @param c a character.
00597        * @param f a class type (as returned from lookup_classname).
00598        *
00599        * @returns true if the character @p c is a member of the classification
00600        * represented by @p f, false otherwise.
00601        *
00602        * @throws std::bad_cast if the current locale does not have a ctype
00603        *         facet.
00604        */
00605       bool
00606       isctype(_Ch_type __c, char_class_type __f) const;
00607 
00608       /**
00609        * @brief Converts a digit to an int.
00610        *
00611        * @param ch    a character representing a digit.
00612        * @param radix the radix if the numeric conversion (limited to 8, 10,
00613        *              or 16).
00614        * 
00615        * @returns the value represented by the digit ch in base radix if the
00616        * character ch is a valid digit in base radix; otherwise returns -1.
00617        */
00618       int
00619       value(_Ch_type __ch, int __radix) const;
00620       
00621       /**
00622        * @brief Imbues the regex_traits object with a copy of a new locale.
00623        *
00624        * @param loc A locale.
00625        *
00626        * @returns a copy of the previous locale in use by the regex_traits
00627        *          object.
00628        *
00629        * @note Calling imbue with a different locale than the one currently in
00630        *       use invalidates all cached data held by *this.
00631        */
00632       locale_type
00633       imbue(locale_type __loc)
00634       {
00635     std::swap(_M_locale, __loc);
00636     return __loc;
00637       }
00638       
00639       /**
00640        * @brief Gets a copy of the current locale in use by the regex_traits
00641        * object.
00642        */
00643       locale_type
00644       getloc() const
00645       { return _M_locale; }
00646       
00647     protected:
00648       locale_type _M_locale;
00649     };
00650 
00651   template<typename _Ch_type>
00652     bool regex_traits<_Ch_type>::
00653     isctype(_Ch_type __c, char_class_type __f) const
00654     {
00655       using std::ctype;
00656       using std::use_facet;
00657       const ctype<_Ch_type>& __ctype(use_facet<
00658                      ctype<_Ch_type> >(_M_locale));
00659       
00660       if (__ctype.is(__c, __f))
00661     return true;
00662       
00663       // special case of underscore in [[:w:]]
00664       if (__c == __ctype.widen('_'))
00665     {
00666       const char* const __wb[] = "w";
00667       char_class_type __wt = this->lookup_classname(__wb,
00668                             __wb + sizeof(__wb));
00669       if (__f | __wt)
00670         return true;
00671     }
00672     
00673       // special case of [[:space:]] in [[:blank:]]
00674       if (__c == __ctype.isspace(__c))
00675     {
00676       const char* const __bb[] = "blank";
00677       char_class_type __bt = this->lookup_classname(__bb,
00678                             __bb + sizeof(__bb));
00679       if (__f | __bt)
00680         return true;
00681     }
00682       
00683       return false;
00684     }
00685 
00686   template<typename _Ch_type>
00687     int regex_traits<_Ch_type>::
00688     value(_Ch_type __ch, int __radix) const
00689     {
00690       std::basic_istringstream<_Ch_type> __is(string_type(1, __ch));
00691       int __v = -1;
00692       if (__radix == 8)
00693     __is >> std::oct;
00694       else if (__radix == 16)
00695     __is >> std::hex;
00696       __is >> __v;
00697       return __v;
00698     }
00699 
00700   // [7.8] Class basic_regex
00701   /**
00702    * Objects of specializations of this class represent regular expressions
00703    * constructed from sequences of character type @p _Ch_type.
00704    *
00705    * Storage for the regular expression is allocated and deallocated as
00706    * necessary by the member functions of this class.
00707    */
00708   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type> >
00709     class basic_regex
00710     {
00711     public:
00712       // types:
00713       typedef _Ch_type                              value_type;
00714       typedef regex_constants::syntax_option_type flag_type;
00715       typedef typename _Rx_traits::locale_type  locale_type;
00716       typedef typename _Rx_traits::string_type  string_type;
00717 
00718       /**
00719        * @name Constants
00720        * tr1 [7.8.1] std [28.8.1]
00721        */
00722       //@{
00723       static const regex_constants::syntax_option_type icase
00724         = regex_constants::icase;
00725       static const regex_constants::syntax_option_type nosubs
00726         = regex_constants::nosubs;
00727       static const regex_constants::syntax_option_type optimize
00728         = regex_constants::optimize;
00729       static const regex_constants::syntax_option_type collate
00730         = regex_constants::collate;
00731       static const regex_constants::syntax_option_type ECMAScript
00732         = regex_constants::ECMAScript;
00733       static const regex_constants::syntax_option_type basic
00734         = regex_constants::basic;
00735       static const regex_constants::syntax_option_type extended
00736         = regex_constants::extended;
00737       static const regex_constants::syntax_option_type awk
00738         = regex_constants::awk;
00739       static const regex_constants::syntax_option_type grep
00740         = regex_constants::grep;
00741       static const regex_constants::syntax_option_type egrep
00742         = regex_constants::egrep;
00743       //@}
00744 
00745       // [7.8.2] construct/copy/destroy
00746       /**
00747        * Constructs a basic regular expression that does not match any
00748        * character sequence.
00749        */
00750       basic_regex()
00751       : _M_flags(regex_constants::ECMAScript), _M_pattern(), _M_mark_count(0)
00752       { _M_compile(); }
00753 
00754       /**
00755        * @brief Constructs a basic regular expression from the sequence
00756        * [p, p + char_traits<_Ch_type>::length(p)) interpreted according to the
00757        * flags in @p f.
00758        *
00759        * @param p A pointer to the start of a C-style null-terminated string
00760        *          containing a regular expression.
00761        * @param f Flags indicating the syntax rules and options.
00762        *
00763        * @throws regex_error if @p p is not a valid regular expression.
00764        */
00765       explicit
00766       basic_regex(const _Ch_type* __p,
00767           flag_type __f = regex_constants::ECMAScript)
00768       : _M_flags(__f), _M_pattern(__p), _M_mark_count(0)
00769       { _M_compile(); }
00770 
00771       /**
00772        * @brief Constructs a basic regular expression from the sequence
00773        * [p, p + len) interpreted according to the flags in @p f.
00774        *
00775        * @param p   A pointer to the start of a string containing a regular
00776        *            expression.
00777        * @param len The length of the string containing the regular expression.
00778        * @param f   Flags indicating the syntax rules and options.
00779        *
00780        * @throws regex_error if @p p is not a valid regular expression.
00781        */
00782       basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f)
00783       : _M_flags(__f) , _M_pattern(__p, __len), _M_mark_count(0)
00784       { _M_compile(); }
00785 
00786       /**
00787        * @brief Copy-constructs a basic regular expression.
00788        *
00789        * @param rhs A @p regex object.
00790      */
00791       basic_regex(const basic_regex& __rhs)
00792       : _M_flags(__rhs._M_flags), _M_pattern(__rhs._M_pattern),
00793     _M_mark_count(__rhs._M_mark_count)
00794       { _M_compile(); }
00795 
00796       /**
00797        * @brief Constructs a basic regular expression from the string
00798        * @p s interpreted according to the flags in @p f.
00799        *
00800        * @param s A string containing a regular expression.
00801        * @param f Flags indicating the syntax rules and options.
00802        *
00803        * @throws regex_error if @p s is not a valid regular expression.
00804        */
00805       template<typename _Ch_traits, typename _Ch_alloc>
00806         explicit
00807         basic_regex(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
00808             flag_type __f = regex_constants::ECMAScript)
00809     : _M_flags(__f), _M_pattern(__s.begin(), __s.end()), _M_mark_count(0)
00810         { _M_compile(); }
00811 
00812       /**
00813        * @brief Constructs a basic regular expression from the range
00814        * [first, last) interpreted according to the flags in @p f.
00815        *
00816        * @param first The start of a range containing a valid regular
00817        *              expression.
00818        * @param last  The end of a range containing a valid regular
00819        *              expression.
00820        * @param f     The format flags of the regular expression.
00821        *
00822        * @throws regex_error if @p [first, last) is not a valid regular
00823        *         expression.
00824        */
00825       template<typename _InputIterator>
00826         basic_regex(_InputIterator __first, _InputIterator __last, 
00827             flag_type __f = regex_constants::ECMAScript)
00828     : _M_flags(__f), _M_pattern(__first, __last), _M_mark_count(0)
00829         { _M_compile(); }
00830 
00831 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00832       /**
00833        * @brief Constructs a basic regular expression from an initializer list.
00834        *
00835        * @param l  The initializer list.
00836        * @param f  The format flags of the regular expression.
00837        *
00838        * @throws regex_error if @p l is not a valid regular expression.
00839        */
00840       basic_regex(initializer_list<_Ch_type> __l,
00841           flag_type __f = regex_constants::ECMAScript)
00842     : _M_flags(__f), _M_pattern(__l.begin(), __l.end()), _M_mark_count(0)
00843         { _M_compile(); }
00844 #endif
00845 
00846       /**
00847        * @brief Destroys a basic regular expression.
00848        */
00849       ~basic_regex()
00850       { }
00851       
00852       /**
00853        * @brief Assigns one regular expression to another.
00854        */
00855       basic_regex&
00856       operator=(const basic_regex& __rhs)
00857       { return this->assign(__rhs); }
00858 
00859       /**
00860        * @brief Replaces a regular expression with a new one constructed from
00861        * a C-style null-terminated string.
00862        *
00863        * @param A pointer to the start of a null-terminated C-style string
00864        *        containing a regular expression.
00865        */
00866       basic_regex&
00867       operator=(const _Ch_type* __p)
00868       { return this->assign(__p, flags()); }
00869       
00870       /**
00871        * @brief Replaces a regular expression with a new one constructed from
00872        * a string.
00873        *
00874        * @param A pointer to a string containing a regular expression.
00875        */
00876       template<typename _Ch_typeraits, typename _Allocator>
00877         basic_regex&
00878         operator=(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s)
00879         { return this->assign(__s, flags()); }
00880 
00881       // [7.8.3] assign
00882       /**
00883        * @brief the real assignment operator.
00884        *
00885        * @param that Another regular expression object.
00886        */
00887       basic_regex&
00888       assign(const basic_regex& __that)
00889       {
00890     basic_regex __tmp(__that);
00891     this->swap(__tmp);
00892     return *this;
00893       }
00894       
00895       /**
00896        * @brief Assigns a new regular expression to a regex object from a
00897        * C-style null-terminated string containing a regular expression
00898        * pattern.
00899        *
00900        * @param p     A pointer to a C-style null-terminated string containing
00901        *              a regular expression pattern.
00902        * @param flags Syntax option flags.
00903        *
00904        * @throws regex_error if p does not contain a valid regular expression
00905        * pattern interpreted according to @p flags.  If regex_error is thrown,
00906        * *this remains unchanged.
00907        */
00908       basic_regex&
00909       assign(const _Ch_type* __p,
00910          flag_type __flags = regex_constants::ECMAScript)
00911       { return this->assign(string_type(__p), __flags); }
00912 
00913       /**
00914        * @brief Assigns a new regular expression to a regex object from a
00915        * C-style string containing a regular expression pattern.
00916        *
00917        * @param p     A pointer to a C-style string containing a
00918        *              regular expression pattern.
00919        * @param len   The length of the regular expression pattern string.
00920        * @param flags Syntax option flags.
00921        *
00922        * @throws regex_error if p does not contain a valid regular expression
00923        * pattern interpreted according to @p flags.  If regex_error is thrown,
00924        * *this remains unchanged.
00925        */
00926       basic_regex&
00927       assign(const _Ch_type* __p, std::size_t __len, flag_type __flags)
00928       { return this->assign(string_type(__p, __len), __flags); }
00929 
00930       /**
00931        * @brief Assigns a new regular expression to a regex object from a 
00932        * string containing a regular expression pattern.
00933        *
00934        * @param s     A string containing a regular expression pattern.
00935        * @param flags Syntax option flags.
00936        *
00937        * @throws regex_error if p does not contain a valid regular expression
00938        * pattern interpreted according to @p flags.  If regex_error is thrown,
00939        * *this remains unchanged.
00940        */
00941       template<typename _Ch_typeraits, typename _Allocator>
00942         basic_regex&
00943         assign(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s,
00944            flag_type __f = regex_constants::ECMAScript)
00945         { 
00946       basic_regex __tmp(__s, __f);
00947       this->swap(__tmp);
00948       return *this;
00949     }
00950 
00951       /**
00952        * @brief Assigns a new regular expression to a regex object.
00953        *
00954        * @param first The start of a range containing a valid regular
00955        *              expression.
00956        * @param last  The end of a range containing a valid regular
00957        *              expression.
00958        * @param flags Syntax option flags.
00959        *
00960        * @throws regex_error if p does not contain a valid regular expression
00961        * pattern interpreted according to @p flags.  If regex_error is thrown,
00962        * the object remains unchanged.
00963        */
00964       template<typename _InputIterator>
00965         basic_regex&
00966         assign(_InputIterator __first, _InputIterator __last,
00967            flag_type __flags = regex_constants::ECMAScript)
00968         { return this->assign(string_type(__first, __last), __flags); }
00969 
00970 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00971       /**
00972        * @brief Assigns a new regular expression to a regex object.
00973        *
00974        * @param l     An initializer list representing a regular expression.
00975        * @param flags Syntax option flags.
00976        *
00977        * @throws regex_error if @p l does not contain a valid regular
00978        * expression pattern interpreted according to @p flags.  If regex_error
00979        * is thrown, the object remains unchanged.
00980        */
00981       basic_regex&
00982       assign(initializer_list<_Ch_type> __l,
00983          flag_type __f = regex_constants::ECMAScript)
00984       { return this->assign(__l.begin(), __l.end(), __f); }
00985 #endif
00986 
00987       // [7.8.4] const operations
00988       /**
00989        * @brief Gets the number of marked subexpressions within the regular
00990        * expression.
00991        */
00992       unsigned int
00993       mark_count() const
00994       { return _M_mark_count; }
00995       
00996       /**
00997        * @brief Gets the flags used to construct the regular expression
00998        * or in the last call to assign().
00999        */
01000       flag_type
01001       flags() const
01002       { return _M_flags; }
01003       
01004       // [7.8.5] locale
01005       /**
01006        * @brief Imbues the regular expression object with the given locale.
01007        *
01008        * @param loc A locale.
01009        */
01010       locale_type
01011       imbue(locale_type __loc)
01012       { return _M_traits.imbue(__loc); }
01013       
01014       /**
01015        * @brief Gets the locale currently imbued in the regular expression
01016        *        object.
01017        */
01018       locale_type
01019       getloc() const
01020       { return _M_traits.getloc(); }
01021       
01022       // [7.8.6] swap
01023       /**
01024        * @brief Swaps the contents of two regular expression objects.
01025        *
01026        * @param rhs Another regular expression object.
01027        */
01028       void
01029       swap(basic_regex& __rhs)
01030       {
01031     std::swap(_M_flags,      __rhs._M_flags);
01032     std::swap(_M_pattern,    __rhs._M_pattern);
01033     std::swap(_M_mark_count, __rhs._M_mark_count);
01034     std::swap(_M_traits,     __rhs._M_traits);
01035       }
01036       
01037     private:
01038       /**
01039        * @brief Compiles a regular expression pattern into a NFA.
01040        * @todo Implement this function.
01041        */
01042       void _M_compile();
01043 
01044     protected:
01045       flag_type    _M_flags;
01046       string_type  _M_pattern;
01047       unsigned int _M_mark_count;
01048       _Rx_traits   _M_traits;
01049     };
01050   
01051   /** @brief Standard regular expressions. */
01052   typedef basic_regex<char>    regex;
01053 #ifdef _GLIBCXX_USE_WCHAR_T
01054   /** @brief Standard wide-character regular expressions. */
01055   typedef basic_regex<wchar_t> wregex;
01056 #endif
01057 
01058 
01059   // [7.8.6] basic_regex swap
01060   /**
01061    * @brief Swaps the contents of two regular expression objects.
01062    * @param lhs First regular expression.
01063    * @param rhs Second regular expression.
01064    */
01065   template<typename _Ch_type, typename _Rx_traits>
01066     inline void
01067     swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
01068      basic_regex<_Ch_type, _Rx_traits>& __rhs)
01069     { __lhs.swap(__rhs); }
01070 
01071 
01072   // [7.9] Class template sub_match
01073   /**
01074    * A sequence of characters matched by a particular marked sub-expression.
01075    *
01076    * An object of this class is essentially a pair of iterators marking a
01077    * matched subexpression within a regular expression pattern match. Such
01078    * objects can be converted to and compared with std::basic_string objects
01079    * of a similar base character type as the pattern matched by the regular
01080    * expression.
01081    *
01082    * The iterators that make up the pair are the usual half-open interval
01083    * referencing the actual original pattern matched.
01084    */
01085   template<typename _BiIter>
01086     class sub_match : public std::pair<_BiIter, _BiIter>
01087     {
01088     public:
01089       typedef typename iterator_traits<_BiIter>::value_type      value_type;
01090       typedef typename iterator_traits<_BiIter>::difference_type
01091                                                             difference_type;
01092       typedef _BiIter                                              iterator;
01093 
01094     public:
01095       bool matched;
01096       
01097       /**
01098        * Gets the length of the matching sequence.
01099        */
01100       difference_type
01101       length() const
01102       { return this->matched ? std::distance(this->first, this->second) : 0; }
01103 
01104       /**
01105        * @brief Gets the matching sequence as a string.
01106        *
01107        * @returns the matching sequence as a string.
01108        *
01109        * This is the implicit conversion operator.  It is identical to the
01110        * str() member function except that it will want to pop up in
01111        * unexpected places and cause a great deal of confusion and cursing
01112        * from the unwary.
01113        */
01114       operator basic_string<value_type>() const
01115       {
01116     return this->matched
01117       ? std::basic_string<value_type>(this->first, this->second)
01118       : std::basic_string<value_type>();
01119       }
01120       
01121       /**
01122        * @brief Gets the matching sequence as a string.
01123        *
01124        * @returns the matching sequence as a string.
01125        */
01126       basic_string<value_type>
01127       str() const
01128       {
01129     return this->matched
01130       ? std::basic_string<value_type>(this->first, this->second)
01131       : std::basic_string<value_type>();
01132       }
01133       
01134       /**
01135        * @brief Compares this and another matched sequence.
01136        *
01137        * @param s Another matched sequence to compare to this one.
01138        *
01139        * @retval <0 this matched sequence will collate before @p s.
01140        * @retval =0 this matched sequence is equivalent to @p s.
01141        * @retval <0 this matched sequence will collate after @p s.
01142        */
01143       int
01144       compare(const sub_match& __s) const
01145       { return this->str().compare(__s.str()); }
01146 
01147       /**
01148        * @brief Compares this sub_match to a string.
01149        *
01150        * @param s A string to compare to this sub_match.
01151        *
01152        * @retval <0 this matched sequence will collate before @p s.
01153        * @retval =0 this matched sequence is equivalent to @p s.
01154        * @retval <0 this matched sequence will collate after @p s.
01155        */
01156       int
01157       compare(const basic_string<value_type>& __s) const
01158       { return this->str().compare(__s); }
01159       
01160       /**
01161        * @brief Compares this sub_match to a C-style string.
01162        *
01163        * @param s A C-style string to compare to this sub_match.
01164        *
01165        * @retval <0 this matched sequence will collate before @p s.
01166        * @retval =0 this matched sequence is equivalent to @p s.
01167        * @retval <0 this matched sequence will collate after @p s.
01168        */
01169       int
01170       compare(const value_type* __s) const
01171       { return this->str().compare(__s); }
01172     };
01173   
01174   
01175   /** @brief Standard regex submatch over a C-style null-terminated string. */
01176   typedef sub_match<const char*>             csub_match;
01177   /** @brief Standard regex submatch over a standard string. */
01178   typedef sub_match<string::const_iterator>  ssub_match;
01179 #ifdef _GLIBCXX_USE_WCHAR_T
01180   /** @brief Regex submatch over a C-style null-terminated wide string. */
01181   typedef sub_match<const wchar_t*>          wcsub_match;
01182   /** @brief Regex submatch over a standard wide string. */
01183   typedef sub_match<wstring::const_iterator> wssub_match;
01184 #endif
01185 
01186   // [7.9.2] sub_match non-member operators
01187   
01188   /**
01189    * @brief Tests the equivalence of two regular expression submatches.
01190    * @param lhs First regular expression submatch.
01191    * @param rhs Second regular expression submatch.
01192    * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
01193    */
01194   template<typename _BiIter>
01195     inline bool
01196     operator==(const sub_match<_BiIter>& __lhs,
01197            const sub_match<_BiIter>& __rhs)
01198     { return __lhs.compare(__rhs) == 0; }
01199 
01200   /**
01201    * @brief Tests the inequivalence of two regular expression submatches.
01202    * @param lhs First regular expression submatch.
01203    * @param rhs Second regular expression submatch.
01204    * @returns true if @a lhs  is not equivalent to @a rhs, false otherwise.
01205    */
01206   template<typename _BiIter>
01207     inline bool
01208     operator!=(const sub_match<_BiIter>& __lhs,
01209            const sub_match<_BiIter>& __rhs)
01210     { return __lhs.compare(__rhs) != 0; }
01211 
01212   /**
01213    * @brief Tests the ordering of two regular expression submatches.
01214    * @param lhs First regular expression submatch.
01215    * @param rhs Second regular expression submatch.
01216    * @returns true if @a lhs precedes @a rhs, false otherwise.
01217    */
01218   template<typename _BiIter>
01219     inline bool
01220     operator<(const sub_match<_BiIter>& __lhs,
01221           const sub_match<_BiIter>& __rhs)
01222     { return __lhs.compare(__rhs) < 0; }
01223 
01224   /**
01225    * @brief Tests the ordering of two regular expression submatches.
01226    * @param lhs First regular expression submatch.
01227    * @param rhs Second regular expression submatch.
01228    * @returns true if @a lhs does not succeed @a rhs, false otherwise.
01229    */
01230   template<typename _BiIter>
01231     inline bool
01232     operator<=(const sub_match<_BiIter>& __lhs,
01233            const sub_match<_BiIter>& __rhs)
01234     { return __lhs.compare(__rhs) <= 0; }
01235 
01236   /**
01237    * @brief Tests the ordering of two regular expression submatches.
01238    * @param lhs First regular expression submatch.
01239    * @param rhs Second regular expression submatch.
01240    * @returns true if @a lhs does not precede @a rhs, false otherwise.
01241    */
01242   template<typename _BiIter>
01243     inline bool
01244     operator>=(const sub_match<_BiIter>& __lhs,
01245            const sub_match<_BiIter>& __rhs)
01246     { return __lhs.compare(__rhs) >= 0; }
01247 
01248   /**
01249    * @brief Tests the ordering of two regular expression submatches.
01250    * @param lhs First regular expression submatch.
01251    * @param rhs Second regular expression submatch.
01252    * @returns true if @a lhs succeeds @a rhs, false otherwise.
01253    */
01254   template<typename _BiIter>
01255     inline bool
01256     operator>(const sub_match<_BiIter>& __lhs,
01257           const sub_match<_BiIter>& __rhs)
01258     { return __lhs.compare(__rhs) > 0; }
01259 
01260   /**
01261    * @brief Tests the equivalence of a string and a regular expression
01262    *        submatch.
01263    * @param lhs A string.
01264    * @param rhs A regular expression submatch.
01265    * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
01266    */
01267   template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
01268     inline bool
01269     operator==(const basic_string<
01270            typename iterator_traits<_Bi_iter>::value_type,
01271            _Ch_traits, _Ch_alloc>& __lhs,
01272            const sub_match<_Bi_iter>& __rhs)
01273     { return __lhs == __rhs.str(); }
01274 
01275   /**
01276    * @brief Tests the inequivalence of a string and a regular expression
01277    *        submatch.
01278    * @param lhs A string.
01279    * @param rhs A regular expression submatch.
01280    * @returns true if @a lhs  is not equivalent to @a rhs, false otherwise.
01281    */
01282   template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
01283     inline bool
01284     operator!=(const basic_string<
01285            typename iterator_traits<_Bi_iter>::value_type,
01286            _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
01287     { return __lhs != __rhs.str(); }
01288 
01289   /**
01290    * @brief Tests the ordering of a string and a regular expression submatch.
01291    * @param lhs A string.
01292    * @param rhs A regular expression submatch.
01293    * @returns true if @a lhs precedes @a rhs, false otherwise.
01294    */
01295   template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
01296     inline bool
01297     operator<(const basic_string<
01298           typename iterator_traits<_Bi_iter>::value_type,
01299           _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
01300      { return __lhs < __rhs.str(); }
01301 
01302   /**
01303    * @brief Tests the ordering of a string and a regular expression submatch.
01304    * @param lhs A string.
01305    * @param rhs A regular expression submatch.
01306    * @returns true if @a lhs succeeds @a rhs, false otherwise.
01307    */
01308   template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
01309     inline bool
01310     operator>(const basic_string<
01311           typename iterator_traits<_Bi_iter>::value_type, 
01312           _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
01313     { return __lhs > __rhs.str(); }
01314 
01315   /**
01316    * @brief Tests the ordering of a string and a regular expression submatch.
01317    * @param lhs A string.
01318    * @param rhs A regular expression submatch.
01319    * @returns true if @a lhs does not precede @a rhs, false otherwise.
01320    */
01321   template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
01322     inline bool
01323     operator>=(const basic_string<
01324            typename iterator_traits<_Bi_iter>::value_type,
01325            _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
01326     { return __lhs >= __rhs.str(); }
01327 
01328   /**
01329    * @brief Tests the ordering of a string and a regular expression submatch.
01330    * @param lhs A string.
01331    * @param rhs A regular expression submatch.
01332    * @returns true if @a lhs does not succeed @a rhs, false otherwise.
01333    */
01334   template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
01335     inline bool
01336     operator<=(const basic_string<
01337            typename iterator_traits<_Bi_iter>::value_type,
01338            _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
01339     { return __lhs <= __rhs.str(); }
01340 
01341   /**
01342    * @brief Tests the equivalence of a regular expression submatch and a
01343    *        string.
01344    * @param lhs A regular expression submatch.
01345    * @param rhs A string.
01346    * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
01347    */
01348   template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
01349     inline bool
01350     operator==(const sub_match<_Bi_iter>& __lhs,
01351            const basic_string<
01352            typename iterator_traits<_Bi_iter>::value_type,
01353            _Ch_traits, _Ch_alloc>& __rhs)
01354     { return __lhs.str() == __rhs; }
01355 
01356   /**
01357    * @brief Tests the inequivalence of a regular expression submatch and a
01358    *        string.
01359    * @param lhs A regular expression submatch.
01360    * @param rhs A string.
01361    * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
01362    */
01363   template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
01364     inline bool
01365     operator!=(const sub_match<_Bi_iter>& __lhs,
01366            const basic_string<
01367            typename iterator_traits<_Bi_iter>::value_type,
01368            _Ch_traits, _Ch_alloc>& __rhs)
01369     { return __lhs.str() != __rhs; }
01370 
01371   /**
01372    * @brief Tests the ordering of a regular expression submatch and a string.
01373    * @param lhs A regular expression submatch.
01374    * @param rhs A string.
01375    * @returns true if @a lhs precedes @a rhs, false otherwise.
01376    */
01377   template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
01378     inline bool
01379     operator<(const sub_match<_Bi_iter>& __lhs,
01380           const basic_string<
01381           typename iterator_traits<_Bi_iter>::value_type,
01382           _Ch_traits, _Ch_alloc>& __rhs)
01383     { return __lhs.str() < __rhs; }
01384 
01385   /**
01386    * @brief Tests the ordering of a regular expression submatch and a string.
01387    * @param lhs A regular expression submatch.
01388    * @param rhs A string.
01389    * @returns true if @a lhs succeeds @a rhs, false otherwise.
01390    */
01391   template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
01392     inline bool
01393     operator>(const sub_match<_Bi_iter>& __lhs,
01394           const basic_string<
01395           typename iterator_traits<_Bi_iter>::value_type,
01396           _Ch_traits, _Ch_alloc>& __rhs)
01397     { return __lhs.str() > __rhs; }
01398 
01399   /**
01400    * @brief Tests the ordering of a regular expression submatch and a string.
01401    * @param lhs A regular expression submatch.
01402    * @param rhs A string.
01403    * @returns true if @a lhs does not precede @a rhs, false otherwise.
01404    */
01405   template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
01406     inline bool
01407     operator>=(const sub_match<_Bi_iter>& __lhs,
01408            const basic_string<
01409            typename iterator_traits<_Bi_iter>::value_type,
01410            _Ch_traits, _Ch_alloc>& __rhs)
01411     { return __lhs.str() >= __rhs; }
01412 
01413   /**
01414    * @brief Tests the ordering of a regular expression submatch and a string.
01415    * @param lhs A regular expression submatch.
01416    * @param rhs A string.
01417    * @returns true if @a lhs does not succeed @a rhs, false otherwise.
01418    */
01419   template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
01420     inline bool
01421     operator<=(const sub_match<_Bi_iter>& __lhs,
01422            const basic_string<
01423            typename iterator_traits<_Bi_iter>::value_type,
01424            _Ch_traits, _Ch_alloc>& __rhs)
01425     { return __lhs.str() <= __rhs; }
01426 
01427   /**
01428    * @brief Tests the equivalence of a C string and a regular expression
01429    *        submatch.
01430    * @param lhs A C string.
01431    * @param rhs A regular expression submatch.
01432    * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
01433    */
01434   template<typename _Bi_iter>
01435     inline bool
01436     operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
01437            const sub_match<_Bi_iter>& __rhs)
01438     { return __lhs == __rhs.str(); }
01439 
01440   /**
01441    * @brief Tests the inequivalence of an iterator value and a regular
01442    *        expression submatch.
01443    * @param lhs A regular expression submatch.
01444    * @param rhs A string.
01445    * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
01446    */
01447   template<typename _Bi_iter>
01448     inline bool
01449     operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
01450            const sub_match<_Bi_iter>& __rhs)
01451     { return __lhs != __rhs.str(); }
01452 
01453   /**
01454    * @brief Tests the ordering of a string and a regular expression submatch.
01455    * @param lhs A string.
01456    * @param rhs A regular expression submatch.
01457    * @returns true if @a lhs precedes @a rhs, false otherwise.
01458    */
01459   template<typename _Bi_iter>
01460     inline bool
01461     operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
01462           const sub_match<_Bi_iter>& __rhs)
01463     { return __lhs < __rhs.str(); }
01464 
01465   /**
01466    * @brief Tests the ordering of a string and a regular expression submatch.
01467    * @param lhs A string.
01468    * @param rhs A regular expression submatch.
01469    * @returns true if @a lhs succeeds @a rhs, false otherwise.
01470    */
01471   template<typename _Bi_iter>
01472     inline bool
01473     operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
01474           const sub_match<_Bi_iter>& __rhs)
01475     { return __lhs > __rhs.str(); }
01476 
01477   /**
01478    * @brief Tests the ordering of a string and a regular expression submatch.
01479    * @param lhs A string.
01480    * @param rhs A regular expression submatch.
01481    * @returns true if @a lhs does not precede @a rhs, false otherwise.
01482    */
01483   template<typename _Bi_iter>
01484     inline bool
01485     operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
01486            const sub_match<_Bi_iter>& __rhs)
01487     { return __lhs >= __rhs.str(); }
01488 
01489   /**
01490    * @brief Tests the ordering of a string and a regular expression submatch.
01491    * @param lhs A string.
01492    * @param rhs A regular expression submatch.
01493    * @returns true if @a lhs does not succeed @a rhs, false otherwise.
01494    */
01495   template<typename _Bi_iter>
01496     inline bool
01497     operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
01498            const sub_match<_Bi_iter>& __rhs)
01499     { return __lhs <= __rhs.str(); }
01500 
01501   /**
01502    * @brief Tests the equivalence of a regular expression submatch and a
01503    *        string.
01504    * @param lhs A regular expression submatch.
01505    * @param rhs A pointer to a string?
01506    * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
01507    */
01508   template<typename _Bi_iter>
01509     inline bool
01510     operator==(const sub_match<_Bi_iter>& __lhs,
01511            typename iterator_traits<_Bi_iter>::value_type const* __rhs)
01512     { return __lhs.str() == __rhs; }
01513 
01514   /**
01515    * @brief Tests the inequivalence of a regular expression submatch and a
01516    *        string.
01517    * @param lhs A regular expression submatch.
01518    * @param rhs A pointer to a string.
01519    * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
01520    */
01521   template<typename _Bi_iter>
01522     inline bool
01523     operator!=(const sub_match<_Bi_iter>& __lhs,
01524            typename iterator_traits<_Bi_iter>::value_type const* __rhs)
01525     { return __lhs.str() != __rhs; }
01526 
01527   /**
01528    * @brief Tests the ordering of a regular expression submatch and a string.
01529    * @param lhs A regular expression submatch.
01530    * @param rhs A string.
01531    * @returns true if @a lhs precedes @a rhs, false otherwise.
01532    */
01533   template<typename _Bi_iter>
01534     inline bool
01535     operator<(const sub_match<_Bi_iter>& __lhs,
01536           typename iterator_traits<_Bi_iter>::value_type const* __rhs)
01537     { return __lhs.str() < __rhs; }
01538 
01539   /**
01540    * @brief Tests the ordering of a regular expression submatch and a string.
01541    * @param lhs A regular expression submatch.
01542    * @param rhs A string.
01543    * @returns true if @a lhs succeeds @a rhs, false otherwise.
01544    */
01545   template<typename _Bi_iter>
01546     inline bool
01547     operator>(const sub_match<_Bi_iter>& __lhs,
01548           typename iterator_traits<_Bi_iter>::value_type const* __rhs)
01549     { return __lhs.str() > __rhs; }
01550 
01551   /**
01552    * @brief Tests the ordering of a regular expression submatch and a string.
01553    * @param lhs A regular expression submatch.
01554    * @param rhs A string.
01555    * @returns true if @a lhs does not precede @a rhs, false otherwise.
01556    */
01557   template<typename _Bi_iter>
01558     inline bool
01559     operator>=(const sub_match<_Bi_iter>& __lhs,
01560            typename iterator_traits<_Bi_iter>::value_type const* __rhs)
01561     { return __lhs.str() >= __rhs; }
01562 
01563   /**
01564    * @brief Tests the ordering of a regular expression submatch and a string.
01565    * @param lhs A regular expression submatch.
01566    * @param rhs A string.
01567    * @returns true if @a lhs does not succeed @a rhs, false otherwise.
01568    */
01569   template<typename _Bi_iter>
01570     inline bool
01571     operator<=(const sub_match<_Bi_iter>& __lhs,
01572            typename iterator_traits<_Bi_iter>::value_type const* __rhs)
01573     { return __lhs.str() <= __rhs; }
01574 
01575   /**
01576    * @brief Tests the equivalence of a string and a regular expression
01577    *        submatch.
01578    * @param lhs A string.
01579    * @param rhs A regular expression submatch.
01580    * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
01581    */
01582   template<typename _Bi_iter>
01583     inline bool
01584     operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
01585            const sub_match<_Bi_iter>& __rhs)
01586     { return __lhs == __rhs.str(); }
01587 
01588   /**
01589    * @brief Tests the inequivalence of a string and a regular expression
01590    *        submatch.
01591    * @param lhs A string.
01592    * @param rhs A regular expression submatch.
01593    * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
01594    */
01595   template<typename _Bi_iter>
01596     inline bool
01597     operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
01598            const sub_match<_Bi_iter>& __rhs)
01599     { return __lhs != __rhs.str(); }
01600 
01601   /**
01602    * @brief Tests the ordering of a string and a regular expression submatch.
01603    * @param lhs A string.
01604    * @param rhs A regular expression submatch.
01605    * @returns true if @a lhs precedes @a rhs, false otherwise.
01606    */
01607   template<typename _Bi_iter>
01608     inline bool
01609     operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
01610           const sub_match<_Bi_iter>& __rhs)
01611     { return __lhs < __rhs.str(); }
01612 
01613   /**
01614    * @brief Tests the ordering of a string and a regular expression submatch.
01615    * @param lhs A string.
01616    * @param rhs A regular expression submatch.
01617    * @returns true if @a lhs succeeds @a rhs, false otherwise.
01618    */
01619   template<typename _Bi_iter>
01620     inline bool
01621     operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
01622           const sub_match<_Bi_iter>& __rhs)
01623     { return __lhs > __rhs.str(); }
01624 
01625   /**
01626    * @brief Tests the ordering of a string and a regular expression submatch.
01627    * @param lhs A string.
01628    * @param rhs A regular expression submatch.
01629    * @returns true if @a lhs does not precede @a rhs, false otherwise.
01630    */
01631   template<typename _Bi_iter>
01632     inline bool
01633     operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
01634            const sub_match<_Bi_iter>& __rhs)
01635     { return __lhs >= __rhs.str(); }
01636 
01637   /**
01638    * @brief Tests the ordering of a string and a regular expression submatch.
01639    * @param lhs A string.
01640    * @param rhs A regular expression submatch.
01641    * @returns true if @a lhs does not succeed @a rhs, false otherwise.
01642    */
01643   template<typename _Bi_iter>
01644     inline bool
01645     operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
01646            const sub_match<_Bi_iter>& __rhs)
01647     { return __lhs <= __rhs.str(); }
01648 
01649   /**
01650    * @brief Tests the equivalence of a regular expression submatch and a
01651    *        string.
01652    * @param lhs A regular expression submatch.
01653    * @param rhs A const string reference.
01654    * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
01655    */
01656   template<typename _Bi_iter>
01657     inline bool
01658     operator==(const sub_match<_Bi_iter>& __lhs,
01659            typename iterator_traits<_Bi_iter>::value_type const& __rhs)
01660     { return __lhs.str() == __rhs; }
01661 
01662   /**
01663    * @brief Tests the inequivalence of a regular expression submatch and a
01664    *        string.
01665    * @param lhs A regular expression submatch.
01666    * @param rhs A const string reference.
01667    * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
01668    */
01669   template<typename _Bi_iter>
01670     inline bool
01671     operator!=(const sub_match<_Bi_iter>& __lhs,
01672            typename iterator_traits<_Bi_iter>::value_type const& __rhs)
01673     { return __lhs.str() != __rhs; }
01674 
01675   /**
01676    * @brief Tests the ordering of a regular expression submatch and a string.
01677    * @param lhs A regular expression submatch.
01678    * @param rhs A const string reference.
01679    * @returns true if @a lhs precedes @a rhs, false otherwise.
01680    */
01681   template<typename _Bi_iter>
01682     inline bool
01683     operator<(const sub_match<_Bi_iter>& __lhs,
01684           typename iterator_traits<_Bi_iter>::value_type const& __rhs)
01685     { return __lhs.str() < __rhs; }
01686 
01687   /**
01688    * @brief Tests the ordering of a regular expression submatch and a string.
01689    * @param lhs A regular expression submatch.
01690    * @param rhs A const string reference.
01691    * @returns true if @a lhs succeeds @a rhs, false otherwise.
01692    */
01693   template<typename _Bi_iter>
01694     inline bool
01695     operator>(const sub_match<_Bi_iter>& __lhs,
01696           typename iterator_traits<_Bi_iter>::value_type const& __rhs)
01697     { return __lhs.str() > __rhs; }
01698 
01699   /**
01700    * @brief Tests the ordering of a regular expression submatch and a string.
01701    * @param lhs A regular expression submatch.
01702    * @param rhs A const string reference.
01703    * @returns true if @a lhs does not precede @a rhs, false otherwise.
01704    */
01705   template<typename _Bi_iter>
01706     inline bool
01707     operator>=(const sub_match<_Bi_iter>& __lhs,
01708            typename iterator_traits<_Bi_iter>::value_type const& __rhs)
01709     { return __lhs.str() >= __rhs; }
01710 
01711   /**
01712    * @brief Tests the ordering of a regular expression submatch and a string.
01713    * @param lhs A regular expression submatch.
01714    * @param rhs A const string reference.
01715    * @returns true if @a lhs does not succeed @a rhs, false otherwise.
01716    */
01717   template<typename _Bi_iter>
01718     inline bool
01719     operator<=(const sub_match<_Bi_iter>& __lhs,
01720            typename iterator_traits<_Bi_iter>::value_type const& __rhs)
01721     { return __lhs.str() <= __rhs; }
01722 
01723   /**
01724    * @brief Inserts a matched string into an output stream.
01725    *
01726    * @param os The output stream.
01727    * @param m  A submatch string.
01728    *
01729    * @returns the output stream with the submatch string inserted.
01730    */
01731   template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
01732     inline
01733     basic_ostream<_Ch_type, _Ch_traits>&
01734     operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
01735            const sub_match<_Bi_iter>& __m)
01736     { return __os << __m.str(); }
01737 
01738   // [7.10] Class template match_results
01739   /**
01740    * @brief The results of a match or search operation.
01741    *
01742    * A collection of character sequences representing the result of a regular
01743    * expression match.  Storage for the collection is allocated and freed as
01744    * necessary by the member functions of class template match_results.
01745    *
01746    * This class satisfies the Sequence requirements, with the exception that
01747    * only the operations defined for a const-qualified Sequence are supported.
01748    *
01749    * The sub_match object stored at index 0 represents sub-expression 0, i.e.
01750    * the whole match. In this case the sub_match member matched is always true.
01751    * The sub_match object stored at index n denotes what matched the marked
01752    * sub-expression n within the matched expression. If the sub-expression n
01753    * participated in a regular expression match then the sub_match member
01754    * matched evaluates to true, and members first and second denote the range
01755    * of characters [first, second) which formed that match. Otherwise matched
01756    * is false, and members first and second point to the end of the sequence
01757    * that was searched.
01758    *
01759    * @nosubgrouping
01760    */
01761   template<typename _Bi_iter,
01762        typename _Allocator = allocator<sub_match<_Bi_iter> > >
01763     class match_results
01764     : private std::vector<std::_GLIBCXX_TR1 sub_match<_Bi_iter>, _Allocator>
01765     {
01766     private:
01767       typedef std::vector<std::_GLIBCXX_TR1 sub_match<_Bi_iter>, _Allocator>
01768                                                               _Base_type;
01769 
01770     public:
01771       /**
01772        * @name 10.? Public Types
01773        */
01774       //@{
01775       typedef sub_match<_Bi_iter>                             value_type;
01776       typedef typename _Allocator::const_reference            const_reference;
01777       typedef const_reference                                 reference;
01778       typedef typename _Base_type::const_iterator             const_iterator;
01779       typedef const_iterator                                  iterator;
01780       typedef typename iterator_traits<_Bi_iter>::difference_type
01781                                                               difference_type;
01782       typedef typename _Allocator::size_type                  size_type;
01783       typedef _Allocator                                      allocator_type;
01784       typedef typename iterator_traits<_Bi_iter>::value_type  char_type;
01785       typedef basic_string<char_type>                         string_type;
01786       //@}
01787   
01788     public:
01789       /**
01790        * @name 10.1 Construction, Copying, and Destruction
01791        */
01792       //@{
01793 
01794       /**
01795        * @brief Constructs a default %match_results container.
01796        * @post size() returns 0 and str() returns an empty string.
01797        */
01798       explicit
01799       match_results(const _Allocator& __a = _Allocator())
01800       : _Base_type(__a), _M_matched(false)
01801       { }
01802 
01803       /**
01804        * @brief Copy constructs a %match_results.
01805        */
01806       match_results(const match_results& __rhs)
01807       : _Base_type(__rhs), _M_matched(__rhs._M_matched),
01808     _M_prefix(__rhs._M_prefix), _M_suffix(__rhs._M_suffix)
01809       { }
01810 
01811       /**
01812        * @brief Assigns rhs to *this.
01813        */
01814       match_results&
01815       operator=(const match_results& __rhs)
01816       {
01817     match_results __tmp(__rhs);
01818     this->swap(__tmp);
01819     return *this;
01820       }
01821 
01822       /**
01823        * @brief Destroys a %match_results object.
01824        */
01825       ~match_results()
01826       { }
01827       
01828       //@}
01829 
01830       /**
01831        * @name 10.2 Size
01832        */
01833       //@{
01834 
01835       /**
01836        * @brief Gets the number of matches and submatches.
01837        *
01838        * The number of matches for a given regular expression will be either 0
01839        * if there was no match or mark_count() + 1 if a match was successful.
01840        * Some matches may be empty.
01841        *
01842        * @returns the number of matches found.
01843        */
01844       size_type
01845       size() const
01846       { return _M_matched ? _Base_type::size() + 1 : 0; }
01847       
01848       //size_type
01849       //max_size() const;
01850       using _Base_type::max_size;
01851 
01852       /**
01853        * @brief Indicates if the %match_results contains no results.
01854        * @retval true The %match_results object is empty.
01855        * @retval false The %match_results object is not empty.
01856        */
01857       bool
01858       empty() const
01859       { return size() == 0; }
01860       
01861       //@}
01862 
01863       /**
01864        * @name 10.3 Element Access
01865        */
01866       //@{
01867 
01868       /**
01869        * @brief Gets the length of the indicated submatch.
01870        * @param sub indicates the submatch.
01871        *
01872        * This function returns the length of the indicated submatch, or the
01873        * length of the entire match if @p sub is zero (the default).
01874        */
01875       difference_type
01876       length(size_type __sub = 0) const
01877       { return _M_matched ? this->str(__sub).length() : 0; }
01878 
01879       /**
01880        * @brief Gets the offset of the beginning of the indicated submatch.
01881        * @param sub indicates the submatch.
01882        *
01883        * This function returns the offset from the beginning of the target
01884        * sequence to the beginning of the submatch, unless the value of @p sub
01885        * is zero (the default), in which case this function returns the offset
01886        * from the beginning of the target sequence to the beginning of the
01887        * match.
01888        */
01889       difference_type
01890       position(size_type __sub = 0) const
01891       {
01892     return _M_matched ? std::distance(this->prefix().first,
01893                       (*this)[__sub].first) : 0;
01894       }
01895 
01896       /**
01897        * @brief Gets the match or submatch converted to a string type.
01898        * @param sub indicates the submatch.
01899        *
01900        * This function gets the submatch (or match, if @p sub is zero) extracted
01901        * from the target range and converted to the associated string type.
01902        */
01903       string_type
01904       str(size_type __sub = 0) const
01905       { return _M_matched ? (*this)[__sub].str() : string_type(); }
01906       
01907       /**
01908        * @brief Gets a %sub_match reference for the match or submatch.
01909        * @param sub indicates the submatch.
01910        *
01911        * This function gets a reference to the indicated submatch, or the entire
01912        * match if @p sub is zero.
01913        *
01914        * If @p sub >= size() then this function returns a %sub_match with a
01915        * special value indicating no submatch.
01916        */
01917       const_reference
01918       operator[](size_type __sub) const
01919       { return _Base_type::operator[](__sub); }
01920 
01921       /**
01922        * @brief Gets a %sub_match representing the match prefix.
01923        *
01924        * This function gets a reference to a %sub_match object representing the
01925        * part of the target range between the start of the target range and the
01926        * start of the match.
01927        */
01928       const_reference
01929       prefix() const
01930       { return _M_prefix; }
01931 
01932       /**
01933        * @brief Gets a %sub_match representing the match suffix.
01934        *
01935        * This function gets a reference to a %sub_match object representing the
01936        * part of the target range between the end of the match and the end of
01937        * the target range.
01938        */
01939       const_reference
01940       suffix() const
01941       { return _M_suffix; }
01942 
01943       /**
01944        * @brief Gets an iterator to the start of the %sub_match collection.
01945        */
01946       const_iterator
01947       begin() const
01948       { return _Base_type::begin(); }
01949       
01950 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
01951       /**
01952        * @brief Gets an iterator to the start of the %sub_match collection.
01953        */
01954       const_iterator
01955       cbegin() const
01956       { return _Base_type::begin(); }
01957 #endif
01958 
01959       /**
01960        * @brief Gets an iterator to one-past-the-end of the collection.
01961        */
01962       const_iterator
01963       end() const
01964       { return _Base_type::end(); }
01965       
01966 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
01967       /**
01968        * @brief Gets an iterator to one-past-the-end of the collection.
01969        */
01970       const_iterator
01971       cend() const
01972       { return _Base_type::end(); }
01973 #endif
01974 
01975       //@}
01976 
01977       /**
01978        * @name 10.4 Formatting
01979        *
01980        * These functions perform formatted substitution of the matched character
01981        * sequences into their target.  The format specifiers and escape sequences
01982        * accepted by these functions are determined by their @p flags parameter 
01983        * as documented above.
01984        */
01985        //@{
01986 
01987       /**
01988        * @todo Implement this function.
01989        */
01990       template<typename _Out_iter>
01991         _Out_iter
01992         format(_Out_iter __out, const string_type& __fmt,
01993            regex_constants::match_flag_type __flags
01994            = regex_constants::format_default) const;
01995 
01996       /**
01997        * @todo Implement this function.
01998        */
01999       string_type
02000       format(const string_type& __fmt,
02001          regex_constants::match_flag_type __flags
02002          = regex_constants::format_default) const;
02003 
02004       //@} 
02005 
02006       /**
02007        * @name 10.5 Allocator
02008        */
02009       //@{ 
02010 
02011       /**
02012        * @brief Gets a copy of the allocator.
02013        */
02014       //allocator_type
02015       //get_allocator() const;
02016       using _Base_type::get_allocator;
02017       
02018       //@} 
02019 
02020       /**
02021        * @name 10.6 Swap
02022        */
02023        //@{ 
02024 
02025       /**
02026        * @brief Swaps the contents of two match_results.
02027        */
02028       void
02029       swap(match_results& __that)
02030       {
02031     _Base_type::swap(__that);
02032     std::swap(_M_matched, __that._M_matched);
02033     std::swap(_M_prefix,  __that._M_prefix);
02034     std::swap(_M_suffix,  __that._M_suffix);
02035       }
02036       //@} 
02037       
02038     private:
02039       bool       _M_matched;
02040       value_type _M_prefix;
02041       value_type _M_suffix;
02042     };
02043   
02044   typedef match_results<const char*>             cmatch;
02045   typedef match_results<string::const_iterator>  smatch;
02046 #ifdef _GLIBCXX_USE_WCHAR_T
02047   typedef match_results<const wchar_t*>          wcmatch;
02048   typedef match_results<wstring::const_iterator> wsmatch;
02049 #endif
02050 
02051   // match_results comparisons
02052   /**
02053    * @brief Compares two match_results for equality.
02054    * @returns true if the two objects refer to the same match,
02055    * false otherwise.
02056    * @todo Implement this function.
02057    */
02058   template<typename _Bi_iter, typename _Allocator>
02059     inline bool
02060     operator==(const match_results<_Bi_iter, _Allocator>& __m1,
02061            const match_results<_Bi_iter, _Allocator>& __m2);
02062 
02063   /**
02064    * @brief Compares two match_results for inequality.
02065    * @returns true if the two objects do not refer to the same match,
02066    * false otherwise.
02067    */
02068   template<typename _Bi_iter, class _Allocator>
02069     inline bool
02070     operator!=(const match_results<_Bi_iter, _Allocator>& __m1,
02071            const match_results<_Bi_iter, _Allocator>& __m2)
02072     { return !(__m1 == __m2); }
02073 
02074   // [7.10.6] match_results swap
02075   /**
02076    * @brief Swaps two match results.
02077    * @param lhs A match result.
02078    * @param rhs A match result.
02079    *
02080    * The contents of the two match_results objects are swapped.
02081    */
02082   template<typename _Bi_iter, typename _Allocator>
02083     inline void
02084     swap(match_results<_Bi_iter, _Allocator>& __lhs,
02085      match_results<_Bi_iter, _Allocator>& __rhs)
02086     { __lhs.swap(__rhs); }
02087 
02088   // [7.11.2] Function template regex_match
02089   /**
02090    * @name Matching, Searching, and Replacing
02091    */
02092   //@{
02093 
02094   /**
02095    * @brief Determines if there is a match between the regular expression @p e
02096    * and all of the character sequence [first, last).
02097    *
02098    * @param first Beginning of the character sequence to match.
02099    * @param last  One-past-the-end of the character sequence to match.
02100    * @param m     The match results.
02101    * @param re    The regular expression.
02102    * @param flags Controls how the regular expression is matched.
02103    *
02104    * @retval true  A match exists.
02105    * @retval false Otherwise.
02106    *
02107    * @throws an exception of type regex_error.
02108    *
02109    * @todo Implement this function.
02110    */
02111   template<typename _Bi_iter, typename _Allocator,
02112        typename _Ch_type, typename _Rx_traits>
02113     bool
02114     regex_match(_Bi_iter __first, _Bi_iter __last,
02115         match_results<_Bi_iter, _Allocator>& __m,
02116         const basic_regex<_Ch_type, _Rx_traits>& __re,
02117         regex_constants::match_flag_type __flags
02118         = regex_constants::match_default);
02119 
02120   /**
02121    * @brief Indicates if there is a match between the regular expression @p e
02122    * and all of the character sequence [first, last).
02123    *
02124    * @param first Beginning of the character sequence to match.
02125    * @param last  One-past-the-end of the character sequence to match.
02126    * @param re    The regular expression.
02127    * @param flags Controls how the regular expression is matched.
02128    *
02129    * @retval true  A match exists.
02130    * @retval false Otherwise.
02131    *
02132    * @throws an exception of type regex_error.
02133    */
02134   template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
02135     bool
02136     regex_match(_Bi_iter __first, _Bi_iter __last,
02137         const basic_regex<_Ch_type, _Rx_traits>& __re,
02138         regex_constants::match_flag_type __flags
02139         = regex_constants::match_default)
02140     { 
02141       match_results<_Bi_iter> __what;
02142       return regex_match(__first, __last, __what, __re, __flags);
02143     }
02144 
02145   /**
02146    * @brief Determines if there is a match between the regular expression @p e
02147    * and a C-style null-terminated string.
02148    *
02149    * @param s  The C-style null-terminated string to match.
02150    * @param m  The match results.
02151    * @param re The regular expression.
02152    * @param f  Controls how the regular expression is matched.
02153    *
02154    * @retval true  A match exists.
02155    * @retval false Otherwise.
02156    *
02157    * @throws an exception of type regex_error.
02158    */
02159   template<typename _Ch_type, typename _Allocator, typename _Rx_traits>
02160     inline bool
02161     regex_match(const _Ch_type* __s,
02162         match_results<const _Ch_type*, _Allocator>& __m,
02163         const basic_regex<_Ch_type, _Rx_traits>& __re,
02164         regex_constants::match_flag_type __f
02165         = regex_constants::match_default)
02166     { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
02167 
02168   /**
02169    * @brief Determines if there is a match between the regular expression @p e
02170    * and a string.
02171    *
02172    * @param s     The string to match.
02173    * @param m     The match results.
02174    * @param re    The regular expression.
02175    * @param flags Controls how the regular expression is matched.
02176    *
02177    * @retval true  A match exists.
02178    * @retval false Otherwise.
02179    *
02180    * @throws an exception of type regex_error.
02181    */
02182   template<typename _Ch_traits, typename _Ch_alloc,
02183        typename _Allocator, typename _Ch_type, typename _Rx_traits>
02184     inline bool
02185     regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
02186         match_results<typename basic_string<_Ch_type, 
02187         _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
02188         const basic_regex<_Ch_type, _Rx_traits>& __re,
02189         regex_constants::match_flag_type __flags
02190         = regex_constants::match_default)
02191     { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
02192 
02193   /**
02194    * @brief Indicates if there is a match between the regular expression @p e
02195    * and a C-style null-terminated string.
02196    *
02197    * @param s  The C-style null-terminated string to match.
02198    * @param re The regular expression.
02199    * @param f  Controls how the regular expression is matched.
02200    *
02201    * @retval true  A match exists.
02202    * @retval false Otherwise.
02203    *
02204    * @throws an exception of type regex_error.
02205    */
02206   template<typename _Ch_type, class _Rx_traits>
02207     inline bool
02208     regex_match(const _Ch_type* __s,
02209         const basic_regex<_Ch_type, _Rx_traits>& __re,
02210         regex_constants::match_flag_type __f
02211         = regex_constants::match_default)
02212     { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
02213 
02214   /**
02215    * @brief Indicates if there is a match between the regular expression @p e
02216    * and a string.
02217    *
02218    * @param s     [IN] The string to match.
02219    * @param re    [IN] The regular expression.
02220    * @param flags [IN] Controls how the regular expression is matched.
02221    *
02222    * @retval true  A match exists.
02223    * @retval false Otherwise.
02224    *
02225    * @throws an exception of type regex_error.
02226    */
02227   template<typename _Ch_traits, typename _Str_allocator,
02228        typename _Ch_type, typename _Rx_traits>
02229     inline bool
02230     regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
02231         const basic_regex<_Ch_type, _Rx_traits>& __re,
02232         regex_constants::match_flag_type __flags
02233         = regex_constants::match_default)
02234     { return regex_match(__s.begin(), __s.end(), __re, __flags); }
02235 
02236   // [7.11.3] Function template regex_search
02237   /**
02238    * Searches for a regular expression within a range.
02239    * @param first [IN]  The start of the string to search.
02240    * @param last  [IN]  One-past-the-end of the string to search.
02241    * @param m     [OUT] The match results.
02242    * @param re    [IN]  The regular expression to search for.
02243    * @param flags [IN]  Search policy flags.
02244    * @retval true  A match was found within the string.
02245    * @retval false No match was found within the string, the content of %m is
02246    *               undefined.
02247    *
02248    * @throws an exception of type regex_error.
02249    *
02250    * @todo Implement this function.
02251    */
02252   template<typename _Bi_iter, typename _Allocator,
02253        typename _Ch_type, typename _Rx_traits>
02254     inline bool
02255     regex_search(_Bi_iter __first, _Bi_iter __last,
02256          match_results<_Bi_iter, _Allocator>& __m,
02257          const basic_regex<_Ch_type, _Rx_traits>& __re,
02258          regex_constants::match_flag_type __flags
02259          = regex_constants::match_default);
02260 
02261   /**
02262    * Searches for a regular expression within a range.
02263    * @param first [IN]  The start of the string to search.
02264    * @param last  [IN]  One-past-the-end of the string to search.
02265    * @param re    [IN]  The regular expression to search for.
02266    * @param flags [IN]  Search policy flags.
02267    * @retval true  A match was found within the string.
02268    * @retval false No match was found within the string.
02269    * @doctodo
02270    *
02271    * @throws an exception of type regex_error.
02272    */
02273   template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
02274     inline bool
02275     regex_search(_Bi_iter __first, _Bi_iter __last,
02276          const basic_regex<_Ch_type, _Rx_traits>& __re,
02277          regex_constants::match_flag_type __flags
02278          = regex_constants::match_default)
02279     {
02280       match_results<_Bi_iter> __what;
02281       return regex_search(__first, __last, __what, __re, __flags);
02282     }
02283 
02284   /**
02285    * @brief Searches for a regular expression within a C-string.
02286    * @param s [IN]  A C-string to search for the regex.
02287    * @param m [OUT] The set of regex matches.
02288    * @param e [IN]  The regex to search for in @p s.
02289    * @param f [IN]  The search flags.
02290    * @retval true  A match was found within the string.
02291    * @retval false No match was found within the string, the content of %m is
02292    *               undefined.
02293    * @doctodo
02294    *
02295    * @throws an exception of type regex_error.
02296    */
02297   template<typename _Ch_type, class _Allocator, class _Rx_traits>
02298     inline bool
02299     regex_search(const _Ch_type* __s,
02300          match_results<const _Ch_type*, _Allocator>& __m,
02301          const basic_regex<_Ch_type, _Rx_traits>& __e,
02302          regex_constants::match_flag_type __f
02303          = regex_constants::match_default)
02304     { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
02305 
02306   /**
02307    * @brief Searches for a regular expression within a C-string.
02308    * @param s [IN]  The C-string to search.
02309    * @param e [IN]  The regular expression to search for.
02310    * @param f [IN]  Search policy flags.
02311    * @retval true  A match was found within the string.
02312    * @retval false No match was found within the string.
02313    * @doctodo
02314    *
02315    * @throws an exception of type regex_error.
02316    */
02317   template<typename _Ch_type, typename _Rx_traits>
02318     inline bool
02319     regex_search(const _Ch_type* __s,
02320          const basic_regex<_Ch_type, _Rx_traits>& __e,
02321          regex_constants::match_flag_type __f
02322          = regex_constants::match_default)
02323     { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
02324 
02325   /**
02326    * @brief Searches for a regular expression within a string.
02327    * @param s     [IN]  The string to search.
02328    * @param e     [IN]  The regular expression to search for.
02329    * @param flags [IN]  Search policy flags.
02330    * @retval true  A match was found within the string.
02331    * @retval false No match was found within the string.
02332    * @doctodo
02333    *
02334    * @throws an exception of type regex_error.
02335    */
02336   template<typename _Ch_traits, typename _String_allocator,
02337        typename _Ch_type, typename _Rx_traits>
02338     inline bool
02339     regex_search(const basic_string<_Ch_type, _Ch_traits,
02340          _String_allocator>& __s,
02341          const basic_regex<_Ch_type, _Rx_traits>& __e,
02342          regex_constants::match_flag_type __flags
02343          = regex_constants::match_default)
02344     { return regex_search(__s.begin(), __s.end(), __e, __flags); }
02345 
02346   /**
02347    * @brief Searches for a regular expression within a string.
02348    * @param s [IN]  A C++ string to search for the regex.
02349    * @param m [OUT] The set of regex matches.
02350    * @param e [IN]  The regex to search for in @p s.
02351    * @param f [IN]  The search flags.
02352    * @retval true  A match was found within the string.
02353    * @retval false No match was found within the string, the content of %m is
02354    *               undefined.
02355    *
02356    * @throws an exception of type regex_error.
02357    */
02358   template<typename _Ch_traits, typename _Ch_alloc,
02359        typename _Allocator, typename _Ch_type,
02360        typename _Rx_traits>
02361     inline bool
02362     regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
02363          match_results<typename basic_string<_Ch_type,
02364          _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
02365          const basic_regex<_Ch_type, _Rx_traits>& __e,
02366          regex_constants::match_flag_type __f
02367          = regex_constants::match_default)
02368     { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
02369 
02370   // tr1 [7.11.4] std [28.11.4] Function template regex_replace
02371   /**
02372    * @doctodo
02373    * @param out
02374    * @param first
02375    * @param last
02376    * @param e
02377    * @param fmt
02378    * @param flags
02379    *
02380    * @returns out
02381    * @throws an exception of type regex_error.
02382    *
02383    * @todo Implement this function.
02384    */
02385   template<typename _Out_iter, typename _Bi_iter,
02386        typename _Rx_traits, typename _Ch_type>
02387     inline _Out_iter
02388     regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
02389           const basic_regex<_Ch_type, _Rx_traits>& __e,
02390           const basic_string<_Ch_type>& __fmt,
02391           regex_constants::match_flag_type __flags
02392           = regex_constants::match_default);
02393 
02394   /**
02395    * @doctodo
02396    * @param s
02397    * @param e
02398    * @param fmt
02399    * @param flags
02400    *
02401    * @returns a copy of string @p s with replacements.
02402    *
02403    * @throws an exception of type regex_error.
02404    */
02405   template<typename _Rx_traits, typename _Ch_type>
02406     inline basic_string<_Ch_type>
02407     regex_replace(const basic_string<_Ch_type>& __s,
02408           const basic_regex<_Ch_type, _Rx_traits>& __e,
02409           const basic_string<_Ch_type>& __fmt,
02410           regex_constants::match_flag_type __flags
02411           = regex_constants::match_default)
02412     {
02413       std::string __result;
02414       regex_replace(std::back_inserter(__result),
02415             __s.begin(), __s.end(), __e, __fmt, __flags);
02416       return __result;
02417     }
02418 
02419   //@}
02420 
02421   // tr1 [7.12.1] std [28.12] Class template regex_iterator
02422   /**
02423    * An iterator adaptor that will provide repeated calls of regex_search over 
02424    * a range until no more matches remain.
02425    */
02426   template<typename _Bi_iter,
02427        typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
02428        typename _Rx_traits = regex_traits<_Ch_type> >
02429     class regex_iterator
02430     {
02431     public:
02432       typedef basic_regex<_Ch_type, _Rx_traits>  regex_type;
02433       typedef match_results<_Bi_iter>            value_type;
02434       typedef std::ptrdiff_t                     difference_type;
02435       typedef const value_type*                  pointer;
02436       typedef const value_type&                  reference;
02437       typedef std::forward_iterator_tag          iterator_category;
02438 
02439     public:
02440       /**
02441        * @brief Provides a singular iterator, useful for indicating
02442        * one-past-the-end of a range.
02443        * @todo Implement this function.
02444        * @doctodo
02445        */
02446       regex_iterator();
02447       
02448       /**
02449        * Constructs a %regex_iterator...
02450        * @param a  [IN] The start of a text range to search.
02451        * @param b  [IN] One-past-the-end of the text range to search.
02452        * @param re [IN] The regular expression to match.
02453        * @param m  [IN] Policy flags for match rules.
02454        * @todo Implement this function.
02455        * @doctodo
02456        */
02457       regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
02458              regex_constants::match_flag_type __m
02459              = regex_constants::match_default);
02460 
02461       /**
02462        * Copy constructs a %regex_iterator.
02463        * @todo Implement this function.
02464        * @doctodo
02465        */
02466       regex_iterator(const regex_iterator& __rhs);
02467       
02468       /**
02469        * @todo Implement this function.
02470        * @doctodo
02471        */
02472       regex_iterator&
02473       operator=(const regex_iterator& __rhs);
02474       
02475       /**
02476        * @todo Implement this function.
02477        * @doctodo
02478        */
02479       bool
02480       operator==(const regex_iterator& __rhs);
02481       
02482       /**
02483        * @todo Implement this function.
02484        * @doctodo
02485        */
02486       bool
02487       operator!=(const regex_iterator& __rhs);
02488       
02489       /**
02490        * @todo Implement this function.
02491        * @doctodo
02492        */
02493       const value_type&
02494       operator*();
02495       
02496       /**
02497        * @todo Implement this function.
02498        * @doctodo
02499        */
02500       const value_type*
02501       operator->();
02502       
02503       /**
02504        * @todo Implement this function.
02505        * @doctodo
02506        */
02507       regex_iterator&
02508       operator++();
02509       
02510       /**
02511        * @todo Implement this function.
02512        * @doctodo
02513        */
02514       regex_iterator
02515       operator++(int);
02516       
02517     private:
02518       // these members are shown for exposition only:
02519       _Bi_iter                         begin;
02520       _Bi_iter                         end;
02521       const regex_type*                pregex;
02522       regex_constants::match_flag_type flags;
02523       match_results<_Bi_iter>          match;
02524     };
02525   
02526   typedef regex_iterator<const char*>             cregex_iterator;
02527   typedef regex_iterator<string::const_iterator>  sregex_iterator;
02528 #ifdef _GLIBCXX_USE_WCHAR_T
02529   typedef regex_iterator<const wchar_t*>          wcregex_iterator;
02530   typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
02531 #endif
02532 
02533   // [7.12.2] Class template regex_token_iterator
02534   /**
02535    * Iterates over submatches in a range (or "splits" a text string).
02536    *
02537    * The purpose of this iterator is to enumerate all, or all specified,
02538    * matches of a regular expression within a text range.  The dereferenced
02539    * value of an iterator of this class is a std::tr1::sub_match object.
02540    */
02541   template<typename _Bi_iter,
02542        typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
02543        typename _Rx_traits = regex_traits<_Ch_type> >
02544     class regex_token_iterator
02545     {
02546     public:
02547       typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
02548       typedef sub_match<_Bi_iter>               value_type;
02549       typedef std::ptrdiff_t                    difference_type;
02550       typedef const value_type*                 pointer;
02551       typedef const value_type&                 reference;
02552       typedef std::forward_iterator_tag         iterator_category;
02553       
02554     public:
02555       /**
02556        * @brief Default constructs a %regex_token_iterator.
02557        * @todo Implement this function.
02558        * 
02559        * A default-constructed %regex_token_iterator is a singular iterator
02560        * that will compare equal to the one-past-the-end value for any
02561        * iterator of the same type.
02562        */
02563       regex_token_iterator();
02564       
02565       /**
02566        * Constructs a %regex_token_iterator...
02567        * @param a          [IN] The start of the text to search.
02568        * @param b          [IN] One-past-the-end of the text to search.
02569        * @param re         [IN] The regular expression to search for.
02570        * @param submatch   [IN] Which submatch to return.  There are some
02571        *                        special values for this parameter:
02572        *                        - -1 each enumerated subexpression does NOT
02573        *                          match the regular expression (aka field
02574        *                          splitting)
02575        *                        - 0 the entire string matching the
02576        *                          subexpression is returned for each match
02577        *                          within the text.
02578        *                        - >0 enumerates only the indicated
02579        *                          subexpression from a match within the text.
02580        * @param m          [IN] Policy flags for match rules.
02581        *
02582        * @todo Implement this function.
02583        * @doctodo
02584        */
02585       regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
02586                int __submatch = 0,
02587                regex_constants::match_flag_type __m
02588                = regex_constants::match_default);
02589 
02590       /**
02591        * Constructs a %regex_token_iterator...
02592        * @param a          [IN] The start of the text to search.
02593        * @param b          [IN] One-past-the-end of the text to search.
02594        * @param re         [IN] The regular expression to search for.
02595        * @param submatches [IN] A list of subexpressions to return for each
02596        *                        regular expression match within the text.
02597        * @param m          [IN] Policy flags for match rules.
02598        *
02599        * @todo Implement this function.
02600        * @doctodo
02601        */
02602       regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
02603                const regex_type& __re,
02604                const std::vector<int>& __submatches,
02605                regex_constants::match_flag_type __m
02606                  = regex_constants::match_default);
02607 
02608       /**
02609        * Constructs a %regex_token_iterator...
02610        * @param a          [IN] The start of the text to search.
02611        * @param b          [IN] One-past-the-end of the text to search.
02612        * @param re         [IN] The regular expression to search for.
02613        * @param submatches [IN] A list of subexpressions to return for each
02614        *                        regular expression match within the text.
02615        * @param m          [IN] Policy flags for match rules.
02616        
02617        * @todo Implement this function.
02618        * @doctodo
02619        */
02620       template<std::size_t _Nm>
02621         regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
02622                  const regex_type& __re,
02623                  const int (&__submatches)[_Nm],
02624                  regex_constants::match_flag_type __m
02625                  = regex_constants::match_default);
02626 
02627       /**
02628        * @brief Copy constructs a %regex_token_iterator.
02629        * @param rhs [IN] A %regex_token_iterator to copy.
02630        * @todo Implement this function.
02631        */
02632       regex_token_iterator(const regex_token_iterator& __rhs);
02633       
02634       /**
02635        * @brief Assigns a %regex_token_iterator to another.
02636        * @param rhs [IN] A %regex_token_iterator to copy.
02637        * @todo Implement this function.
02638        */
02639       regex_token_iterator&
02640       operator=(const regex_token_iterator& __rhs);
02641       
02642       /**
02643        * @brief Compares a %regex_token_iterator to another for equality.
02644        * @todo Implement this function.
02645        */
02646       bool
02647       operator==(const regex_token_iterator& __rhs);
02648       
02649       /**
02650        * @brief Compares a %regex_token_iterator to another for inequality.
02651        * @todo Implement this function.
02652        */
02653       bool
02654       operator!=(const regex_token_iterator& __rhs);
02655       
02656       /**
02657        * @brief Dereferences a %regex_token_iterator.
02658        * @todo Implement this function.
02659        */
02660       const value_type&
02661       operator*();
02662       
02663       /**
02664        * @brief Selects a %regex_token_iterator member.
02665        * @todo Implement this function.
02666        */
02667       const value_type*
02668       operator->();
02669       
02670       /**
02671        * @brief Increments a %regex_token_iterator.
02672        * @todo Implement this function.
02673        */
02674       regex_token_iterator&
02675       operator++();
02676       
02677       /**
02678        * @brief Postincrements a %regex_token_iterator.
02679        * @todo Implement this function.
02680        */
02681       regex_token_iterator
02682       operator++(int);
02683       
02684     private: // data members for exposition only:
02685       typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> position_iterator;
02686 
02687       position_iterator __position;
02688       const value_type* __result;
02689       value_type        __suffix;
02690       std::size_t       __n;
02691       std::vector<int>  __subs;
02692     };
02693 
02694   /** @brief Token iterator for C-style NULL-terminated strings. */
02695   typedef regex_token_iterator<const char*>             cregex_token_iterator;
02696   /** @brief Token iterator for standard strings. */
02697   typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
02698 #ifdef _GLIBCXX_USE_WCHAR_T
02699   /** @brief Token iterator for C-style NULL-terminated wide strings. */
02700   typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
02701   /** @brief Token iterator for standard wide-character strings. */
02702   typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
02703 #endif
02704   
02705   //@} 
02706   
02707 _GLIBCXX_END_NAMESPACE_TR1
02708 }

Generated on Thu Jul 23 21:16:14 2009 for libstdc++ by  doxygen 1.5.8