From 49d723c392eabd41d16185abb822bf58ee467c3d Mon Sep 17 00:00:00 2001 From: paolo Date: Mon, 12 Mar 2007 21:57:51 +0000 Subject: [PATCH] 2007-03-12 Stephen M. Webb * include/tr1/regex: Add "boilerplate" implementations. * testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/ translate_nocase.cc: New. * testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/ ctor.cc: Likewise. * testsuite/tr1/7_regular_expressions/regex_traits/char/ translate_nocase.cc: Likewise. * testsuite/tr1/7_regular_expressions/regex_traits/char/ ctor.cc: Likewise. * testsuite/tr1/7_regular_expressions/regex/cons/char/ c_string_ecma.cc: Likewise. * testsuite/tr1/7_regular_expressions/regex/cons/char/ default.cc: Likewise. * testsuite/tr1/7_regular_expressions/regex/cons/char/ c_string_grep.cc: Likewise. * testsuite/tr1/7_regular_expressions/regex/cons/char/ c_string_extended.cc: Likewise. * testsuite/tr1/7_regular_expressions/regex/cons/char/ c_string_basic.cc: Likewise. * testsuite/tr1/7_regular_expressions/regex/cons/char/ c_string_awk.cc: Likewise. * testsuite/tr1/7_regular_expressions/regex/cons/char/ c_string_egrep.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ range.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ string_op.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ string.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ pstring.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ cstring_op.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ cstring.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ range.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ string_op.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ string.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ pstring.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ cstring_op.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ cstring.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/ range.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/ default.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/ string.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/ pstring.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/ cstring.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/ range.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/ default.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/ string.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/ pstring.cc: Likewise. * testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/ cstring.cc: Likewise. * testsuite/tr1/7_regular_expressions/match_results/ctors/char/ default.cc: Likewise. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@122867 138bc75d-0d04-0410-961f-82ee72b054a4 --- libstdc++-v3/ChangeLog | 72 + libstdc++-v3/include/tr1/regex | 2398 +++++++++++++++++++- .../basic_regex/assign/char/cstring.cc | 43 + .../basic_regex/assign/char/cstring_op.cc | 43 + .../basic_regex/assign/char/pstring.cc | 43 + .../basic_regex/assign/char/range.cc | 43 + .../basic_regex/assign/char/string.cc | 44 + .../basic_regex/assign/char/string_op.cc | 44 + .../basic_regex/assign/wchar_t/cstring.cc | 43 + .../basic_regex/assign/wchar_t/cstring_op.cc | 43 + .../basic_regex/assign/wchar_t/pstring.cc | 43 + .../basic_regex/assign/wchar_t/range.cc | 43 + .../basic_regex/assign/wchar_t/string.cc | 44 + .../basic_regex/assign/wchar_t/string_op.cc | 44 + .../basic_regex/ctors/char/cstring.cc | 42 + .../basic_regex/ctors/char/default.cc | 47 + .../basic_regex/ctors/char/pstring.cc | 42 + .../basic_regex/ctors/char/range.cc | 42 + .../basic_regex/ctors/char/string.cc | 43 + .../basic_regex/ctors/wchar_t/cstring.cc | 42 + .../basic_regex/ctors/wchar_t/default.cc | 47 + .../basic_regex/ctors/wchar_t/pstring.cc | 42 + .../basic_regex/ctors/wchar_t/range.cc | 42 + .../basic_regex/ctors/wchar_t/string.cc | 43 + .../match_results/ctors/char/default.cc | 58 + .../regex/cons/char/c_string_awk.cc | 37 + .../regex/cons/char/c_string_basic.cc | 37 + .../regex/cons/char/c_string_ecma.cc | 37 + .../regex/cons/char/c_string_egrep.cc | 37 + .../regex/cons/char/c_string_extended.cc | 43 + .../regex/cons/char/c_string_grep.cc | 39 + .../regex/cons/char/default.cc | 37 + .../regex_traits/char/ctor.cc | 49 + .../regex_traits/char/translate_nocase.cc | 42 + .../regex_traits/wchar_t/ctor.cc | 49 + .../regex_traits/wchar_t/translate_nocase.cc | 42 + 36 files changed, 3926 insertions(+), 3 deletions(-) create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/cstring.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/cstring_op.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/pstring.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/range.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/string.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/string_op.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/cstring.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/cstring_op.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/pstring.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/range.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/string.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/string_op.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/cstring.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/default.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/pstring.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/range.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/string.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/cstring.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/default.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/pstring.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/range.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/string.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/match_results/ctors/char/default.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_awk.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_basic.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_ecma.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_egrep.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_extended.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_grep.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/default.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/char/ctor.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/char/translate_nocase.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/ctor.cc create mode 100644 libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/translate_nocase.cc diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 8257ba7b5e9..dbb4714dd50 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,75 @@ +2007-03-12 Stephen M. Webb + + * include/tr1/regex: Add "boilerplate" implementations. + * testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/ + translate_nocase.cc: New. + * testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/ + ctor.cc: Likewise. + * testsuite/tr1/7_regular_expressions/regex_traits/char/ + translate_nocase.cc: Likewise. + * testsuite/tr1/7_regular_expressions/regex_traits/char/ + ctor.cc: Likewise. + * testsuite/tr1/7_regular_expressions/regex/cons/char/ + c_string_ecma.cc: Likewise. + * testsuite/tr1/7_regular_expressions/regex/cons/char/ + default.cc: Likewise. + * testsuite/tr1/7_regular_expressions/regex/cons/char/ + c_string_grep.cc: Likewise. + * testsuite/tr1/7_regular_expressions/regex/cons/char/ + c_string_extended.cc: Likewise. + * testsuite/tr1/7_regular_expressions/regex/cons/char/ + c_string_basic.cc: Likewise. + * testsuite/tr1/7_regular_expressions/regex/cons/char/ + c_string_awk.cc: Likewise. + * testsuite/tr1/7_regular_expressions/regex/cons/char/ + c_string_egrep.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ + range.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ + string_op.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ + string.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ + pstring.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ + cstring_op.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/ + cstring.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ + range.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ + string_op.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ + string.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ + pstring.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ + cstring_op.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/assign/char/ + cstring.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/ + range.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/ + default.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/ + string.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/ + pstring.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/ + cstring.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/ + range.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/ + default.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/ + string.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/ + pstring.cc: Likewise. + * testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/ + cstring.cc: Likewise. + * testsuite/tr1/7_regular_expressions/match_results/ctors/char/ + default.cc: Likewise. + 2007-03-12 Paolo Carlini * include/bits/stl_algo.h (swap_ranges): Move... diff --git a/libstdc++-v3/include/tr1/regex b/libstdc++-v3/include/tr1/regex index 65600600f95..3b8f03feb41 100644 --- a/libstdc++-v3/include/tr1/regex +++ b/libstdc++-v3/include/tr1/regex @@ -27,11 +27,2403 @@ // invalidate any other reasons why the executable file might be covered by // the GNU General Public License. -/** @file tr1/regex -* This is a TR1 C++ Library header. -*/ +/** + * @file tr1/regex + * @author Stephen M. Webb + * This is a TR1 C++ Library header. + */ #ifndef _TR1_REGEX #define _TR1_REGEX 1 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace std +{ +_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1) + +/** + * @addtogroup tr1_regex Regular Expressions + * A facility for performing regular expression pattern matching. + * @{ + */ + +namespace regex_constants +{ + // [7.5.1] Bitmask Type syntax_option_type + enum __syntax_option + { + _S_icase, + _S_nosubs, + _S_optimize, + _S_collate, + _S_ECMAScript, + _S_basic, + _S_extended, + _S_awk, + _S_grep, + _S_egrep, + _S_syntax_last + }; + + /** + * @brief This is a bitmask type indicating how to interpret the regex. + * + * The @c syntax_option_type is implementation defined but it is valid to + * perform bitwise operations on these values and expect the right thing to + * happen. + * + * A valid value of type syntax_option_type shall have exactly one of the + * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep + * set. + */ + typedef unsigned int syntax_option_type; + + /// Specifies that the matching of regular expressions against a character + /// sequence shall be performed without regard to case. + static const syntax_option_type icase = 1 << _S_icase; + + /// Specifies that when a regular expression is matched against a character + /// container sequence, no sub-expression matches are to be stored in the + /// supplied match_results structure. + static const syntax_option_type nosubs = 1 << _S_nosubs; + + /// Specifies that the regular expression engine should pay more attention to + /// the speed with which regular expressions are matched, and less to the + /// speed with which regular expression objects are constructed. Otherwise + /// it has no detectable effect on the program output. + static const syntax_option_type optimize = 1 << _S_optimize; + + /// Specifies that character ranges of the form [a-b] should be locale + /// sensitive. + static const syntax_option_type collate = 1 << _S_collate; + + /// Specifies that the grammar recognized by the regular expression engine is + /// that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript + /// Language Specification, Standard Ecma-262, third edition, 1999], as + /// modified in tr1 section [7.13]. This grammar is similar to that defined + /// in the PERL scripting language but extended with elements found in the + /// POSIX regular expression grammar. + static const syntax_option_type ECMAScript = 1 << _S_ECMAScript; + + /// Specifies that the grammar recognized by the regular expression engine is + /// that used by POSIX basic regular expressions in IEEE Std 1003.1-2001, + /// Portable Operating System Interface (POSIX), Base Definitions and + /// Headers, Section 9, Regular Expressions [IEEE, Information Technology -- + /// Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001]. + static const syntax_option_type basic = 1 << _S_basic; + + /// Specifies that the grammar recognized by the regular expression engine is + /// that used by POSIX extended regular expressions in IEEE Std 1003.1-2001, + /// Portable Operating System Interface (POSIX), Base Definitions and Headers, + /// Section 9, Regular Expressions. + static const syntax_option_type extended = 1 << _S_extended; + + /// Specifies that the grammar recognized by the regular expression engine is + /// that used by POSIX utility awk in IEEE Std 1003.1-2001. This option is + /// identical to syntax_option_type extended, except that C-style escape + /// sequences are supported. These sequences are, explicitly, '\\', '\a', + /// '\b', '\f', '\n', '\r', '\t' , '\v', '\"', '\\', and '\ddd' (where ddd is + /// one, two, or three octal digits). + static const syntax_option_type awk = 1 << _S_awk; + + /// Specifies that the grammar recognized by the regular expression engine is + /// that used by POSIX utility grep in IEEE Std 1003.1-2001. This option is + /// identical to syntax_option_type basic, except that newlines are treated + /// as whitespace. + static const syntax_option_type grep = 1 << _S_grep; + + /// Specifies that the grammar recognized by the regular expression engine is + /// that used by POSIX utility grep when given the -E option in + /// IEEE Std 1003.1-2001. This option is identical to syntax_option_type + /// extended, except that newlines are treated as whitespace. + static const syntax_option_type egrep = 1 << _S_egrep; + + + // [7.5.2] Bitmask Type match_flag_type + enum __match_flag + { + _S_not_bol, + _S_not_eol, + _S_not_bow, + _S_not_eow, + _S_any, + _S_not_null, + _S_continuous, + _S_prev_avail, + _S_sed, + _S_no_copy, + _S_first_only, + _S_match_flag_last + }; + + /** + * @brief This is a bitmask type indicating regex matching rules. + * + * Matching a regular expression against a sequence of characters [first, + * last) proceeds according to the rules of the grammar specified for the + * regular expression object, modified according to the effects listed + * below for any bitmask elements set. + * + * The @c match_flag_type is implementation defined but it is valid to + * perform bitwise operations on these values and expect the right thing to + * happen. + */ + typedef std::bitset<_S_match_flag_last> match_flag_type; + + static const match_flag_type match_default = 0; + + /// The first character in the sequence [first, last) is treated as though it + /// is not at the beginning of a line, so the character "^" in the regular + /// expression shall not match [first, first). + static const match_flag_type match_not_bol = 1 << _S_not_bol; + + /// The last character in the sequence [first, last) is treated as though it + /// is not at the end of a line, so the character "$" in the regular + /// expression shall not match [last, last). + static const match_flag_type match_not_eol = 1 << _S_not_eol; + + /// The expression "\b" is not matched against the sub-sequence + /// [first,first). + static const match_flag_type match_not_bow = 1 << _S_not_bow; + + /// The expression "\b" should not be matched against the sub-sequence + /// [last,last). + static const match_flag_type match_not_eow = 1 << _S_not_eow; + + /// If more than one match is possible then any match is an acceptable + /// result. + static const match_flag_type match_any = 1 << _S_any; + + /// The expression does not match an empty sequence. + static const match_flag_type match_not_null = 1 << _S_not_null; + + /// The expression only matchs a sub-sequence that begins at first . + static const match_flag_type match_continuous = 1 << _S_continuous; + + /// --first is a valid iterator position. When this flag is set then the + /// flags match_not_bol and match_not_bow are ignored by the regular + /// expression algorithms 7.11 and iterators 7.12. + static const match_flag_type match_prev_avail = 1 << _S_prev_avail; + + /// When a regular expression match is to be replaced by a new string, the + /// new string is constructed using the rules used by the ECMAScript replace + /// function in ECMA- 262 [Ecma International, ECMAScript Language + /// Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11 + /// String.prototype.replace. In addition, during search and replace + /// operations all non-overlapping occurrences of the regular expression + /// are located and replaced, and sections of the input that did not match + /// the expression are copied unchanged to the output string. + /// + /// Format strings (from ECMA-262 [15.5.4.11]): + /// $$ $ + /// $& The matched substring. + /// $` The portion of string that preceeds the matched substring. + /// $' The portion of string that follows the matched substring. + /// $n The nth capture, where n is in [1,9] and $n is not followed by a + /// decimal digit. If n <= m and the nth capture is undefined, use the + /// empty string + /// instead. If n > m, the result is implementation-defined. + /// $nn The nnth capture, where nn is a two-digit decimal number on [01, 99]. + /// If nn <= m and the nth capture is undefined, use the empty string + /// instead. If nn > m, the result is implementation-defined. + /// + static const match_flag_type format_default = 0; + + /// When a regular expression match is to be replaced by a new string, the + /// new string is constructed using the rules used by the POSIX sed utility + /// in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable + /// Operating System Interface (POSIX), IEEE Standard 1003.1-2001]. + static const match_flag_type format_sed = 1 << _S_sed; + + /// During a search and replace operation, sections of the character + /// container sequence being searched that do not match the regular + /// expression shall not be copied to the output string. + static const match_flag_type format_no_copy = 1 << _S_no_copy; + + /// When specified during a search and replace operation, only the first + /// occurrence of the regular expression shall be replaced. + static const match_flag_type format_first_only = 1 << _S_first_only; + + + // [7.5.3] implementation-defined error type + enum error_type + { + _S_error_collate, + _S_error_ctype, + _S_error_escape, + _S_error_backref, + _S_error_brack, + _S_error_paren, + _S_error_brace, + _S_error_badbrace, + _S_error_range, + _S_error_space, + _S_error_badrepeat, + _S_error_complexity, + _S_error_stack, + _S_error_last + }; + + /// The expression contained an invalid collating element name. + static const error_type error_collate(_S_error_collate); + + /// The expression contained an invalid character class name. + static const error_type error_ctype(_S_error_ctype); + + /// The expression contained an invalid escaped character, or a trailing + /// escape. + static const error_type error_escape(_S_error_escape); + + /// The expression contained an invalid back reference. + static const error_type error_backref(_S_error_backref); + + /// The expression contained mismatched [ and ]. + static const error_type error_brack(_S_error_brack); + + /// The expression contained mismatched ( and ). + static const error_type error_paren(_S_error_paren); + + /// The expression contained mismatched { and } + static const error_type error_brace(_S_error_brace); + + /// The expression contained an invalid range in a {} expression. + static const error_type error_badbrace(_S_error_badbrace); + + /// The expression contained an invalid character range, + /// such as [b-a] in most encodings. + static const error_type error_range(_S_error_range); + + /// There was insufficient memory to convert the expression into a + /// finite state machine. + static const error_type error_space(_S_error_space); + + /// One of *?+{ was not preceded by a valid regular expression. + static const error_type error_badrepeat(_S_error_badrepeat); + + /// The complexity of an attempted match against a regular expression + /// exceeded a pre-set level. + static const error_type error_complexity(_S_error_complexity); + + /// There was insufficient memory to determine whether the + /// regular expression could match the specified character sequence. + static const error_type error_stack(_S_error_stack); +} + + + // [7.8] Class regex_error + /** + * Defines the type of objects thrown as exceptions to report errors from the + * regular expression library. + */ + class regex_error + : public std::runtime_error + { + public: + /** + * @brief constructs a regex_error object. + * + * @param ecode the regex error code. + */ + explicit + regex_error(regex_constants::error_type __ecode) + : std::runtime_error("regex_error"), _M_code(__ecode) + { } + + /** + * @brief gets the regex error code. + * + * @returns the regex error code. + */ + regex_constants::error_type + code() const + { return _M_code; } + + protected: + regex_constants::error_type _M_code; + }; + + + // [7.7] Class regex_traits + /** + * A regular expression traits class that satisfies the requirements of tr1 + * section [7.2]. + * + * The class %regex is parameterized around a set of related types and + * functions used to complete the definition of its semantics. This class + * satisfies the requirements of such a traits class. + */ + template + struct regex_traits + { + public: + typedef _Ch_type char_type; + typedef std::basic_string string_type; + typedef std::locale locale_type; + typedef std::ctype_base::mask char_class_type; + + public: + /** + * @brief Constructs a default traits object. + */ + regex_traits() + { } + + /** + * @brief Gives the length of a C-style string starting at @p __p. + * + * @param __p a pointer to the start of a character sequence. + * + * @returns the number of characters between @p *__p and the first + * default-initialized value of type @p char_type. In other words, uses + * the C-string algorithm for determiining the length of a sequence of + * characters. + */ + static std::size_t + length(const char_type* __p) + { return string_type::traits_type::length(__p); } + + /** + * @brief Performs the identity translation. + * + * @param c A character to the locale-specific character set. + * + * @returns c. + */ + char_type + translate(char_type __c) const + { return __c; } + + /** + * @brief Translates a character into a case-insensitive equivalent. + * + * @param c A character to the locale-specific character set. + * + * @returns the locale-specific lower-case equivalent of c. + * @throws std::bad_cast if the imbued locale does not support the ctype + * facet. + */ + char_type + translate_nocase(char_type __c) const + { + using std::ctype; + using std::use_facet; + return use_facet >(_M_locale).tolower(__c); + } + + /** + * @brief Gets a sort key for a character sequence. + * + * @param first beginning of the character sequence. + * @param last one-past-the-end of the character sequence. + * + * Returns a sort key for the character sequence designated by the + * iterator range [F1, F2) such that if the character sequence [G1, G2) + * sorts before the character sequence [H1, H2) then + * v.transform(G1, G2) < v.transform(H1, H2). + * + * What this really does is provide a more efficient way to compare a + * string to multiple other strings in locales with fancy collation + * rules and equivalence classes. + * + * @returns a locale-specific sort key equivalent to the input range. + * + * @throws std::bad_cast if the current locale does not have a collate + * facet. + */ + template + string_type + transform(_Fwd_iter __first, _Fwd_iter __last) const + { + using std::collate; + using std::use_facet; + const collate<_Ch_type>& __c(use_facet< + collate<_Ch_type> >(_M_locale)); + string_type __s(__first, __last); + return __c.transform(__s.data(), __s.data() + __s.size()); + } + + /** + * @brief Dunno. + * + * @param first beginning of the character sequence. + * @param last one-past-the-end of the character sequence. + * + * Effects: if typeid(use_facet >) == + * typeid(collate_byname<_Ch_type>) and the form of the sort key + * returned by collate_byname<_Ch_type>::transform(first, last) is known + * and can be converted into a primary sort key then returns that key, + * otherwise returns an empty string. WTF?? + * + * @todo Implement this function. + */ + template + string_type + transform_primary(_Fwd_iter __first, _Fwd_iter __last) const + { return string_type(); } + + /** + * @breief Gets a collation element by name. + * + * @param first beginning of the collation element name. + * @param last one-past-the-end of the collation element name. + * + * @returns a sequence of one or more characters that represents the + * collating element consisting of the character sequence designated by + * the iterator range [first, last). Returns an empty string if the + * character sequence is not a valid collating element. + * + * @todo Implement this function. + */ + template + string_type + lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const + { return string_type(); } + + /** + * @brief Maps one or mire characters to a named character + * classification. + * + * @param first beginning of the character sequence. + * @param last one-past-the-end of the character sequence. + * + * @returns an unspecified value that represents the character + * classification named by the character sequence designated by the + * iterator range [first, last). The value returned shall be independent + * of the case of the characters in the character sequence. If the name + * is not recognized then returns a value that compares equal to 0. + * + * At least the following names (or their wide-character equivalent) are + * supported. + * - d + * - w + * - s + * - alnum + * - alpha + * - blank + * - cntrl + * - digit + * - graph + * - lower + * - print + * - punct + * - space + * - upper + * - xdigit + * + * @todo Implement this function. + */ + template + char_class_type + lookup_classname(_Fwd_iter __first, _Fwd_iter __last) const + { return 0; } + + /** + * @brief Determines if @p c is a member of an identified class. + * + * @param c a character. + * @param f a class type (as returned from lookup_classname). + * + * @returns true if the character @p c is a member of the classification + * represented by @p f, false otherwise. + * + * @throws std::bad_cast if the current locale does not have a ctype + * facet. + */ + bool + isctype(_Ch_type __c, char_class_type __f) const + { + using std::ctype; + using std::use_facet; + const ctype<_Ch_type>& __ctype(use_facet< + ctype<_Ch_type> >(_M_locale)); + + if (__ctype.is(__c, __f)) + return true; + + // special case of underscore in [[:w:]] + if (__c == __ctype.widen('_')) + { + const char* const __wb[] = "w"; + char_class_type __wt = this->lookup_classname(__wb, + __wb + sizeof(__wb)); + if (__f | __wt) + return true; + } + + // special case of [[:space:]] in [[:blank:]] + if (__c == __ctype.isspace(__c)) + { + const char* const __bb[] = "blank"; + char_class_type __bt = this->lookup_classname(__bb, + __bb + sizeof(__bb)); + if (__f | __bt) + return true; + } + + return false; + } + + /** + * @brief Converts a digit to an int. + * + * @param ch a character representing a digit. + * @param radix the radix if the numeric conversion (limited to 8, 10, + * or 16). + * + * @returns the value represented by the digit ch in base radix if the + * character ch is a valid digit in base radix; otherwise returns -1. + * + * @todo Implement this function. + */ + int + value(_Ch_type __ch, int __radix) const; + + /** + * @brief Imbues the regex_traits object with a copy of a new locale. + * + * @param loc A locale. + * + * @returns a copy of the previous locale in use by the regex_traits + * object. + * + * @note Calling imbue with a different locale than the one currently in + * use invalidates all cached data held by *this. + */ + locale_type + imbue(locale_type __loc) + { + std::swap(_M_locale, __loc); + return __loc; + } + + /** + * @brief Gets a copy of the current locale in use by the regex_traits + * object. + */ + locale_type + getloc() const + { return _M_locale; } + + protected: + locale_type _M_locale; + }; + + + // [7.8] Class basic_regex + /** + * Objects of specializations of this class represent regular expressions + * constructed from sequences of character type @p _Ch_type. + * + * Storage for the regular expression is allocated and deallocated as + * necessary by the member functions of this class. + */ + template > + class basic_regex + { + public: + // types: + typedef _Ch_type value_type; + typedef regex_constants::syntax_option_type flag_type; + typedef typename _Rx_traits::locale_type locale_type; + typedef typename _Rx_traits::string_type string_type; + + // [7.8.1] constants + static const regex_constants::syntax_option_type icase + = regex_constants::icase; + static const regex_constants::syntax_option_type nosubs + = regex_constants::nosubs; + static const regex_constants::syntax_option_type optimize + = regex_constants::optimize; + static const regex_constants::syntax_option_type collate + = regex_constants::collate; + static const regex_constants::syntax_option_type ECMAScript + = regex_constants::ECMAScript; + static const regex_constants::syntax_option_type basic + = regex_constants::basic; + static const regex_constants::syntax_option_type extended + = regex_constants::extended; + static const regex_constants::syntax_option_type awk + = regex_constants::awk; + static const regex_constants::syntax_option_type grep + = regex_constants::grep; + static const regex_constants::syntax_option_type egrep + = regex_constants::egrep; + + // [7.8.2] construct/copy/destroy + /** + * Constructs a basic regular expression that does not match any + * character sequence. + */ + basic_regex() + : _M_flags(regex_constants::ECMAScript), _M_pattern(), _M_mark_count(0) + { _M_compile(); } + + /** + * @brief Constructs a basic regular expression from the sequence + * [p, p + char_traits<_Ch_type>::length(p)) interpreted according to the + * flags in @p f. + * + * @param p A pointer to the start of a C-style null-terminated string + * containing a regular expression. + * @param f Flags indicating the syntax rules and options. + * + * @throws regex_error if @p p is not a valid regular expression. + */ + explicit + basic_regex(const _Ch_type* __p, + flag_type __f = regex_constants::ECMAScript) + : _M_flags(__f), _M_pattern(__p), _M_mark_count(0) + { _M_compile(); } + + /** + * @brief Constructs a basic regular expression from the sequence + * [p, p + len) interpreted according to the flags in @p f. + * + * @param p A pointer to the start of a string containing a regular + * expression. + * @param len The length of the string containing the regular expression. + * @param f Flags indicating the syntax rules and options. + * + * @throws regex_error if @p p is not a valid regular expression. + */ + basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f) + : _M_flags(__f) , _M_pattern(__p, __len), _M_mark_count(0) + { _M_compile(); } + + /** + * @brief Copy-contructs a basic regular expression. + * + * @param rhs A @p regex object. + */ + basic_regex(const basic_regex& __rhs) + : _M_flags(__rhs._M_flags), _M_pattern(__rhs._M_pattern), + _M_mark_count(__rhs._M_mark_count) + { _M_compile(); } + + /** + * @brief Constructs a basic regular expression from the string + * @p interpreted according to the flags in @p f. + * + * @param p A string containing a regular expression. + * @param f Flags indicating the syntax rules and options. + * + * @throws regex_error if @p p is not a valid regular expression. + */ + template + explicit + basic_regex(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, + flag_type __f = regex_constants::ECMAScript) + : _M_flags(__f), _M_pattern(__s), _M_mark_count(0) + { _M_compile(); } + + /** + * @brief Constructs a basic regular expression from the range + * [first, last) interpreted according to the flags in @p f. + * + * @param first The start of arange containing a valid regular + * expression. + * @param last The end of a range containing a valid regular + * expression. + * @param f The format flags of the regular expression. + * + * @throws regex_error if @p p is not a valid regular expression. + */ + template + basic_regex(_InputIterator __first, _InputIterator __last, + flag_type __f = regex_constants::ECMAScript) + : _M_flags(__f), _M_pattern(__first, __last), _M_mark_count(0) + { _M_compile(); } + + /** + * @brief Destroys a basic regular expression. + */ + ~basic_regex() + { } + + /** + * @brief Assigns one regular expression to another. + */ + basic_regex& + operator=(const basic_regex& __rhs) + { return this->assign(__rhs); } + + /** + * @brief Replaces a regular expression with a new one constructed from + * a C-style null-terminated string. + * + * @param A pointer to the start of a null-terminated C-style string + * containing a regular expression. + */ + basic_regex& + operator=(const _Ch_type* __p) + { return this->assign(__p, flags()); } + + /** + * @brief Replaces a regular expression with a new one constructed from + * a string. + * + * @param A pointer to a string containing a regular expression. + */ + template + basic_regex& + operator=(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s) + { return this->assign(__s, flags()); } + + // [7.8.3] assign + /** + * @brief the real assignment operator. + * + * @param that Another regular expression object. + */ + basic_regex& + assign(const basic_regex& __that) + { + basic_regex __tmp(__that); + this->swap(__tmp); + return *this; + } + + /** + * @brief Assigns a new regular expression to a regex object from a + * C-style null-terminated string containing a regular expression + * pattern. + * + * @param p A pointer to a C-style null-terminated string containing + * a regular expression pattern. + * @param flags Syntax option flags. + * + * @throws regex_error if p does not contain a valid regular expression + * pattern interpreted according to @p flags. If regex_error is thrown, + * *this remains unchanged. + */ + basic_regex& + assign(const _Ch_type* __p, + flag_type __flags = regex_constants::ECMAScript) + { return this->assign(string_type(__p), __flags); } + + /** + * @brief Assigns a new regular expression to a regex object from a + * C-style string containing a regular expression pattern. + * + * @param p A pointer to a C-style string containing a + * regular expression pattern. + * @param len The length of the regular expression pattern string. + * @param flags Syntax option flags. + * + * @throws regex_error if p does not contain a valid regular expression + * pattern interpreted according to @p flags. If regex_error is thrown, + * *this remains unchanged. + */ + basic_regex& + assign(const _Ch_type* __p, std::size_t __len, flag_type __flags) + { return this->assign(string_type(__p, __len), __flags); } + + /** + * @brief Assigns a new regular expression to a regex object from a + * string containing a regular expression pattern. + * + * @param s A string containing a regular expression pattern. + * @param flags Syntax option flags. + * + * @throws regex_error if p does not contain a valid regular expression + * pattern interpreted according to @p flags. If regex_error is thrown, + * *this remains unchanged. + */ + template + basic_regex& + assign(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s, + flag_type __f = regex_constants::ECMAScript) + { + basic_regex __tmp(__s, __f); + this->swap(__tmp); + return *this; + } + + /** + * @brief Assigns a new regular expression to a regex object. + * + * @param first The start of a range containing a valid regular + * expression. + * @param last The end of a range containing a valid regular + * expression. + * @param flags Syntax option flags. + * + * @throws regex_error if p does not contain a valid regular expression + * pattern interpreted according to @p flags. If regex_error is thrown, + * *this remains unchanged. + */ + template + basic_regex& + assign(_InputIterator __first, _InputIterator __last, + flag_type __flags = regex_constants::ECMAScript) + { return this->assign(string_type(__first, __last), __flags); } + + // [7.8.4] const operations + /** + * @brief Gets the number of marked subexpressions within the regular + * expresison. + */ + unsigned int + mark_count() const + { return _M_mark_count; } + + /** + * @brief Gets the flags used to construct the regular expression + * or in the last call to assign(). + */ + flag_type + flags() const + { return _M_flags; } + + // [7.8.5] locale + /** + * @brief Imbues the regular expression object with the given locale. + * + * @param loc A locale. + */ + locale_type + imbue(locale_type __loc) + { return _M_traits.imbue(__loc); } + + /** + * @brief Gets the locale currently imbued in the regular expression + * object. + */ + locale_type + getloc() const + { return _M_traits.getloc(); } + + // [7.8.6] swap + /** + * @brief Swaps the contents of two regular expression obects. + * + * @param rhs Another regular expression object. + */ + void + swap(basic_regex& __rhs) + { + std::swap(_M_flags, __rhs._M_flags); + std::swap(_M_pattern, __rhs._M_pattern); + std::swap(_M_mark_count, __rhs._M_mark_count); + std::swap(_M_traits, __rhs._M_traits); + } + + private: + /** + * @brief Compiles a regular expression pattern into a NFA. + * @todo Implement this function. + */ + void _M_compile() + { } + + protected: + flag_type _M_flags; + string_type _M_pattern; + unsigned int _M_mark_count; + _Rx_traits _M_traits; + }; + + typedef basic_regex regex; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef basic_regex wregex; +#endif + + + // [7.8.6] basic_regex swap + /** + * @brief Swaps the contents of two regular expression objects. + * @param lhs First regular expression. + * @param rhs Second regular expression. + */ + template + inline void + swap(basic_regex<_Ch_type, _Rx_traits>& __lhs, + basic_regex<_Ch_type, _Rx_traits>& __rhs) + { return __lhs.swap(__rhs); } + + + // [7.9] Class template sub_match + /** + * A sequence of characters matched by a particular marked sub-expression. + * + * An object of this class is essentially a pair of iterators marking a + * matched subexpression within a regular expression pattern match. Such + * objects can be converted to and compared with std::basic_string objects + * of a similar base character type as the pattern matched by the regular + * expression. + * + * The iterators that make up the pair are the usual half-open interval + * referencing the actual original pattern matched. + */ + template + class sub_match : public std::pair<_BiIter, _BiIter> + { + public: + typedef typename iterator_traits<_BiIter>::value_type value_type; + typedef typename iterator_traits<_BiIter>::difference_type + difference_type; + typedef _BiIter iterator; + + public: + bool matched; + + /** + * Gets the length of the matching sequence. + */ + difference_type + length() const + { return this->matched ? std::distance(this->first, this->second) : 0; } + + /** + * @brief Gets the matching sequence as a string. + * + * @returns the matching sequence as a string. + * + * This is the implicit conversion operator. It is identical to the + * str() member function except that it will want to pop up in + * unexpected places and cause a great deal of confusion and cursing + * from the unwary. + */ + operator basic_string() const + { + return this->matched + ? std::basic_string(this->first, this->second) + : std::basic_string(); + } + + /** + * @brief Gets the matching sequence as a string. + * + * @returns the matching sequence as a string. + */ + basic_string + str() const + { + return this->matched + ? std::basic_string(this->first, this->second) + : std::basic_string(); + } + + /** + * @brief Compares this and another matched sequence. + * + * @param s Another matched sequence to compare to this one. + * + * @retval <0 this matched sequence will collate before @p s. + * @retval =0 this matched sequence is equivalent to @p s. + * @retval <0 this matched sequence will collate after @p s. + */ + int + compare(const sub_match& __s) const + { return this->str().compare(__s.str()); } + + /** + * @brief Compares this sub_match to a string. + * + * @param s A string to compare to this sub_match. + * + * @retval <0 this matched sequence will collate before @p s. + * @retval =0 this matched sequence is equivalent to @p s. + * @retval <0 this matched sequence will collate after @p s. + */ + int + compare(const basic_string& __s) const + { return this->str().compare(__s); } + + /** + * @brief Compares this sub_match to a C-style string. + * + * @param s A C-style string to compare to this sub_match. + * + * @retval <0 this matched sequence will collate before @p s. + * @retval =0 this matched sequence is equivalent to @p s. + * @retval <0 this matched sequence will collate after @p s. + */ + int + compare(const value_type* __s) const + { return this->str().compare(__s); } + }; + + + typedef sub_match csub_match; + typedef sub_match ssub_match; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef sub_match wcsub_match; + typedef sub_match wssub_match; #endif + + // [7.9.2] sub_match non-member operators + + /** + * @brief Tests the equivalence of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator==(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) == 0; } + + /** + * @brief Tests the inequivalence of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator!=(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) != 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template + inline bool + operator<(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) < 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template + inline bool + operator<=(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) <= 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs does not preceed @a rhs, false otherwise. + */ + template + inline bool + operator>=(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) >= 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template + inline bool + operator>(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) > 0; } + + /** + * @brief Tests the equivalence of a string and a regular expression + * submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator==(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs == __rhs.str(); } + + /** + * @brief Tests the inequivalence of a string and a regular expression + * submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator!=(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) + { return __lhs != __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template + inline bool + operator<(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) + { return __lhs < __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template + inline bool + operator>(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) + { return __lhs > __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not preceed @a rhs, false otherwise. + */ + template + inline bool + operator>=(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) + { return __lhs >= __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template + inline bool + operator<=(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) + { return __lhs <= __rhs.str(); } + + /** + * @brief Tests the equivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator==(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() == __rhs; } + + /** + * @brief Tests the inequivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator!=(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() != __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template + inline bool + operator<(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() < __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template + inline bool + operator>(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() > __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs does not preceed @a rhs, false otherwise. + */ + template + inline bool + operator>=(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() >= __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template + inline bool + operator<=(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() <= __rhs; } + + /** + * @brief Tests the equivalence of a C string and a regular expression + * submatch. + * @param lhs A C string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs == __rhs.str(); } + + /** + * @brief Tests the inequivalence of an iterator value and a regular + * expression submatch. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs != __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template + inline bool + operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs < __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template + inline bool + operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs > __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not preceed @a rhs, false otherwise. + */ + template + inline bool + operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs >= __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template + inline bool + operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs <= __rhs.str(); } + + /** + * @brief Tests the equivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A pointer to a string? + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator==(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() == __rhs; } + + /** + * @brief Tests the inequivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A pointer to a string. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator!=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() != __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template + inline bool + operator<(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() < __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template + inline bool + operator>(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() > __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs does not precede @a rhs, false otherwise. + */ + template + inline bool + operator>=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() >= __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template + inline bool + operator<=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() <= __rhs; } + + /** + * @brief Tests the equivalence of a string and a regular expression + * submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs == __rhs.str(); } + + /** + * @brief Tests the inequivalence of a string and a regular expression + * submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs != __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template + inline bool + operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs < __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template + inline bool + operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs > __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not preceed @a rhs, false otherwise. + */ + template + inline bool + operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs >= __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template + inline bool + operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs <= __rhs.str(); } + + /** + * @brief Tests the equivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator==(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() == __rhs; } + + /** + * @brief Tests the inequivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template + inline bool + operator!=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() != __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs preceeds @a rhs, false otherwise. + */ + template + inline bool + operator<(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() < __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template + inline bool + operator>(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() > __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs does not preceed @a rhs, false otherwise. + */ + template + inline bool + operator>=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() >= __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template + inline bool + operator<=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() <= __rhs; } + + /** + * @brief Inserts a matched string into an output stream. + * + * @param os The output stream. + * @param m A submatch string. + * + * @returns the output stream with the submatch string inserted. + */ + template + inline + basic_ostream<_Ch_type, _Ch_traits>& + operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os, + const sub_match<_Bi_iter>& __m) + { return __os << __m.str(); } + + // [7.10] Class template match_results + /** + * A collection of character sequences representing the result of a regular + * expression match. Storage for the collection is allocated and freed as + * necessary by the member functions of class template match_results. + * + * This class satisfies the Sequence requirements, with the exception that + * only the operations defined for a const-qualified Sequence are supported. + * + * The sub_match object stored at index 0 represents sub-expression 0, i.e. + * the whole match. In this case the sub_match member matched is always true. + * The sub_match object stored at index n denotes what matched the marked + * sub-expression n within the matched expression. If the sub-expression n + * participated in a regular expression match then the sub_match member + * matched evaluates to true, and members first and second denote the range + * of characters [first, second) which formed that match. Otherwise matched + * is false, and members first and second point to the end of the sequence + * that was searched. + */ + template > > + class match_results + : private std::vector, _Allocator> + { + private: + typedef std::vector, _Allocator> + _Base_type; + + public: + typedef sub_match<_Bi_iter> value_type; + typedef typename _Allocator::const_reference const_reference; + typedef const_reference reference; + typedef typename _Base_type::const_iterator const_iterator; + typedef const_iterator iterator; + typedef typename iterator_traits<_Bi_iter>::difference_type + difference_type; + typedef typename _Allocator::size_type size_type; + typedef _Allocator allocator_type; + typedef typename iterator_traits<_Bi_iter>::value_type char_type; + typedef basic_string string_type; + + public: + // [7.10.1] construct/copy/destroy + /** + * @brief Constructs a default match_results container. + */ + explicit + match_results(const _Allocator& __a = _Allocator()) + : _Base_type(__a), _M_matched(false) + { } + + /** + * @brief Copy constructs a match_result. + */ + match_results(const match_results& __rhs) + : _Base_type(__rhs), _M_matched(__rhs._M_matched), + _M_prefix(__rhs._M_prefix), _M_suffix(__rhs._M_suffix) + { } + + /** + * @brief Assigns rhs to *this. + */ + match_results& + operator=(const match_results& __rhs) + { + match_results __tmp(__rhs); + this->swap(__tmp); + } + + /** + * @todo Implement this function. + */ + ~match_results() + { } + + // [7.10.2] size + /** + * @todo Document this function. + */ + size_type + size() const + { return _M_matched ? _Base_type::size() + 1 : 0; } + + /** + * @todo Implement this function. + */ + //size_type + //max_size() const; + using _Base_type::max_size; + + /** + * @todo Document this function. + */ + bool + empty() const + { return size() == 0; } + + // [7.10.3] element access + /** + * @brief Gets the length of the indicated submatch. + * @param sub indicates the submatch. + */ + difference_type + length(size_type __sub = 0) const + { return _M_matched ? this->str(__sub).length() : 0; } + + /** + * @todo Document this function. + */ + difference_type + position(size_type __sub = 0) const + { + return _M_matched ? std::distance(this->prefix().first, + (*this)[__sub].first) : 0; + } + + /** + * @todo Document this function. + */ + string_type + str(size_type __sub = 0) const + { return _M_matched ? (*this)[__sub].str() : string_type(); } + + /** + * @todo Document this function. + */ + const_reference + operator[](size_type __n) const + { return _Base_type::operator[](__n); } + + /** + * @todo Document this function. + */ + const_reference + prefix() const + { return _M_prefix; } + + /** + * @todo Document this function. + */ + const_reference + suffix() const + { return _M_suffix; } + + /** + * @todo Document this function. + */ + const_iterator + begin() const + { return _Base_type::begin(); } + + /** + * @todo Document this function. + */ + const_iterator + end() const + { return _Base_type::end(); } + + // [7.10.4] format + /** + * @todo Implement this function. + */ + template + _Out_iter + format(_Out_iter __out, const string_type& __fmt, + regex_constants::match_flag_type __flags + = regex_constants::format_default) const + { return __out; } + + /** + * @todo Implement this function. + */ + string_type + format(const string_type& __fmt, + regex_constants::match_flag_type __flags + = regex_constants::format_default) const; + + // [7.10.5] allocator + /** + * @todo Document this function. + */ + //allocator_type + //get_allocator() const; + using _Base_type::get_allocator; + + // [7.10.6] swap + /** + * @todo Document this function. + */ + void + swap(match_results& __that) + { + _Base_type::swap(__that); + std::swap(_M_matched, __that._M_matched); + std::swap(_M_prefix, __that._M_prefix); + std::swap(_M_suffix, __that._M_suffix); + } + + private: + bool _M_matched; + value_type _M_prefix; + value_type _M_suffix; + }; + + typedef match_results cmatch; + typedef match_results smatch; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef match_results wcmatch; + typedef match_results wsmatch; +#endif + + // match_results comparisons + /** + * @todo Implement this function. + */ + template + inline bool + operator==(const match_results<_Bi_iter, _Allocator>& __m1, + const match_results<_Bi_iter, _Allocator>& __m2); + + /** + * @todo Implement this function. + */ + template + inline bool + operator!=(const match_results<_Bi_iter, _Allocator>& __m1, + const match_results<_Bi_iter, _Allocator>& __m2); + + // [7.10.6] match_results swap + /** + * @brief Swaps two match results. + * @param lhs A match result. + * @param rhs A match result. + * + * The contents of the two match_results objects are swapped. + */ + template + inline void + swap(match_results<_Bi_iter, _Allocator>& __lhs, + match_results<_Bi_iter, _Allocator>& __rhs) + { return __lhs.swap(__rhs); } + + // [7.11.2] Function template regex_match + /** + * @brief Determines if there is a match between the regular expression @p e + * and all of the character sequence [first, last). + * + * @param first Beginning of the character sequence to match. + * @param last One-past-the-end of the character sequence to match. + * @param m The match results. + * @param re The regular expression. + * @param flags Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @todo Implement this function. + */ + template + bool + regex_match(_Bi_iter __first, _Bi_iter __last, + match_results<_Bi_iter, _Allocator>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return false; } + + /** + * @brief Indicates if there is a match between the regular expression @p e + * and all of the character sequence [first, last). + * + * @param first Beginning of the character sequence to match. + * @param last One-past-the-end of the character sequence to match. + * @param re The regular expression. + * @param flags Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + */ + template + bool + regex_match(_Bi_iter __first, _Bi_iter __last, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + match_results<_Bi_iter> __what; + return regex_match(__first, __last, __what, __re, __flags); + } + + /** + * @brief Determines if there is a match between the regular expression @p e + * and a C-style null-terminated string. + * + * @param s The C-style null-terminated string to match. + * @param m The match results. + * @param re The regular expression. + * @param f Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + */ + template + inline bool + regex_match(const _Ch_type* __s, + match_results& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); } + + /** + * @brief Determines if there is a match between the regular expression @p e + * and a string. + * + * @param s The string to match. + * @param m The match results. + * @param re The regular expression. + * @param flags Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + */ + template + inline bool + regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, + match_results::const_iterator, _Allocator>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); } + + /** + * @brief Indicates if there is a match between the regular expression @p e + * and a C-style null-terminated string. + * + * @param s The C-style null-terminated string to match. + * @param re The regular expression. + * @param f Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + */ + template + inline bool + regex_match(const _Ch_type* __s, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); } + + /** + * @brief Indicates if there is a match between the regular expression @p e + * and a string. + * + * @param s [IN] The string to match. + * @param re [IN] The regular expression. + * @param flags [IN] Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + */ + template + inline bool + regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return regex_match(__s.begin(), __s.end(), __re, __flags); } + + // [7.11.3] Function template regex_search + /** + * Searches for a regular expression within a range. + * @param first [IN] The start of the string to search. + * @param last [IN] One-past-the-end of the string to search. + * @param m [OUT] The match results. + * @param re [IN] The regular expression to search for. + * @param flags [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string, the content of %m is + * undefined. + * @todo Implement this function. + */ + template + inline bool + regex_search(_Bi_iter __first, _Bi_iter __last, + match_results<_Bi_iter, _Allocator>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return false; } + + /** + * Searches for a regular expression within a range. + * @param first [IN] The start of the string to search. + * @param last [IN] One-past-the-end of the string to search. + * @param re [IN] The regular expression to search for. + * @param flags [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string. + * @todo Document me. + */ + template + inline bool + regex_search(_Bi_iter __first, _Bi_iter __last, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + match_results<_Bi_iter> __what; + return regex_search(__first, __last, __what, __re, __flags); + } + + /** + * @brief Searches for a regular expression within a C-string. + * @param s [IN] A C-string to search for the regex. + * @param m [OUT] The set of regex mnatches. + * @param e [IN] The regex to search for in @p s. + * @param f [IN] The search flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string, the content of %m is + * undefined. + * @todo Document me. + */ + template + inline bool + regex_search(const _Ch_type* __s, + match_results& __m, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); } + + /** + * @brief Searches for a regular expression within a C-string. + * @param s [IN] The C-string to search. + * @param e [IN] The regular expressioon to search for. + * @param f [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string. + * @todo Document me. + */ + template + inline bool + regex_search(const _Ch_type* __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); } + + /** + * @brief Searches for a regular expression within a string. + * @param s [IN] The string to search. + * @param e [IN] The regular expressioon to search for. + * @param flags [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string. + * @todo Document me. + */ + template + inline bool + regex_search(const basic_string<_Ch_type, _Ch_traits, + _String_allocator>& __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return regex_search(__s.begin(), __s.end(), __e, __flags); } + + /** + * @brief Searches for a regular expression within a string. + * @param s [IN] A C++ string to search for the regex. + * @param m [OUT] The set of regex mnatches. + * @param e [IN] The regex to search for in @p s. + * @param f [IN] The search flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string, the content of %m is + * undefined. + */ + template + inline bool + regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, + match_results::const_iterator, _Allocator>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_search(__s.begin(), __s.end(), __m, __e, __f); } + + // [7.11.4] Function template regex_replace + /** + * @todo Implement this function. + * @todo Document this function. + */ + template + inline _Out_iter + regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, + const basic_regex<_Ch_type, _Rx_traits>& __e, + const basic_string<_Ch_type>& __fmt, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return __out; } + + /** + * @todo Document me. + */ + template + inline basic_string<_Ch_type> + regex_replace(const basic_string<_Ch_type>& __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + const basic_string<_Ch_type>& __fmt, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + std::string __result; + regex_replace(std::back_inserter(__result), + __s.begin(), __s.end(), __e, __fmt, __flags); + return __result; + } + + // [7.12.1] Class template regex_iterator + /** + * An iterator adaptor that will provide repeated calls of regex_search over + * a range until no more matches remain. + */ + template::value_type, + typename _Rx_traits = regex_traits<_Ch_type> > + class regex_iterator + { + public: + typedef basic_regex<_Ch_type, _Rx_traits> regex_type; + typedef match_results<_Bi_iter> value_type; + typedef std::ptrdiff_t difference_type; + typedef const value_type* pointer; + typedef const value_type& reference; + typedef std::forward_iterator_tag iterator_category; + + public: + /** + * @brief Provides a singular iterator, useful for indicating + * one-past-the-end of a range. + * @todo Implement this function. + * @todo Document this function. + */ + regex_iterator(); + + /** + * Constructs a %regex_iterator... + * @param a [IN] The start of a text range to search. + * @param b [IN] One-past-the-end of the text range to search. + * @param re [IN] The regular expression to match. + * @param m [IN] Policy flags for match rules. + * @todo Implement this function. + * @todo Document this function. + */ + regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, + regex_constants::match_flag_type __m + = regex_constants::match_default); + + /** + * Copy constructs a %regex_iterator. + * @todo Implement this function. + * @todo Document this function. + */ + regex_iterator(const regex_iterator& __rhs); + + /** + * @todo Implement this function. + * @todo Document this function. + */ + regex_iterator& + operator=(const regex_iterator& __rhs); + + /** + * @todo Implement this function. + * @todo Document this function. + */ + bool + operator==(const regex_iterator& __rhs); + + /** + * @todo Implement this function. + * @todo Document this function. + */ + bool + operator!=(const regex_iterator& __rhs); + + /** + * @todo Implement this function. + * @todo Document this function. + */ + const value_type& + operator*(); + + /** + * @todo Implement this function. + * @todo Document this function. + */ + const value_type* + operator->(); + + /** + * @todo Implement this function. + * @todo Document this function. + */ + regex_iterator& + operator++(); + + /** + * @todo Implement this function. + * @todo Document this function. + */ + regex_iterator + operator++(int); + + private: + // these members are shown for exposition only: + _Bi_iter begin; + _Bi_iter end; + const regex_type* pregex; + regex_constants::match_flag_type flags; + match_results<_Bi_iter> match; + }; + + typedef regex_iterator cregex_iterator; + typedef regex_iterator sregex_iterator; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef regex_iterator wcregex_iterator; + typedef regex_iterator wsregex_iterator; +#endif + + // [7.12.2] Class template regex_token_iterator + /** + * Iterates over submatches in a range (or "splits" a text string). + * + * The purpose of this iterator is to enumerate all, or all specified, + * matches of a regular expression within a text range. The dereferenced + * value of an iterator of this class is a std::tr1::sub_match object. + */ + template::value_type, + typename _Rx_traits = regex_traits<_Ch_type> > + class regex_token_iterator + { + public: + typedef basic_regex<_Ch_type, _Rx_traits> regex_type; + typedef sub_match<_Bi_iter> value_type; + typedef std::ptrdiff_t difference_type; + typedef const value_type* pointer; + typedef const value_type& reference; + typedef std::forward_iterator_tag iterator_category; + + public: + /** + * @brief Default constructs a %regex_token_iterator. + * @todo Implement this function. + * + * A default-constructed %regex_token_iterator is a singular iterator + * that will compare equal to the one-past-the-end value for any + * iterator of the same type. + */ + regex_token_iterator(); + + /** + * Constrcts a %regex_token_iterator... + * @param a [IN] The start of the text to search. + * @param b [IN] One-past-the-eend of the text to search. + * @param re [IN] The regular expression to search for. + * @param submatch [IN] Which submatch to return. There are some + * special values for thsi parameter: + * - -1 each enumerated subexpression does NOT + * match the regular expression (aka field + * splitting) + * - 0 the entire string matching the + * subexpression is returned for each match + * within the text. + * - >0 enumerates only the indicated + * subexpression from a match within the text. + * @param m [IN] Policy flags for match rules. + * + * @todo Implement this function. + * @todo Document this function. + */ + regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, + int __submatch = 0, + regex_constants::match_flag_type __m + = regex_constants::match_default); + + /** + * Constrcts a %regex_token_iterator... + * @param a [IN] The start of the text to search. + * @param b [IN] One-past-the-eend of the text to search. + * @param re [IN] The regular expression to search for. + * @param submatches [IN] A list of subexpressions to return for each + * regular expression match within the text. + * @param m [IN] Policy flags for match rules. + * + * @todo Implement this function. + * @todo Document this function. + */ + regex_token_iterator(_Bi_iter __a, _Bi_iter __b, + const regex_type& __re, + const std::vector& __submatches, + regex_constants::match_flag_type __m + = regex_constants::match_default); + + /** + * Constrcts a %regex_token_iterator... + * @param a [IN] The start of the text to search. + * @param b [IN] One-past-the-eend of the text to search. + * @param re [IN] The regular expression to search for. + * @param submatches [IN] A list of subexpressions to return for each + * regular expression match within the text. + * @param m [IN] Policy flags for match rules. + + * @todo Implement this function. + * @todo Document this function. + */ + template + regex_token_iterator(_Bi_iter __a, _Bi_iter __b, + const regex_type& __re, + const int (&__submatches)[_Nm], + regex_constants::match_flag_type __m + = regex_constants::match_default); + + /** + * @brief Copy constructs a %regex_token_iterator. + * @param rhs [IN] A %regex_token_iterator to copy. + * @todo Implement this function. + */ + regex_token_iterator(const regex_token_iterator& __rhs); + + /** + * @brief Assigns a %regex_token_iterator to another. + * @param rhs [IN] A %regex_token_iterator to copy. + * @todo Implement this function. + */ + regex_token_iterator& + operator=(const regex_token_iterator& __rhs); + + /** + * @brief Compares a %regex_token_iterator to another for equality. + * @todo Implement this function. + */ + bool + operator==(const regex_token_iterator& __rhs); + + /** + * @brief Compares a %regex_token_iterator to another for inequality. + * @todo Implement this function. + */ + bool + operator!=(const regex_token_iterator& __rhs); + + /** + * @brief Dereferences a %regex_token_iterator. + * @todo Implement this function. + */ + const value_type& + operator*(); + + /** + * @brief Selects a %regex_token_iterator member. + * @todo Implement this function. + */ + const value_type* + operator->(); + + /** + * @brief Increments a %regex_token_iterator. + * @todo Implement this function. + */ + regex_token_iterator& + operator++(); + + /** + * @brief Postincrements a %regex_token_iterator. + * @todo Implement this function. + */ + regex_token_iterator + operator++(int); + + private: // data members for exposition only: + typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> position_iterator; + + position_iterator __position; + const value_type* __result; + value_type __suffix; + std::size_t __n; + std::vector __subs; + }; + + typedef regex_token_iterator cregex_token_iterator; + typedef regex_token_iterator sregex_token_iterator; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef regex_token_iterator wcregex_token_iterator; + typedef regex_token_iterator wsregex_token_iterator; +#endif + + /** @} */ // group tr1_regex + +_GLIBCXX_END_NAMESPACE +} + +#endif // _TR1_REGEX diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/cstring.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/cstring.cc new file mode 100644 index 00000000000..6594b286adc --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/cstring.cc @@ -0,0 +1,43 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include + +// Tests assign operation from a C-style null-terminated-string. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + const char* cs = "aab"; + test_type re; + re.assign(cs); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/cstring_op.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/cstring_op.cc new file mode 100644 index 00000000000..d8db3933b18 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/cstring_op.cc @@ -0,0 +1,43 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include + +// Tests basic_regex assign operator from a C-style null-terminated-string. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + const char* cs = "aab"; + test_type re; + re = cs; +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/pstring.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/pstring.cc new file mode 100644 index 00000000000..fd48a46623a --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/pstring.cc @@ -0,0 +1,43 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include + +// Tests assign operation from a Pascal-style counted-string. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + const char cs[] = "aab"; + test_type re; + re.assign(cs, sizeof(cs)-1, std::tr1::regex_constants::basic); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/range.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/range.cc new file mode 100644 index 00000000000..e96e169463c --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/range.cc @@ -0,0 +1,43 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include + +// Tests range assign of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + char s[] = "a+b|c"; + test_type re; + re.assign(s, s + sizeof(s)); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/string.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/string.cc new file mode 100644 index 00000000000..57e9a6b1dfd --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/string.cc @@ -0,0 +1,44 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include +#include + +// Tests C++ string assignment of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + std::string s("a*b"); + test_type re; + re.assign(s); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/string_op.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/string_op.cc new file mode 100644 index 00000000000..a653fbc6f53 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/char/string_op.cc @@ -0,0 +1,44 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include +#include + +// Tests basic_regex assignment operator from a C++ string; +void test01() +{ + typedef std::tr1::basic_regex test_type; + + std::string s("a*b"); + test_type re; + re = s; +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/cstring.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/cstring.cc new file mode 100644 index 00000000000..755434044fe --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/cstring.cc @@ -0,0 +1,43 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include + +// Tests assign operation from a C-style null-terminated-string. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + const wchar_t* cs = L"aab"; + test_type re; + re.assign(cs); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/cstring_op.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/cstring_op.cc new file mode 100644 index 00000000000..f61dbcf22d7 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/cstring_op.cc @@ -0,0 +1,43 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include + +// Tests basic_regex assign operator from a C-style null-terminated-string. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + const wchar_t* cs = L"aab"; + test_type re; + re = cs; +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/pstring.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/pstring.cc new file mode 100644 index 00000000000..bf3de48e94a --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/pstring.cc @@ -0,0 +1,43 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include + +// Tests assign operation from a Pascal-style counted-string. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + const wchar_t cs[] = L"aab"; + test_type re; + re.assign(cs, sizeof(cs)-1, std::tr1::regex_constants::basic); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/range.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/range.cc new file mode 100644 index 00000000000..ca48cadf880 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/range.cc @@ -0,0 +1,43 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include + +// Tests range assign of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + wchar_t s[] = L"a+b|c"; + test_type re; + re.assign(s, s + sizeof(s)); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/string.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/string.cc new file mode 100644 index 00000000000..a5303e267eb --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/string.cc @@ -0,0 +1,44 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include +#include + +// Tests C++ string assignment of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + std::wstring s(L"a*b"); + test_type re; + re.assign(s); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/string_op.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/string_op.cc new file mode 100644 index 00000000000..78ac26d8dfe --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/assign/wchar_t/string_op.cc @@ -0,0 +1,44 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.3] class template basic_regex assign() + +#include +#include +#include + +// Tests basic_regex assignment operator from a C++ string; +void test01() +{ + typedef std::tr1::basic_regex test_type; + + std::wstring s(L"a*b"); + test_type re; + re = s; +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/cstring.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/cstring.cc new file mode 100644 index 00000000000..a349acd8d20 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/cstring.cc @@ -0,0 +1,42 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.2] class template basic_regex constructor + +#include +#include + +// Tests C-style null-terminated-string constructor of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + const char* cs = "aab"; + test_type re(cs); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/default.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/default.cc new file mode 100644 index 00000000000..b499a282b7e --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/default.cc @@ -0,0 +1,47 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.2] class template basic_regex constructor + +#include +#include + +// Tests default constructor of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + // default constructor + test_type re; + + // Check for required typedefs + typedef test_type::value_type value_type; + typedef test_type::flag_type flag_type; + typedef test_type::locale_type locale_type; +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/pstring.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/pstring.cc new file mode 100644 index 00000000000..827c8bf6af7 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/pstring.cc @@ -0,0 +1,42 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.2] class template basic_regex constructor + +#include +#include + +// Tests Pascal-style counted-string constructor of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + const char* cs = "aab"; + test_type re(cs, 3, std::tr1::regex_constants::basic); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/range.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/range.cc new file mode 100644 index 00000000000..53f1f4fc1c8 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/range.cc @@ -0,0 +1,42 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.2] class template basic_regex constructor + +#include +#include + +// Tests range constructor of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + char s[] = "a+b|c"; + test_type re(s, s + sizeof(s)); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/string.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/string.cc new file mode 100644 index 00000000000..0924b1c2015 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/char/string.cc @@ -0,0 +1,43 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.2] class template basic_regex constructor + +#include +#include +#include + +// Tests C++ string constructor of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + std::string s("a*b"); + test_type re(s); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/cstring.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/cstring.cc new file mode 100644 index 00000000000..5e8e70347c3 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/cstring.cc @@ -0,0 +1,42 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.2] class template basic_regex constructor + +#include +#include + +// Tests C-style null-terminated-string constructor of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + const wchar_t* cs = L"aab"; + test_type re(cs); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/default.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/default.cc new file mode 100644 index 00000000000..efdd81a6e14 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/default.cc @@ -0,0 +1,47 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.2] class template basic_regex constructor + +#include +#include + +// Tests default constructor of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + // default constructor + test_type re; + + // Check for required typedefs + typedef test_type::value_type value_type; + typedef test_type::flag_type flag_type; + typedef test_type::locale_type locale_type; +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/pstring.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/pstring.cc new file mode 100644 index 00000000000..f25dee605d8 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/pstring.cc @@ -0,0 +1,42 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.2] class template basic_regex constructor + +#include +#include + +// Tests Pascal-style counted-string constructor of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + const wchar_t* cs = L"aab"; + test_type re(cs, 3, std::tr1::regex_constants::basic); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/range.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/range.cc new file mode 100644 index 00000000000..eb9139a9038 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/range.cc @@ -0,0 +1,42 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.2] class template basic_regex constructor + +#include +#include + +// Tests range constructor of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + wchar_t s[] = L"a+b|c"; + test_type re(s, s + sizeof(s)); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/string.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/string.cc new file mode 100644 index 00000000000..6379fecefc4 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/basic_regex/ctors/wchar_t/string.cc @@ -0,0 +1,43 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.8.2] class template basic_regex constructor + +#include +#include +#include + +// Tests C++ string constructor of the basic_regex class. +void test01() +{ + typedef std::tr1::basic_regex test_type; + + std::wstring s(L"a*b"); + test_type re(s); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/match_results/ctors/char/default.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/match_results/ctors/char/default.cc new file mode 100644 index 00000000000..124e7acde54 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/match_results/ctors/char/default.cc @@ -0,0 +1,58 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.10.1] class template match_results constructor + +#include +#include + +// Tests default constructor of the match_result class. +void test01() +{ + bool test __attribute__((unused)) = true; + typedef std::tr1::match_results test_type; + + // default constructor + test_type m; + + // Check for required typedefs + typedef test_type::value_type value_type; + typedef test_type::const_reference const_reference; + typedef test_type::reference reference; + typedef test_type::const_iterator const_iterator; + typedef test_type::iterator iterator; + typedef test_type::difference_type difference_type; + typedef test_type::size_type size_type; + typedef test_type::allocator_type allocator_type; + typedef test_type::char_type char_type; + typedef test_type::string_type string_type; + + VERIFY( m.size() == 0 ); + VERIFY( m.str() == std::basic_string() ); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_awk.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_awk.cc new file mode 100644 index 00000000000..0b90859f8dc --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_awk.cc @@ -0,0 +1,37 @@ +// { dg-do compile } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// 7.8.2 basic_regex constructors + +#include + +void +test01() +{ + std::tr1::regex re("(a|b)*abb", std::tr1::regex::awk); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_basic.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_basic.cc new file mode 100644 index 00000000000..7451f3bd351 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_basic.cc @@ -0,0 +1,37 @@ +// { dg-do compile } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// 7.8.2 basic_regex constructors + +#include + +void +test01() +{ + std::tr1::regex re("(a|b)*abb", std::tr1::regex::basic); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_ecma.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_ecma.cc new file mode 100644 index 00000000000..8713e64240f --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_ecma.cc @@ -0,0 +1,37 @@ +// { dg-do compile } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// 7.8.2 basic_regex constructors + +#include + +void +test01() +{ + std::tr1::regex re("(a|b)*abb"); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_egrep.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_egrep.cc new file mode 100644 index 00000000000..dd308cfd4a1 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_egrep.cc @@ -0,0 +1,37 @@ +// { dg-do compile } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// 7.8.2 basic_regex constructors + +#include + +void +test01() +{ + std::tr1::regex re("(a|b)*abb", std::tr1::regex::egrep); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_extended.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_extended.cc new file mode 100644 index 00000000000..68e7709722d --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_extended.cc @@ -0,0 +1,43 @@ +// { dg-do run } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// 7.8.2 basic_regex constructors + +#include +#include + +void +test01() +{ + bool test __attribute__((unused)) = true; + + std::tr1::regex re("(wee|week)(knights|night)", std::tr1::regex::extended); + + VERIFY( re.flags() == std::tr1::regex::extended ); + VERIFY( re.mark_count() == 0 ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_grep.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_grep.cc new file mode 100644 index 00000000000..d49e31ce8b4 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/c_string_grep.cc @@ -0,0 +1,39 @@ +// { dg-do compile } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// 7.8.2 basic_regex constructors + +#include + +void +test01() +{ + using std::tr1::regex; + + regex re("(a|b)*abb", regex::grep); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/default.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/default.cc new file mode 100644 index 00000000000..d2568119633 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex/cons/char/default.cc @@ -0,0 +1,37 @@ +// { dg-do compile } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// 7.8.2 basic_regex constructors + +#include + +void +test01() +{ + std::tr1::regex re; +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/char/ctor.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/char/ctor.cc new file mode 100644 index 00000000000..1efb8676517 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/char/ctor.cc @@ -0,0 +1,49 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.7] class template regex_traits + +#include +#include + +// Tests default constructor of the regex_traits class. There is only the +// default constructor. +void test01() +{ + typedef std::tr1::regex_traits test_type; + + // required default constructor + test_type t; + + // Check for required typedefs + typedef test_type::char_type char_type; + typedef test_type::string_type string_type; + typedef test_type::locale_type locale_type; + typedef test_type::char_class_type char_class_type; +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/char/translate_nocase.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/char/translate_nocase.cc new file mode 100644 index 00000000000..14d99dd4588 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/char/translate_nocase.cc @@ -0,0 +1,42 @@ +// { dg-do run } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.7] class template regex_traits (5) translate_nocase + +#include +#include + +// Tests default constructor of the regex_traits class. There is only the +// default constructor. +void test01() +{ + bool test __attribute__((unused)) = true; + std::tr1::regex_traits t; + VERIFY( t.translate_nocase('A') == 'a' ); +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/ctor.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/ctor.cc new file mode 100644 index 00000000000..4ba65c51185 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/ctor.cc @@ -0,0 +1,49 @@ +// { dg-do link } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.7] class template regex_traits + +#include +#include + +// Tests default constructor of the regex_traits class. There is only the +// default constructor. +void test01() +{ + typedef std::tr1::regex_traits test_type; + + // required default constructor + test_type t; + + // Check for required typedefs + typedef test_type::char_type char_type; + typedef test_type::string_type string_type; + typedef test_type::locale_type locale_type; + typedef test_type::char_class_type char_class_type; +} + +int +main() +{ + test01(); + return 0; +}; diff --git a/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/translate_nocase.cc b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/translate_nocase.cc new file mode 100644 index 00000000000..cb6d9b8c5da --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/7_regular_expressions/regex_traits/wchar_t/translate_nocase.cc @@ -0,0 +1,42 @@ +// { dg-do run } + +// 2007-03-12 Stephen M. Webb +// +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// tr1 [7.7] class template regex_traits (5) translate_nocase + +#include +#include + +// Tests default constructor of the regex_traits class. There is only the +// default constructor. +void test01() +{ + bool test __attribute__((unused)) = true; + std::tr1::regex_traits t; + VERIFY( t.translate_nocase(L'A') == L'a' ); +} + +int +main() +{ + test01(); + return 0; +}; -- 2.11.0