+2010-06-25 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+
+ Initial regex implementation.
+
+ * include/std/regex: Modified to use bits/regex_* headers.
+ * include/bits/regex_compiler.h: New file.
+ * include/bits/regex_constants.h: New file.
+ * include/bits/regex_cursor.h: New file.
+ * include/bits/regex_error.h: New file.
+ * include/bits/regex_grep_matcher.h: New file.
+ * include/bits/regex_grep_matcher.tcc: New file.
+ * include/bits/regex.h: New file.
+ * include/bits/regex_nfa.h: New file.
+ * include/bits/regex_nfa.tcc: New file.
+ * include/Makefile.am: Added above new files.
+ * include/Makefile.in: Regenerated.
+ * testsuite/28_regex/02_definitions: New file.
+ * testsuite/28_regex/03_requirements: New file.
+ * testsuite/28_regex/03_requirements/typedefs.cc: New file.
+ * testsuite/28_regex/04_header: New file.
+ * testsuite/28_regex/04_header/regex: New file.
+ * testsuite/28_regex/04_header/regex/std_c++0x_neg.cc: New file.
+ * testsuite/28_regex/05_constants: New file.
+ * testsuite/28_regex/05_constants/error_type.cc: New file.
+ * testsuite/28_regex/05_constants/match_flag_type.cc: New file.
+ * testsuite/28_regex/05_constants/syntax_option_type.cc: New file.
+ * testsuite/28_regex/06_exception_type: New file.
+ * testsuite/28_regex/06_exception_type/regex_error.cc: New file.
+ * testsuite/28_regex/07_traits: New file.
+ * testsuite/28_regex/07_traits/char: New file.
+ * testsuite/28_regex/07_traits/char/ctor.cc: New file.
+ * testsuite/28_regex/07_traits/char/isctype.cc: New file.
+ * testsuite/28_regex/07_traits/char/length.cc: New file.
+ * testsuite/28_regex/07_traits/char/lookup_classname.cc: New file.
+ * testsuite/28_regex/07_traits/char/lookup_collatename.cc: New file.
+ * testsuite/28_regex/07_traits/char/transform.cc: New file.
+ * testsuite/28_regex/07_traits/char/transform_primary.cc: New file.
+ * testsuite/28_regex/07_traits/char/translate.cc: New file.
+ * testsuite/28_regex/07_traits/char/translate_nocase.cc: New file.
+ * testsuite/28_regex/07_traits/char/value.cc: New file.
+ * testsuite/28_regex/07_traits/wchar_t: New file.
+ * testsuite/28_regex/07_traits/wchar_t/ctor.cc: New file.
+ * testsuite/28_regex/07_traits/wchar_t/length.cc: New file.
+ * testsuite/28_regex/07_traits/wchar_t/transform.cc: New file.
+ * testsuite/28_regex/07_traits/wchar_t/translate.cc: New file.
+ * testsuite/28_regex/07_traits/wchar_t/translate_nocase.cc: New file.
+ * testsuite/28_regex/07_traits/wchar_t/value.cc: New file.
+ * testsuite/28_regex/08_basic_regex: New file.
+ * testsuite/28_regex/08_basic_regex/assign: New file.
+ * testsuite/28_regex/08_basic_regex/assign/char: New file.
+ * testsuite/28_regex/08_basic_regex/assign/char/cstring.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/char/cstring_op.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/char/moveable.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/char/pstring.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/char/range.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/char/string.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/char/string_op.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/wchar_t: New file.
+ * testsuite/28_regex/08_basic_regex/assign/wchar_t/cstring.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/wchar_t/cstring_op.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/wchar_t/pstring.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/wchar_t/range.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/wchar_t/string.cc: New file.
+ * testsuite/28_regex/08_basic_regex/assign/wchar_t/string_op.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/basic: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/basic/cstring.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/basic/pstring_char.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/basic/pstring_wchar_t.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/basic/string_range_01_02_03.cc:
+ New file.
+ * testsuite/28_regex/08_basic_regex/ctors/char: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/char/cstring_awk.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/char/cstring.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/char/cstring_ecma.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/char/cstring_egrep.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/char/cstring_grep.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/char/default.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/char/range.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/copy_char.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/extended: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/extended/cstring.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/extended/string_range_01_02_03.cc:
+ New file.
+ * testsuite/28_regex/08_basic_regex/ctors/move_char.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/string_char.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/string_wchar_t.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/wchar_t: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/wchar_t/cstring.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/wchar_t/default.cc: New file.
+ * testsuite/28_regex/08_basic_regex/ctors/wchar_t/range.cc: New file.
+ * testsuite/28_regex/08_basic_regex/regex.cc: New file.
+ * testsuite/28_regex/09_sub_match: New file.
+ * testsuite/28_regex/09_sub_match/cast_char.cc: New file.
+ * testsuite/28_regex/09_sub_match/cast_wchar_t.cc: New file.
+ * testsuite/28_regex/09_sub_match/length.cc: New file.
+ * testsuite/28_regex/09_sub_match/typedefs.cc: New file.
+ * testsuite/28_regex/10_match_results: New file.
+ * testsuite/28_regex/10_match_results/ctors: New file.
+ * testsuite/28_regex/10_match_results/ctors/char: New file.
+ * testsuite/28_regex/10_match_results/ctors/char/default.cc: New file.
+ * testsuite/28_regex/10_match_results/ctors/wchar_t: New file.
+ * testsuite/28_regex/10_match_results/ctors/wchar_t/default.cc: New file.
+ * testsuite/28_regex/10_match_results/typedefs.cc: New file.
+ * testsuite/28_regex/11_algorithms: New file.
+ * testsuite/28_regex/11_algorithms/02_match: New file.
+ * testsuite/28_regex/11_algorithms/02_match/basic: New file.
+ * testsuite/28_regex/11_algorithms/02_match/basic/string_01.cc: New file.
+ * testsuite/28_regex/11_algorithms/02_match/basic/string_range_00_03.cc:
+ New file.
+ * testsuite/28_regex/11_algorithms/02_match/basic/string_range_01_03.cc:
+ New file.
+ * testsuite/28_regex/11_algorithms/02_match/basic/string_range_02_03.cc:
+ New file.
+ * testsuite/28_regex/11_algorithms/02_match/extended: New file.
+ * testsuite/28_regex/11_algorithms/02_match/extended/cstring_plus.cc: New file.
+ * testsuite/28_regex/11_algorithms/02_match/extended/cstring_questionmark.cc:
+ New file.
+ * testsuite/28_regex/11_algorithms/02_match/extended/string_any.cc: New file.
+ * testsuite/28_regex/11_algorithms/02_match/extended/string_range_00_03.cc:
+ New file.
+ * testsuite/28_regex/11_algorithms/02_match/extended/string_range_01_03.cc:
+ New file.
+ * testsuite/28_regex/11_algorithms/02_match/extended/string_range_02_03.cc:
+ New file.
+ * testsuite/28_regex/12_iterators: New file.
+ * testsuite/28_regex/12_iterators/regex_iterator: New file.
+ * testsuite/28_regex/12_iterators/regex_iterator/ctors: New file.
+ * testsuite/28_regex/12_iterators/regex_iterator/ctors/char: New file.
+ * testsuite/28_regex/12_iterators/regex_iterator/ctors/char/default.cc: New
+ file.
+ * testsuite/28_regex/12_iterators/regex_iterator/ctors/wchar_t: New file.
+ * testsuite/28_regex/12_iterators/regex_iterator/ctors/wchar_t/default.cc: New
+ file.
+ * testsuite/28_regex/12_iterators/regex_iterator/typedefs.cc: New file.
+ * testsuite/28_regex/12_iterators/regex_token_iterator: New file.
+ * testsuite/28_regex/12_iterators/regex_token_iterator/ctors: New file.
+ * testsuite/28_regex/12_iterators/regex_token_iterator/ctors/char: New file.
+ * testsuite/28_regex/12_iterators/regex_token_iterator/ctors/char/default.cc:
+ New file.
+ * testsuite/28_regex/12_iterators/regex_token_iterator/ctors/wchar_t: New file.
+ * testsuite/28_regex/12_iterators/regex_token_iterator/ctors/wchar_t/default.cc:
+ New file.
+ * testsuite/28_regex/12_iterators/regex_token_iterator/typedefs.cc: New file.
+ * testsuite/28_regex/13_ecmascript: New file.
+
2010-06-25 Paolo Carlini <paolo.carlini@oracle.com>
* include/profile/impl/profiler_list_to_slist.h: Remove spurious
${bits_srcdir}/postypes.h \
${bits_srcdir}/random.h \
${bits_srcdir}/random.tcc \
+ ${bits_srcdir}/regex.h \
+ ${bits_srcdir}/regex_compiler.h \
+ ${bits_srcdir}/regex_constants.h \
+ ${bits_srcdir}/regex_cursor.h \
+ ${bits_srcdir}/regex_error.h \
+ ${bits_srcdir}/regex_grep_matcher.h \
+ ${bits_srcdir}/regex_grep_matcher.tcc \
+ ${bits_srcdir}/regex_nfa.h \
+ ${bits_srcdir}/regex_nfa.tcc \
${bits_srcdir}/stream_iterator.h \
${bits_srcdir}/streambuf_iterator.h \
${bits_srcdir}/shared_ptr.h \
${bits_srcdir}/postypes.h \
${bits_srcdir}/random.h \
${bits_srcdir}/random.tcc \
+ ${bits_srcdir}/regex.h \
+ ${bits_srcdir}/regex_compiler.h \
+ ${bits_srcdir}/regex_constants.h \
+ ${bits_srcdir}/regex_cursor.h \
+ ${bits_srcdir}/regex_error.h \
+ ${bits_srcdir}/regex_grep_matcher.h \
+ ${bits_srcdir}/regex_grep_matcher.tcc \
+ ${bits_srcdir}/regex_nfa.h \
+ ${bits_srcdir}/regex_nfa.tcc \
${bits_srcdir}/stream_iterator.h \
${bits_srcdir}/streambuf_iterator.h \
${bits_srcdir}/shared_ptr.h \
--- /dev/null
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file bits/regex
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+
+/**
+ * @defgroup regex Regular Expressions
+ * A facility for performing regular expression pattern matching.
+ */
+ //@{
+
+ // [7.7] Class regex_traits
+ /**
+ * @brief Describes aspects of a regular expression.
+ *
+ * A regular expression traits class that satisfies the requirements of
+ * section [28.7].
+ *
+ * The class %regex is parameterized around a set of related types and
+ * functions used to complete the definition of its semantics. This class
+ * satisfies the requirements of such a traits class.
+ */
+ template<typename _Ch_type>
+ struct regex_traits
+ {
+ public:
+ typedef _Ch_type char_type;
+ typedef std::basic_string<char_type> 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 determining the length of a sequence of
+ * characters.
+ */
+ static std::size_t
+ length(const char_type* __p)
+ { return string_type::traits_type::length(__p); }
+
+ /**
+ * @brief Performs the identity translation.
+ *
+ * @param c A character to the locale-specific character set.
+ *
+ * @returns c.
+ */
+ char_type
+ translate(char_type __c) const
+ { return __c; }
+
+ /**
+ * @brief Translates a character into a case-insensitive equivalent.
+ *
+ * @param c A character to the locale-specific character set.
+ *
+ * @returns the locale-specific lower-case equivalent of c.
+ * @throws std::bad_cast if the imbued locale does not support the ctype
+ * facet.
+ */
+ char_type
+ translate_nocase(char_type __c) const
+ {
+ using std::ctype;
+ using std::use_facet;
+ return use_facet<ctype<char_type> >(_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<typename _Fwd_iter>
+ 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 Gets a sort key for a character sequence, independant of case.
+ *
+ * @param first beginning of the character sequence.
+ * @param last one-past-the-end of the character sequence.
+ *
+ * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
+ * typeid(collate_byname<_Ch_type>) and the form of the sort key
+ * returned by collate_byname<_Ch_type>::transform(first, last) is known
+ * and can be converted into a primary sort key then returns that key,
+ * otherwise returns an empty string.
+ *
+ * @todo Implement this function.
+ */
+ template<typename _Fwd_iter>
+ string_type
+ transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
+ { return string_type(); }
+
+ /**
+ * @brief Gets a collation element by name.
+ *
+ * @param first beginning of the collation element name.
+ * @param last one-past-the-end of the collation element name.
+ *
+ * @returns a sequence of one or more characters that represents the
+ * collating element consisting of the character sequence designated by
+ * the iterator range [first, last). Returns an empty string if the
+ * character sequence is not a valid collating element.
+ *
+ * @todo Implement this function.
+ */
+ template<typename _Fwd_iter>
+ string_type
+ lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
+ { return string_type(); }
+
+ /**
+ * @brief Maps one or more characters to a named character
+ * classification.
+ *
+ * @param first beginning of the character sequence.
+ * @param last one-past-the-end of the character sequence.
+ * @param icase ignores the case of the classification name.
+ *
+ * @returns an unspecified value that represents the character
+ * classification named by the character sequence designated by the
+ * iterator range [first, last). If @p icase is true, the returned mask
+ * identifies the classification regardless of the case of the characters
+ * to be matched (for example, [[:lower:]] is the same as [[:alpha:]]),
+ * otherwise a case-dependant classification is returned. The value
+ * returned shall be independent of the case of the characters in the
+ * character sequence. If the name is not recognized then returns a value
+ * that compares equal to 0.
+ *
+ * At least the following names (or their wide-character equivalent) are
+ * supported.
+ * - d
+ * - w
+ * - s
+ * - alnum
+ * - alpha
+ * - blank
+ * - cntrl
+ * - digit
+ * - graph
+ * - lower
+ * - print
+ * - punct
+ * - space
+ * - upper
+ * - xdigit
+ *
+ * @todo Implement this function.
+ */
+ template<typename _Fwd_iter>
+ char_class_type
+ lookup_classname(_Fwd_iter __first, _Fwd_iter __last,
+ bool __icase = false) 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;
+
+ /**
+ * @brief Converts a digit to an int.
+ *
+ * @param ch a character representing a digit.
+ * @param radix the radix if the numeric conversion (limited to 8, 10,
+ * or 16).
+ *
+ * @returns the value represented by the digit ch in base radix if the
+ * character ch is a valid digit in base radix; otherwise returns -1.
+ */
+ int
+ value(_Ch_type __ch, int __radix) const;
+
+ /**
+ * @brief Imbues the regex_traits object with a copy of a new locale.
+ *
+ * @param loc A locale.
+ *
+ * @returns a copy of the previous locale in use by the regex_traits
+ * object.
+ *
+ * @note Calling imbue with a different locale than the one currently in
+ * use invalidates all cached data held by *this.
+ */
+ locale_type
+ imbue(locale_type __loc)
+ {
+ std::swap(_M_locale, __loc);
+ return __loc;
+ }
+
+ /**
+ * @brief Gets a copy of the current locale in use by the regex_traits
+ * object.
+ */
+ locale_type
+ getloc() const
+ { return _M_locale; }
+
+ protected:
+ locale_type _M_locale;
+ };
+
+ template<typename _Ch_type>
+ bool
+ regex_traits<_Ch_type>::
+ 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 __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 (__ctype.is(std::ctype_base::space, __c))
+ {
+ const char __bb[] = "blank";
+ char_class_type __bt = this->lookup_classname(__bb,
+ __bb + sizeof(__bb));
+ if (__f | __bt)
+ return true;
+ }
+
+ return false;
+ }
+
+ template<typename _Ch_type>
+ int
+ regex_traits<_Ch_type>::
+ value(_Ch_type __ch, int __radix) const
+ {
+ std::basic_istringstream<_Ch_type> __is(string_type(1, __ch));
+ int __v;
+ if (__radix == 8)
+ __is >> std::oct;
+ else if (__radix == 16)
+ __is >> std::hex;
+ __is >> __v;
+ return __is.fail() ? -1 : __v;
+ }
+
+ // [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<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type> >
+ 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;
+
+ /**
+ * @name Constants
+ * std [28.8.1](1)
+ * @todo These should be constexpr.
+ */
+ //@{
+ 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_automaton(__regex::__compile<const _Ch_type*, _Rx_traits>(0, 0,
+ _M_traits, _M_flags))
+ { }
+
+ /**
+ * @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_automaton(__regex::__compile(__p, __p + _Rx_traits::length(__p),
+ _M_traits, _M_flags))
+ { }
+
+ /**
+ * @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_automaton(__regex::__compile(__p, __p + __len, _M_traits, _M_flags))
+ { }
+
+ /**
+ * @brief Copy-constructs a basic regular expression.
+ *
+ * @param rhs A @p regex object.
+ */
+ basic_regex(const basic_regex& __rhs)
+ : _M_flags(__rhs._M_flags), _M_traits(__rhs._M_traits),
+ _M_automaton(__rhs._M_automaton)
+ { }
+
+ /**
+ * @brief Move-constructs a basic regular expression.
+ *
+ * @param rhs A @p regex object.
+ */
+ basic_regex(const basic_regex&& __rhs)
+ : _M_flags(__rhs._M_flags), _M_traits(__rhs._M_traits),
+ _M_automaton(std::move(__rhs._M_automaton))
+ { }
+
+ /**
+ * @brief Constructs a basic regular expression from the string
+ * @p s interpreted according to the flags in @p f.
+ *
+ * @param s A string containing a regular expression.
+ * @param f Flags indicating the syntax rules and options.
+ *
+ * @throws regex_error if @p s is not a valid regular expression.
+ */
+ template<typename _Ch_traits, typename _Ch_alloc>
+ explicit
+ basic_regex(const std::basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+ flag_type __f = regex_constants::ECMAScript)
+ : _M_flags(__f),
+ _M_automaton(__regex::__compile(__s.begin(), __s.end(),
+ _M_traits, _M_flags))
+ { }
+
+ /**
+ * @brief Constructs a basic regular expression from the range
+ * [first, last) interpreted according to the flags in @p f.
+ *
+ * @param first The start of a range containing a valid regular
+ * expression.
+ * @param last The end of a range containing a valid regular
+ * expression.
+ * @param f The format flags of the regular expression.
+ *
+ * @throws regex_error if @p [first, last) is not a valid regular
+ * expression.
+ */
+ template<typename _InputIterator>
+ basic_regex(_InputIterator __first, _InputIterator __last,
+ flag_type __f = regex_constants::ECMAScript)
+ : _M_flags(__f),
+ _M_automaton(__regex::__compile(__first, __last, _M_traits, _M_flags))
+ { }
+
+ /**
+ * @brief Constructs a basic regular expression from an initializer list.
+ *
+ * @param l The initializer list.
+ * @param f The format flags of the regular expression.
+ *
+ * @throws regex_error if @p l is not a valid regular expression.
+ */
+ basic_regex(initializer_list<_Ch_type> __l,
+ flag_type __f = regex_constants::ECMAScript)
+ : _M_flags(__f),
+ _M_automaton(__regex::__compile(__l.begin(), __l.end(),
+ _M_traits, _M_flags))
+ { }
+
+ /**
+ * @brief Destroys a basic regular expression.
+ */
+ ~basic_regex()
+ { }
+
+ /**
+ * @brief Assigns one regular expression to another.
+ */
+ basic_regex&
+ operator=(const basic_regex& __rhs)
+ { return this->assign(__rhs); }
+
+ /**
+ * @brief Move-assigns one regular expression to another.
+ */
+ basic_regex&
+ operator=(basic_regex&& __rhs)
+ { return this->assign(std::move(__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<typename _Ch_typeraits, typename _Allocator>
+ 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 rhs Another regular expression object.
+ */
+ basic_regex&
+ assign(const basic_regex& __rhs)
+ {
+ basic_regex __tmp(__rhs);
+ this->swap(__tmp);
+ return *this;
+ }
+
+ /**
+ * @brief The move-assignment operator.
+ *
+ * @param rhs Another regular expression object.
+ */
+ basic_regex&
+ assign(basic_regex&& __rhs)
+ {
+ basic_regex __tmp(std::move(__rhs));
+ this->swap(__tmp);
+ return *this;
+ }
+
+ /**
+ * @brief Assigns a new regular expression to a regex object from a
+ * C-style null-terminated string containing a regular expression
+ * pattern.
+ *
+ * @param p A pointer to a C-style null-terminated string containing
+ * a regular expression pattern.
+ * @param flags Syntax option flags.
+ *
+ * @throws regex_error if p does not contain a valid regular expression
+ * pattern interpreted according to @p flags. If regex_error is thrown,
+ * *this remains unchanged.
+ */
+ basic_regex&
+ assign(const _Ch_type* __p,
+ flag_type __flags = 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<typename _Ch_typeraits, typename _Allocator>
+ 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,
+ * the object remains unchanged.
+ */
+ template<typename _InputIterator>
+ basic_regex&
+ assign(_InputIterator __first, _InputIterator __last,
+ flag_type __flags = regex_constants::ECMAScript)
+ { return this->assign(string_type(__first, __last), __flags); }
+
+ /**
+ * @brief Assigns a new regular expression to a regex object.
+ *
+ * @param l An initializer list representing a regular expression.
+ * @param flags Syntax option flags.
+ *
+ * @throws regex_error if @p l does not contain a valid regular
+ * expression pattern interpreted according to @p flags. If regex_error
+ * is thrown, the object remains unchanged.
+ */
+ basic_regex&
+ assign(initializer_list<_Ch_type> __l,
+ flag_type __f = regex_constants::ECMAScript)
+ { return this->assign(__l.begin(), __l.end(), __f); }
+
+ // [7.8.4] const operations
+ /**
+ * @brief Gets the number of marked subexpressions within the regular
+ * expression.
+ */
+ unsigned int
+ mark_count() const
+ { return _M_automaton->_M_sub_count() - 1; }
+
+ /**
+ * @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 objects.
+ *
+ * @param rhs Another regular expression object.
+ */
+ void
+ swap(basic_regex& __rhs)
+ {
+ std::swap(_M_flags, __rhs._M_flags);
+ std::swap(_M_traits, __rhs._M_traits);
+ std::swap(_M_automaton, __rhs._M_automaton);
+ }
+
+#ifdef _GLIBCXX_DEBUG
+ void
+ _M_dot(std::ostream& __ostr)
+ { _M_automaton->_M_dot(__ostr); }
+#endif
+
+ const __regex::_AutomatonPtr&
+ _M_get_automaton() const
+ { return _M_automaton; }
+
+ protected:
+ flag_type _M_flags;
+ _Rx_traits _M_traits;
+ __regex::_AutomatonPtr _M_automaton;
+ };
+
+ /** @brief Standard regular expressions. */
+ typedef basic_regex<char> regex;
+#ifdef _GLIBCXX_USE_WCHAR_T
+ /** @brief Standard wide-character regular expressions. */
+ typedef basic_regex<wchar_t> 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<typename _Ch_type, typename _Rx_traits>
+ inline void
+ swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
+ basic_regex<_Ch_type, _Rx_traits>& __rhs)
+ { __lhs.swap(__rhs); }
+
+
+ // [7.9] Class template sub_match
+ /**
+ * A sequence of characters matched by a particular marked sub-expression.
+ *
+ * An object of this class is essentially a pair of iterators marking a
+ * matched subexpression within a regular expression pattern match. Such
+ * objects can be converted to and compared with std::basic_string objects
+ * of a similar base character type as the pattern matched by the regular
+ * expression.
+ *
+ * The iterators that make up the pair are the usual half-open interval
+ * referencing the actual original pattern matched.
+ */
+ template<typename _BiIter>
+ 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;
+ typedef std::basic_string<value_type> string_type;
+
+ 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 string_type() const
+ {
+ return this->matched
+ ? string_type(this->first, this->second)
+ : string_type();
+ }
+
+ /**
+ * @brief Gets the matching sequence as a string.
+ *
+ * @returns the matching sequence as a string.
+ */
+ string_type
+ str() const
+ {
+ return this->matched
+ ? string_type(this->first, this->second)
+ : string_type();
+ }
+
+ /**
+ * @brief Compares this and another matched sequence.
+ *
+ * @param s Another matched sequence to compare to this one.
+ *
+ * @retval <0 this matched sequence will collate before @p s.
+ * @retval =0 this matched sequence is equivalent to @p s.
+ * @retval <0 this matched sequence will collate after @p s.
+ */
+ int
+ compare(const sub_match& __s) const
+ { return this->str().compare(__s.str()); }
+
+ /**
+ * @brief Compares this sub_match to a string.
+ *
+ * @param s A string to compare to this sub_match.
+ *
+ * @retval <0 this matched sequence will collate before @p s.
+ * @retval =0 this matched sequence is equivalent to @p s.
+ * @retval <0 this matched sequence will collate after @p s.
+ */
+ int
+ compare(const string_type& __s) const
+ { return this->str().compare(__s); }
+
+ /**
+ * @brief Compares this sub_match to a C-style string.
+ *
+ * @param s A C-style string to compare to this sub_match.
+ *
+ * @retval <0 this matched sequence will collate before @p s.
+ * @retval =0 this matched sequence is equivalent to @p s.
+ * @retval <0 this matched sequence will collate after @p s.
+ */
+ int
+ compare(const value_type* __s) const
+ { return this->str().compare(__s); }
+ };
+
+
+ /** @brief Standard regex submatch over a C-style null-terminated string. */
+ typedef sub_match<const char*> csub_match;
+ /** @brief Standard regex submatch over a standard string. */
+ typedef sub_match<string::const_iterator> ssub_match;
+#ifdef _GLIBCXX_USE_WCHAR_T
+ /** @brief Regex submatch over a C-style null-terminated wide string. */
+ typedef sub_match<const wchar_t*> wcsub_match;
+ /** @brief Regex submatch over a standard wide string. */
+ typedef sub_match<wstring::const_iterator> 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<typename _BiIter>
+ 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<typename _BiIter>
+ 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<typename _BiIter>
+ 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<typename _BiIter>
+ inline bool
+ operator<=(const sub_match<_BiIter>& __lhs,
+ const sub_match<_BiIter>& __rhs)
+ { return __lhs.compare(__rhs) <= 0; }
+
+ /**
+ * @brief Tests the ordering of two regular expression submatches.
+ * @param lhs First regular expression submatch.
+ * @param rhs Second regular expression submatch.
+ * @returns true if @a lhs does not precede @a rhs, false otherwise.
+ */
+ template<typename _BiIter>
+ 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<typename _BiIter>
+ 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<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ 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<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ 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<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ 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<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ 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 precede @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ 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<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ 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<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ 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<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+ 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<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+ 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<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+ 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 precede @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+ 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<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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 precede @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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 precede @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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 precedes @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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 precede @a rhs, false otherwise.
+ */
+ template<typename _Bi_iter>
+ 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<typename _Bi_iter>
+ 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<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
+ 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
+
+ /*
+ * Special sub_match object representing an unmatched sub-expression.
+ */
+ template<typename _Bi_iter>
+ inline const sub_match<_Bi_iter>&
+ __unmatched_sub()
+ {
+ static const sub_match<_Bi_iter> __unmatched = sub_match<_Bi_iter>();
+ return __unmatched;
+ }
+
+ /**
+ * @brief The results of a match or search operation.
+ *
+ * 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.
+ *
+ * @nosubgrouping
+ */
+ template<typename _Bi_iter,
+ typename _Allocator = allocator<sub_match<_Bi_iter> > >
+ class match_results
+ : private std::vector<std::sub_match<_Bi_iter>, _Allocator>
+ {
+ private:
+ /*
+ * The vector base is empty if this does not represent a successful match.
+ * Otherwise it contains n+3 elements where n is the number of marked
+ * sub-expressions:
+ * [0] entire match
+ * [1] 1st marked subexpression
+ * ...
+ * [n] nth marked subexpression
+ * [n+1] prefix
+ * [n+2] suffix
+ */
+ typedef std::vector<std::sub_match<_Bi_iter>, _Allocator>
+ _Base_type;
+
+ public:
+ /**
+ * @name 10.? Public Types
+ */
+ //@{
+ typedef sub_match<_Bi_iter> value_type;
+ typedef const value_type& const_reference;
+ typedef const_reference reference;
+ typedef typename _Base_type::const_iterator const_iterator;
+ typedef const_iterator iterator;
+ typedef typename std::iterator_traits<_Bi_iter>::difference_type
+ difference_type;
+ /* TODO: needs allocator_traits */
+ typedef typename _Allocator::size_type size_type;
+ typedef _Allocator allocator_type;
+ typedef typename std::iterator_traits<_Bi_iter>::value_type
+ char_type;
+ typedef std::basic_string<char_type> string_type;
+ //@}
+
+ public:
+ /**
+ * @name 10.1 Construction, Copying, and Destruction
+ */
+ //@{
+
+ /**
+ * @brief Constructs a default %match_results container.
+ * @post size() returns 0 and str() returns an empty string.
+ */
+ explicit
+ match_results(const _Allocator& __a = _Allocator())
+ : _Base_type(__a)
+ { }
+
+ /**
+ * @brief Copy constructs a %match_results.
+ */
+ match_results(const match_results& __rhs)
+ : _Base_type(__rhs)
+ { }
+
+ /**
+ * @brief Assigns rhs to *this.
+ */
+ match_results&
+ operator=(const match_results __rhs)
+ {
+ match_results(__rhs).swap(*this);
+ return *this;
+ }
+
+ /**
+ * @brief Destroys a %match_results object.
+ */
+ ~match_results()
+ { }
+
+ //@}
+
+ /**
+ * @name 10.2 Size
+ */
+ //@{
+
+ /**
+ * @brief Gets the number of matches and submatches.
+ *
+ * The number of matches for a given regular expression will be either 0
+ * if there was no match or mark_count() + 1 if a match was successful.
+ * Some matches may be empty.
+ *
+ * @returns the number of matches found.
+ */
+ size_type
+ size() const
+ {
+ size_type __size = _Base_type::size();
+ return (__size && _Base_type::operator[](0).matched) ? __size - 2 : 0;
+ }
+
+ size_type
+ max_size() const
+ { return _Base_type::max_size(); }
+
+ /**
+ * @brief Indicates if the %match_results contains no results.
+ * @retval true The %match_results object is empty.
+ * @retval false The %match_results object is not empty.
+ */
+ bool
+ empty() const
+ { return _Base_type::empty(); }
+
+ //@}
+
+ /**
+ * @name 10.3 Element Access
+ */
+ //@{
+
+ /**
+ * @brief Gets the length of the indicated submatch.
+ * @param sub indicates the submatch.
+ *
+ * This function returns the length of the indicated submatch, or the
+ * length of the entire match if @p sub is zero (the default).
+ */
+ difference_type
+ length(size_type __sub = 0) const
+ { return this[__sub].length(); }
+
+ /**
+ * @brief Gets the offset of the beginning of the indicated submatch.
+ * @param sub indicates the submatch.
+ *
+ * This function returns the offset from the beginning of the target
+ * sequence to the beginning of the submatch, unless the value of @p sub
+ * is zero (the default), in which case this function returns the offset
+ * from the beginning of the target sequence to the beginning of the
+ * match.
+ *
+ * Returns -1 if @p sub is out of range.
+ */
+ difference_type
+ position(size_type __sub = 0) const
+ {
+ return __sub < size() ? std::distance(this->prefix().first,
+ (*this)[__sub].first) : -1;
+ }
+
+ /**
+ * @brief Gets the match or submatch converted to a string type.
+ * @param sub indicates the submatch.
+ *
+ * This function gets the submatch (or match, if @p sub is zero) extracted
+ * from the target range and converted to the associated string type.
+ */
+ string_type
+ str(size_type __sub = 0) const
+ { return (*this)[__sub].str(); }
+
+ /**
+ * @brief Gets a %sub_match reference for the match or submatch.
+ * @param sub indicates the submatch.
+ *
+ * This function gets a reference to the indicated submatch, or the entire
+ * match if @p sub is zero.
+ *
+ * If @p sub >= size() then this function returns a %sub_match with a
+ * special value indicating no submatch.
+ */
+ const_reference
+ operator[](size_type __sub) const
+ {
+ return __sub < size()
+ ? _Base_type::operator[](__sub)
+ : __unmatched_sub<_Bi_iter>();
+ }
+
+ /**
+ * @brief Gets a %sub_match representing the match prefix.
+ *
+ * This function gets a reference to a %sub_match object representing the
+ * part of the target range between the start of the target range and the
+ * start of the match.
+ */
+ const_reference
+ prefix() const
+ {
+ return !empty()
+ ? _Base_type::operator[](_Base_type::size() - 2)
+ : __unmatched_sub<_Bi_iter>();
+ }
+
+ /**
+ * @brief Gets a %sub_match representing the match suffix.
+ *
+ * This function gets a reference to a %sub_match object representing the
+ * part of the target range between the end of the match and the end of
+ * the target range.
+ */
+ const_reference
+ suffix() const
+ {
+ return !empty()
+ ? _Base_type::operator[](_Base_type::size() - 1)
+ : __unmatched_sub<_Bi_iter>();
+ }
+
+ /**
+ * @brief Gets an iterator to the start of the %sub_match collection.
+ */
+ const_iterator
+ begin() const
+ { return _Base_type::begin(); }
+
+ /**
+ * @brief Gets an iterator to the start of the %sub_match collection.
+ */
+ const_iterator
+ cbegin() const
+ { return _Base_type::cbegin(); }
+
+ /**
+ * @brief Gets an iterator to one-past-the-end of the collection.
+ */
+ const_iterator
+ end() const
+ {
+ return !empty()
+ ? _Base_type::end() - 2
+ : _Base_type::end();
+ }
+
+ /**
+ * @brief Gets an iterator to one-past-the-end of the collection.
+ */
+ const_iterator
+ cend() const
+ {
+ return !empty()
+ ? _Base_type::cend() - 2
+ : _Base_type::cend();
+ }
+
+ //@}
+
+ /**
+ * @name 10.4 Formatting
+ *
+ * These functions perform formatted substitution of the matched character
+ * sequences into their target. The format specifiers and escape sequences
+ * accepted by these functions are determined by their @p flags parameter
+ * as documented above.
+ */
+ //@{
+
+ /**
+ * @todo Implement this function.
+ */
+ template<typename _Out_iter>
+ _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;
+
+ //@}
+
+ /**
+ * @name 10.5 Allocator
+ */
+ //@{
+
+ /**
+ * @brief Gets a copy of the allocator.
+ */
+ allocator_type
+ get_allocator() const
+ { return _Base_type::get_allocator(); }
+
+ //@}
+
+ /**
+ * @name 10.6 Swap
+ */
+ //@{
+
+ /**
+ * @brief Swaps the contents of two match_results.
+ */
+ void
+ swap(match_results& __that)
+ { _Base_type::swap(__that); }
+ //@}
+
+ private:
+ friend class __regex::_SpecializedResults<_Bi_iter, _Allocator>;
+ };
+
+ typedef match_results<const char*> cmatch;
+ typedef match_results<string::const_iterator> smatch;
+#ifdef _GLIBCXX_USE_WCHAR_T
+ typedef match_results<const wchar_t*> wcmatch;
+ typedef match_results<wstring::const_iterator> wsmatch;
+#endif
+
+ // match_results comparisons
+ /**
+ * @brief Compares two match_results for equality.
+ * @returns true if the two objects refer to the same match,
+ * false otherwise.
+ * @todo Implement this function.
+ */
+ template<typename _Bi_iter, typename _Allocator>
+ inline bool
+ operator==(const match_results<_Bi_iter, _Allocator>& __m1,
+ const match_results<_Bi_iter, _Allocator>& __m2);
+
+ /**
+ * @brief Compares two match_results for inequality.
+ * @returns true if the two objects do not refer to the same match,
+ * false otherwise.
+ */
+ template<typename _Bi_iter, class _Allocator>
+ inline bool
+ operator!=(const match_results<_Bi_iter, _Allocator>& __m1,
+ const match_results<_Bi_iter, _Allocator>& __m2)
+ { return !(__m1 == __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<typename _Bi_iter, typename _Allocator>
+ inline void
+ swap(match_results<_Bi_iter, _Allocator>& __lhs,
+ match_results<_Bi_iter, _Allocator>& __rhs)
+ { __lhs.swap(__rhs); }
+
+ // [7.11.2] Function template regex_match
+ /**
+ * @name Matching, Searching, and Replacing
+ */
+ //@{
+
+ /**
+ * @brief Determines if there is a match between the regular expression @p e
+ * and all of the character sequence [first, last).
+ *
+ * @param s Start of the character sequence to match.
+ * @param e 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.
+ *
+ * @throws an exception of type regex_error.
+ *
+ * @todo Implement this function.
+ */
+ template<typename _Bi_iter, typename _Allocator,
+ typename _Ch_type, typename _Rx_traits>
+ bool
+ regex_match(_Bi_iter __s,
+ _Bi_iter __e,
+ match_results<_Bi_iter, _Allocator>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ regex_constants::match_flag_type __flags
+ = regex_constants::match_default)
+ {
+ __regex::_AutomatonPtr __a = __re._M_get_automaton();
+ __regex::_Automaton::_SizeT __sz = __a->_M_sub_count();
+ __regex::_SpecializedCursor<_Bi_iter> __cs(__s, __e);
+ __regex::_SpecializedResults<_Bi_iter, _Allocator> __r(__sz, __cs, __m);
+ __regex::_Grep_matcher __matcher(__cs, __r, __a, __flags);
+ return __m[0].matched;
+ }
+
+ /**
+ * @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.
+ *
+ * @throws an exception of type regex_error.
+ */
+ template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+ 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.
+ *
+ * @throws an exception of type regex_error.
+ */
+ template<typename _Ch_type, typename _Allocator, typename _Rx_traits>
+ inline bool
+ regex_match(const _Ch_type* __s,
+ match_results<const _Ch_type*, _Allocator>& __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.
+ *
+ * @throws an exception of type regex_error.
+ */
+ template<typename _Ch_traits, typename _Ch_alloc,
+ typename _Allocator, typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+ match_results<typename basic_string<_Ch_type,
+ _Ch_traits, _Ch_alloc>::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.
+ *
+ * @throws an exception of type regex_error.
+ */
+ template<typename _Ch_type, class _Rx_traits>
+ 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.
+ *
+ * @throws an exception of type regex_error.
+ */
+ template<typename _Ch_traits, typename _Str_allocator,
+ typename _Ch_type, typename _Rx_traits>
+ 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.
+ *
+ * @throws an exception of type regex_error.
+ *
+ * @todo Implement this function.
+ */
+ template<typename _Bi_iter, typename _Allocator,
+ typename _Ch_type, typename _Rx_traits>
+ 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.
+ * @doctodo
+ *
+ * @throws an exception of type regex_error.
+ */
+ template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+ 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 matches.
+ * @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.
+ * @doctodo
+ *
+ * @throws an exception of type regex_error.
+ */
+ template<typename _Ch_type, class _Allocator, class _Rx_traits>
+ inline bool
+ regex_search(const _Ch_type* __s,
+ match_results<const _Ch_type*, _Allocator>& __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 expression 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.
+ * @doctodo
+ *
+ * @throws an exception of type regex_error.
+ */
+ template<typename _Ch_type, typename _Rx_traits>
+ 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 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.
+ * @doctodo
+ *
+ * @throws an exception of type regex_error.
+ */
+ template<typename _Ch_traits, typename _String_allocator,
+ typename _Ch_type, typename _Rx_traits>
+ 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 matches.
+ * @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.
+ *
+ * @throws an exception of type regex_error.
+ */
+ template<typename _Ch_traits, typename _Ch_alloc,
+ typename _Allocator, typename _Ch_type,
+ typename _Rx_traits>
+ inline bool
+ regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+ match_results<typename basic_string<_Ch_type,
+ _Ch_traits, _Ch_alloc>::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); }
+
+ // std [28.11.4] Function template regex_replace
+ /**
+ * @doctodo
+ * @param out
+ * @param first
+ * @param last
+ * @param e
+ * @param fmt
+ * @param flags
+ *
+ * @returns out
+ * @throws an exception of type regex_error.
+ *
+ * @todo Implement this function.
+ */
+ template<typename _Out_iter, typename _Bi_iter,
+ typename _Rx_traits, typename _Ch_type>
+ 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; }
+
+ /**
+ * @doctodo
+ * @param s
+ * @param e
+ * @param fmt
+ * @param flags
+ *
+ * @returns a copy of string @p s with replacements.
+ *
+ * @throws an exception of type regex_error.
+ */
+ template<typename _Rx_traits, typename _Ch_type>
+ 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;
+ }
+
+ //@}
+
+ // std [28.12] Class template regex_iterator
+ /**
+ * An iterator adaptor that will provide repeated calls of regex_search over
+ * a range until no more matches remain.
+ */
+ template<typename _Bi_iter,
+ typename _Ch_type = typename iterator_traits<_Bi_iter>::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.
+ * @doctodo
+ */
+ 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.
+ * @doctodo
+ */
+ 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.
+ * @doctodo
+ */
+ regex_iterator(const regex_iterator& __rhs);
+
+ /**
+ * @todo Implement this function.
+ * @doctodo
+ */
+ regex_iterator&
+ operator=(const regex_iterator& __rhs);
+
+ /**
+ * @todo Implement this function.
+ * @doctodo
+ */
+ bool
+ operator==(const regex_iterator& __rhs);
+
+ /**
+ * @todo Implement this function.
+ * @doctodo
+ */
+ bool
+ operator!=(const regex_iterator& __rhs);
+
+ /**
+ * @todo Implement this function.
+ * @doctodo
+ */
+ const value_type&
+ operator*();
+
+ /**
+ * @todo Implement this function.
+ * @doctodo
+ */
+ const value_type*
+ operator->();
+
+ /**
+ * @todo Implement this function.
+ * @doctodo
+ */
+ regex_iterator&
+ operator++();
+
+ /**
+ * @todo Implement this function.
+ * @doctodo
+ */
+ 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<const char*> cregex_iterator;
+ typedef regex_iterator<string::const_iterator> sregex_iterator;
+#ifdef _GLIBCXX_USE_WCHAR_T
+ typedef regex_iterator<const wchar_t*> wcregex_iterator;
+ typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
+#endif
+
+ // [7.12.2] Class template regex_token_iterator
+ /**
+ * Iterates over submatches in a range (or @a 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::sub_match object.
+ */
+ template<typename _Bi_iter,
+ typename _Ch_type = typename iterator_traits<_Bi_iter>::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();
+
+ /**
+ * Constructs a %regex_token_iterator...
+ * @param a [IN] The start of the text to search.
+ * @param b [IN] One-past-the-end 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 this 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.
+ * @doctodo
+ */
+ 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);
+
+ /**
+ * Constructs a %regex_token_iterator...
+ * @param a [IN] The start of the text to search.
+ * @param b [IN] One-past-the-end 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.
+ * @doctodo
+ */
+ regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
+ const regex_type& __re,
+ const std::vector<int>& __submatches,
+ regex_constants::match_flag_type __m
+ = regex_constants::match_default);
+
+ /**
+ * Constructs a %regex_token_iterator...
+ * @param a [IN] The start of the text to search.
+ * @param b [IN] One-past-the-end 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.
+ * @doctodo
+ */
+ template<std::size_t _Nm>
+ 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<int> __subs;
+ };
+
+ /** @brief Token iterator for C-style NULL-terminated strings. */
+ typedef regex_token_iterator<const char*> cregex_token_iterator;
+ /** @brief Token iterator for standard strings. */
+ typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
+#ifdef _GLIBCXX_USE_WCHAR_T
+ /** @brief Token iterator for C-style NULL-terminated wide strings. */
+ typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
+ /** @brief Token iterator for standard wide-character strings. */
+ typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
+#endif
+
+ //@} // group regex
+
+}
+
--- /dev/null
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file bits/regex_parser.h
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+namespace __regex
+{
+ struct _Scanner_base
+ {
+ typedef unsigned int _StateT; // FIXME: replace these constanst with constexpr
+
+ static const _StateT _S_state_at_start = 1 << 0;
+ static const _StateT _S_state_in_brace = 1 << 2;
+ static const _StateT _S_state_in_bracket = 1 << 3;
+ };
+
+ //
+ // @brief Scans an input range for regex tokens.
+ //
+ // The %_Scanner class interprets the regular expression pattern in the input
+ // range passed to its constructor as a sequence of parse tokens passed to
+ // the regular expression compiler. The sequence of tokens provided depends
+ // on the flag settings passed to the constructor: different regular
+ // expression gramars will interpret the same input pattern in syntactically
+ // different ways.
+ //
+ template<typename _InputIterator>
+ class _Scanner: public _Scanner_base
+ {
+ public:
+ typedef _InputIterator _IteratorT;
+ typedef typename std::iterator_traits<_IteratorT>::value_type _CharT;
+ typedef std::basic_string<_CharT> _StringT;
+ typedef regex_constants::syntax_option_type _FlagT;
+ typedef const std::ctype<_CharT> _CtypeT;
+
+ // Token types returned from the scanner.
+ enum _TokenT
+ {
+ _S_token_anychar,
+ _S_token_backref,
+ _S_token_bracket_begin,
+ _S_token_bracket_end,
+ _S_token_inverse_class,
+ _S_token_char_class_name,
+ _S_token_closure0,
+ _S_token_closure1,
+ _S_token_collelem_multi,
+ _S_token_collelem_single,
+ _S_token_collsymbol,
+ _S_token_comma,
+ _S_token_dash,
+ _S_token_dup_count,
+ _S_token_eof,
+ _S_token_equiv_class_name,
+ _S_token_interval_begin,
+ _S_token_interval_end,
+ _S_token_line_begin,
+ _S_token_line_end,
+ _S_token_opt,
+ _S_token_or,
+ _S_token_ord_char,
+ _S_token_quoted_char,
+ _S_token_subexpr_begin,
+ _S_token_subexpr_end,
+ _S_token_word_begin,
+ _S_token_word_end,
+ _S_token_unknown
+ };
+
+ public:
+ _Scanner(_IteratorT __begin, _IteratorT __end, _FlagT __flags,
+ std::locale __loc)
+ : _M_current(__begin) , _M_end(__end) , _M_flags(__flags),
+ _M_ctype(std::use_facet<_CtypeT>(__loc)), _M_state(_S_state_at_start)
+ { _M_advance(); }
+
+ void
+ _M_advance();
+
+ _TokenT
+ _M_token() const
+ { return _M_curToken; }
+
+ const _StringT&
+ _M_value() const
+ { return _M_curValue; }
+
+#ifdef _GLIBCXX_DEBUG
+ std::ostream&
+ _M_print(std::ostream&);
+#endif
+
+ private:
+ void
+ _M_eat_escape();
+
+ void
+ _M_scan_in_brace();
+
+ void
+ _M_scan_in_bracket();
+
+ void
+ _M_eat_charclass();
+
+ void
+ _M_eat_equivclass();
+
+ void
+ _M_eat_collsymbol();
+
+ private:
+ _IteratorT _M_current;
+ _IteratorT _M_end;
+ _FlagT _M_flags;
+ _CtypeT& _M_ctype;
+ _TokenT _M_curToken;
+ _StringT _M_curValue;
+ _StateT _M_state;
+ };
+
+ template<typename _InputIterator>
+ void
+ _Scanner<_InputIterator>::
+ _M_advance()
+ {
+ if (_M_current == _M_end)
+ {
+ _M_curToken = _S_token_eof;
+ return;
+ }
+
+ _CharT __c = *_M_current;
+ if (_M_state & _S_state_in_bracket)
+ {
+ _M_scan_in_bracket();
+ return;
+ }
+ if (_M_state & _S_state_in_brace)
+ {
+ _M_scan_in_brace();
+ return;
+ }
+ else if (_M_state & _S_state_at_start && __c == _M_ctype.widen('^'))
+ {
+ _M_curToken = _S_token_line_begin;
+ ++_M_current;
+ return;
+ }
+ else if (__c == _M_ctype.widen('$'))
+ {
+ _M_curToken = _S_token_line_end;
+ ++_M_current;
+ return;
+ }
+ else if (__c == _M_ctype.widen('.'))
+ {
+ _M_curToken = _S_token_anychar;
+ ++_M_current;
+ return;
+ }
+ else if (__c == _M_ctype.widen('*'))
+ {
+ _M_curToken = _S_token_closure0;
+ ++_M_current;
+ return;
+ }
+ else if (__c == _M_ctype.widen('+'))
+ {
+ _M_curToken = _S_token_closure1;
+ ++_M_current;
+ return;
+ }
+ else if (__c == _M_ctype.widen('|'))
+ {
+ _M_curToken = _S_token_or;
+ ++_M_current;
+ return;
+ }
+ else if (__c == _M_ctype.widen('['))
+ {
+ _M_curToken = _S_token_bracket_begin;
+ _M_state |= (_S_state_in_bracket | _S_state_at_start);
+ ++_M_current;
+ return;
+ }
+ else if (__c == _M_ctype.widen('\\'))
+ {
+ _M_eat_escape();
+ return;
+ }
+ else if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
+ {
+ if (__c == _M_ctype.widen('('))
+ {
+ _M_curToken = _S_token_subexpr_begin;
+ ++_M_current;
+ return;
+ }
+ else if (__c == _M_ctype.widen(')'))
+ {
+ _M_curToken = _S_token_subexpr_end;
+ ++_M_current;
+ return;
+ }
+ else if (__c == _M_ctype.widen('{'))
+ {
+ _M_curToken = _S_token_interval_begin;
+ _M_state |= _S_state_in_brace;
+ ++_M_current;
+ return;
+ }
+ }
+
+ _M_curToken = _S_token_ord_char;
+ _M_curValue.assign(1, __c);
+ ++_M_current;
+ }
+
+
+ template<typename _InputIterator>
+ void
+ _Scanner<_InputIterator>::
+ _M_scan_in_brace()
+ {
+ if (_M_ctype.is(_CtypeT::digit, *_M_current))
+ {
+ _M_curToken = _S_token_dup_count;
+ _M_curValue.assign(1, *_M_current);
+ ++_M_current;
+ while (_M_current != _M_end && _M_ctype.is(_CtypeT::digit, *_M_current))
+ {
+ _M_curValue += *_M_current;
+ ++_M_current;
+ }
+ return;
+ }
+ else if (*_M_current == _M_ctype.widen(','))
+ {
+ _M_curToken = _S_token_comma;
+ ++_M_current;
+ return;
+ }
+ if (_M_flags & (regex_constants::basic | regex_constants::grep))
+ {
+ if (*_M_current == _M_ctype.widen('\\'))
+ { _M_eat_escape(); }
+ }
+ else
+ {
+ if (*_M_current == _M_ctype.widen('}'))
+ {
+ _M_curToken = _S_token_interval_end;
+ _M_state &= ~_S_state_in_brace;
+ ++_M_current;
+ return;
+ }
+ }
+ }
+
+ template<typename _InputIterator>
+ void
+ _Scanner<_InputIterator>::
+ _M_scan_in_bracket()
+ {
+ if (_M_state & _S_state_at_start && *_M_current == _M_ctype.widen('^'))
+ {
+ _M_curToken = _S_token_inverse_class;
+ _M_state &= ~_S_state_at_start;
+ ++_M_current;
+ return;
+ }
+ else if (*_M_current == _M_ctype.widen('['))
+ {
+ ++_M_current;
+ if (_M_current == _M_end)
+ {
+ _M_curToken = _S_token_eof;
+ return;
+ }
+
+ if (*_M_current == _M_ctype.widen('.'))
+ {
+ _M_curToken = _S_token_collsymbol;
+ _M_eat_collsymbol();
+ return;
+ }
+ else if (*_M_current == _M_ctype.widen(':'))
+ {
+ _M_curToken = _S_token_char_class_name;
+ _M_eat_charclass();
+ return;
+ }
+ else if (*_M_current == _M_ctype.widen('='))
+ {
+ _M_curToken = _S_token_equiv_class_name;
+ _M_eat_equivclass();
+ return;
+ }
+ }
+ else if (*_M_current == _M_ctype.widen('-'))
+ {
+ _M_curToken = _S_token_dash;
+ ++_M_current;
+ return;
+ }
+ else if (*_M_current == _M_ctype.widen(']'))
+ {
+ if (!(_M_flags & regex_constants::ECMAScript)
+ || !(_M_state & _S_state_at_start))
+ {
+ // special case: only if _not_ chr first after '[' or '[^' and if not
+ // ECMAscript
+ _M_curToken = _S_token_bracket_end;
+ ++_M_current;
+ return;
+ }
+ }
+ _M_curToken = _S_token_collelem_single;
+ _M_curValue.assign(1, *_M_current);
+ ++_M_current;
+ }
+
+ template<typename _InputIterator>
+ void
+ _Scanner<_InputIterator>::
+ _M_eat_escape()
+ {
+ ++_M_current;
+ if (_M_current == _M_end)
+ {
+ _M_curToken = _S_token_eof;
+ return;
+ }
+ _CharT __c = *_M_current;
+ ++_M_current;
+
+ if (__c == _M_ctype.widen('('))
+ {
+ if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
+ {
+ _M_curToken = _S_token_ord_char;
+ _M_curValue.assign(1, __c);
+ }
+ else
+ {
+ _M_curToken = _S_token_subexpr_begin;
+ }
+ }
+ else if (__c == _M_ctype.widen(')'))
+ {
+ if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
+ {
+ _M_curToken = _S_token_ord_char;
+ _M_curValue.assign(1, __c);
+ }
+ else
+ {
+ _M_curToken = _S_token_subexpr_end;
+ }
+ }
+ else if (__c == _M_ctype.widen('{'))
+ {
+ if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
+ {
+ _M_curToken = _S_token_ord_char;
+ _M_curValue.assign(1, __c);
+ }
+ else
+ {
+ _M_curToken = _S_token_interval_begin;
+ _M_state |= _S_state_in_brace;
+ }
+ }
+ else if (__c == _M_ctype.widen('}'))
+ {
+ if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
+ {
+ _M_curToken = _S_token_ord_char;
+ _M_curValue.assign(1, __c);
+ }
+ else
+ {
+ if (!(_M_state && _S_state_in_brace))
+ __throw_regex_error(regex_constants::error_badbrace);
+ _M_state &= ~_S_state_in_brace;
+ _M_curToken = _S_token_interval_end;
+ }
+ }
+ else if (__c == _M_ctype.widen('x'))
+ {
+ ++_M_current;
+ if (_M_current == _M_end)
+ {
+ _M_curToken = _S_token_eof;
+ return;
+ }
+ if (_M_ctype.is(_CtypeT::digit, *_M_current))
+ {
+ _M_curValue.assign(1, *_M_current);
+ ++_M_current;
+ if (_M_current == _M_end)
+ {
+ _M_curToken = _S_token_eof;
+ return;
+ }
+ if (_M_ctype.is(_CtypeT::digit, *_M_current))
+ {
+ _M_curValue += *_M_current;
+ ++_M_current;
+ return;
+ }
+ }
+ }
+ else if (__c == _M_ctype.widen('^')
+ || __c == _M_ctype.widen('.')
+ || __c == _M_ctype.widen('*')
+ || __c == _M_ctype.widen('$')
+ || __c == _M_ctype.widen('\\'))
+ {
+ _M_curToken = _S_token_ord_char;
+ _M_curValue.assign(1, __c);
+ }
+ else if (_M_ctype.is(_CtypeT::digit, __c))
+ {
+ _M_curToken = _S_token_backref;
+ _M_curValue.assign(1, __c);
+ }
+ else
+ {
+ __throw_regex_error(regex_constants::error_escape);
+ }
+ }
+
+
+ // Eats a character class or throwns an exception.
+ // current point to ':' delimiter on entry, char after ']' on return
+ template<typename _InputIterator>
+ void
+ _Scanner<_InputIterator>::
+ _M_eat_charclass()
+ {
+ ++_M_current; // skip ':'
+ if (_M_current == _M_end)
+ __throw_regex_error(regex_constants::error_ctype);
+ for (_M_curValue.clear();
+ _M_current != _M_end && *_M_current != _M_ctype.widen(':');
+ ++_M_current)
+ _M_curValue += *_M_current;
+ if (_M_current == _M_end)
+ __throw_regex_error(regex_constants::error_ctype);
+ ++_M_current; // skip ':'
+ if (*_M_current != _M_ctype.widen(']'))
+ __throw_regex_error(regex_constants::error_ctype);
+ ++_M_current; // skip ']'
+ }
+
+
+ template<typename _InputIterator>
+ void
+ _Scanner<_InputIterator>::
+ _M_eat_equivclass()
+ {
+ ++_M_current; // skip '='
+ if (_M_current == _M_end)
+ __throw_regex_error(regex_constants::error_collate);
+ for (_M_curValue.clear();
+ _M_current != _M_end && *_M_current != _M_ctype.widen('=');
+ ++_M_current)
+ _M_curValue += *_M_current;
+ if (_M_current == _M_end)
+ __throw_regex_error(regex_constants::error_collate);
+ ++_M_current; // skip '='
+ if (*_M_current != _M_ctype.widen(']'))
+ __throw_regex_error(regex_constants::error_collate);
+ ++_M_current; // skip ']'
+ }
+
+
+ template<typename _InputIterator>
+ void
+ _Scanner<_InputIterator>::
+ _M_eat_collsymbol()
+ {
+ ++_M_current; // skip '.'
+ if (_M_current == _M_end)
+ __throw_regex_error(regex_constants::error_collate);
+ for (_M_curValue.clear();
+ _M_current != _M_end && *_M_current != _M_ctype.widen('.');
+ ++_M_current)
+ _M_curValue += *_M_current;
+ if (_M_current == _M_end)
+ __throw_regex_error(regex_constants::error_collate);
+ ++_M_current; // skip '.'
+ if (*_M_current != _M_ctype.widen(']'))
+ __throw_regex_error(regex_constants::error_collate);
+ ++_M_current; // skip ']'
+ }
+
+#ifdef _GLIBCXX_DEBUG
+ template<typename _InputIterator>
+ std::ostream&
+ _Scanner<_InputIterator>::
+ _M_print(std::ostream& ostr)
+ {
+ switch (_M_curToken)
+ {
+ case _S_token_anychar:
+ ostr << "any-character\n";
+ break;
+ case _S_token_backref:
+ ostr << "backref\n";
+ break;
+ case _S_token_bracket_begin:
+ ostr << "bracket-begin\n";
+ break;
+ case _S_token_bracket_end:
+ ostr << "bracket-end\n";
+ break;
+ case _S_token_char_class_name:
+ ostr << "char-class-name \"" << _M_curValue << "\"\n";
+ break;
+ case _S_token_closure0:
+ ostr << "closure0\n";
+ break;
+ case _S_token_closure1:
+ ostr << "closure1\n";
+ break;
+ case _S_token_collelem_multi:
+ ostr << "coll-elem-multi \"" << _M_curValue << "\"\n";
+ break;
+ case _S_token_collelem_single:
+ ostr << "coll-elem-single \"" << _M_curValue << "\"\n";
+ break;
+ case _S_token_collsymbol:
+ ostr << "collsymbol \"" << _M_curValue << "\"\n";
+ break;
+ case _S_token_comma:
+ ostr << "comma\n";
+ break;
+ case _S_token_dash:
+ ostr << "dash\n";
+ break;
+ case _S_token_dup_count:
+ ostr << "dup count: " << _M_curValue << "\n";
+ break;
+ case _S_token_eof:
+ ostr << "EOF\n";
+ break;
+ case _S_token_equiv_class_name:
+ ostr << "equiv-class-name \"" << _M_curValue << "\"\n";
+ break;
+ case _S_token_interval_begin:
+ ostr << "interval begin\n";
+ break;
+ case _S_token_interval_end:
+ ostr << "interval end\n";
+ break;
+ case _S_token_line_begin:
+ ostr << "line begin\n";
+ break;
+ case _S_token_line_end:
+ ostr << "line end\n";
+ break;
+ case _S_token_opt:
+ ostr << "opt\n";
+ break;
+ case _S_token_or:
+ ostr << "or\n";
+ break;
+ case _S_token_ord_char:
+ ostr << "ordinary character: \"" << _M_value() << "\"\n";
+ break;
+ case _S_token_quoted_char:
+ ostr << "quoted char\n";
+ break;
+ case _S_token_subexpr_begin:
+ ostr << "subexpr begin\n";
+ break;
+ case _S_token_subexpr_end:
+ ostr << "subexpr end\n";
+ break;
+ case _S_token_word_begin:
+ ostr << "word begin\n";
+ break;
+ case _S_token_word_end:
+ ostr << "word end\n";
+ break;
+ case _S_token_unknown:
+ ostr << "-- unknown token --\n";
+ break;
+ }
+ return ostr;
+ }
+#endif
+
+ // Builds an NFA from an input iterator interval.
+ template<typename _InIter, typename _TraitsT>
+ class _Compiler
+ {
+ public:
+ typedef _InIter _IterT;
+ typedef typename std::iterator_traits<_InIter>::value_type _CharT;
+ typedef std::basic_string<_CharT> _StringT;
+ typedef regex_constants::syntax_option_type _FlagT;
+
+ public:
+ _Compiler(const _InIter& __b, const _InIter& __e,
+ _TraitsT& __traits, _FlagT __flags);
+
+ const _Nfa&
+ _M_nfa() const
+ { return _M_state_store; }
+
+ private:
+ typedef _Scanner<_InIter> _ScannerT;
+ typedef typename _ScannerT::_TokenT _TokenT;
+ typedef std::stack<_StateSeq, std::vector<_StateSeq> > _StackT;
+ typedef _RangeMatcher<_InIter, _TraitsT> _RMatcherT;
+
+ // accepts a specific token or returns false.
+ bool
+ _M_match_token(_TokenT token);
+
+ void
+ _M_disjunction();
+
+ bool
+ _M_alternative();
+
+ bool
+ _M_term();
+
+ bool
+ _M_assertion();
+
+ bool
+ _M_quantifier();
+
+ bool
+ _M_atom();
+
+ bool
+ _M_bracket_expression();
+
+ bool
+ _M_bracket_list(_RMatcherT& __matcher);
+
+ bool
+ _M_follow_list(_RMatcherT& __matcher);
+
+ bool
+ _M_follow_list2(_RMatcherT& __matcher);
+
+ bool
+ _M_expression_term(_RMatcherT& __matcher);
+
+ bool
+ _M_range_expression(_RMatcherT& __matcher);
+
+ bool
+ _M_start_range(_RMatcherT& __matcher);
+
+ bool
+ _M_collating_symbol(_RMatcherT& __matcher);
+
+ bool
+ _M_equivalence_class(_RMatcherT& __matcher);
+
+ bool
+ _M_character_class(_RMatcherT& __matcher);
+
+ int
+ _M_cur_int_value(int __radix);
+
+ private:
+ _TraitsT& _M_traits;
+ _ScannerT _M_scanner;
+ _StringT _M_cur_value;
+ _Nfa _M_state_store;
+ _StackT _M_stack;
+ };
+
+ template<typename _InIter, typename _TraitsT>
+ _Compiler<_InIter, _TraitsT>::
+ _Compiler(const _InIter& __b, const _InIter& __e, _TraitsT& __traits,
+ _Compiler<_InIter, _TraitsT>::_FlagT __flags)
+ : _M_traits(__traits), _M_scanner(__b, __e, __flags, _M_traits.getloc()),
+ _M_state_store(__flags)
+ {
+ using std::bind;
+ using std::placeholders::_1;
+ using std::placeholders::_2;
+ typedef _StartTagger<_InIter, _TraitsT> _Start;
+ typedef _EndTagger<_InIter, _TraitsT> _End;
+
+ _StateSeq __r(_M_state_store,
+ _M_state_store._M_insert_subexpr_begin(
+ bind(_Start(0), _1, _2)));
+ _M_disjunction();
+ if (!_M_stack.empty())
+ {
+ __r._M_append(_M_stack.top());
+ _M_stack.pop();
+ }
+ __r._M_append(_M_state_store._M_insert_subexpr_end(0,
+ bind(_End(0), _1, _2)));
+ __r._M_append(_M_state_store._M_insert_accept());
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_match_token(_Compiler<_InIter, _TraitsT>::_TokenT token)
+ {
+ if (token == _M_scanner._M_token())
+ {
+ _M_cur_value = _M_scanner._M_value();
+ _M_scanner._M_advance();
+ return true;
+ }
+ return false;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ void
+ _Compiler<_InIter, _TraitsT>::
+ _M_disjunction()
+ {
+ this->_M_alternative();
+ if (_M_match_token(_ScannerT::_S_token_or))
+ {
+ _StateSeq __alt1 = _M_stack.top(); _M_stack.pop();
+ this->_M_disjunction();
+ _StateSeq __alt2 = _M_stack.top(); _M_stack.pop();
+ _M_stack.push(_StateSeq(__alt1, __alt2));
+ }
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_alternative()
+ {
+ if (this->_M_term())
+ {
+ _StateSeq __re = _M_stack.top(); _M_stack.pop();
+ this->_M_alternative();
+ if (!_M_stack.empty())
+ {
+ __re._M_append(_M_stack.top());
+ _M_stack.pop();
+ }
+ _M_stack.push(__re);
+ return true;
+ }
+ return false;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_term()
+ {
+ if (this->_M_assertion())
+ return true;
+ if (this->_M_atom())
+ {
+ this->_M_quantifier();
+ return true;
+ }
+ return false;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_assertion()
+ {
+ if (_M_match_token(_ScannerT::_S_token_line_begin))
+ {
+ // __m.push(_Matcher::_S_opcode_line_begin);
+ return true;
+ }
+ if (_M_match_token(_ScannerT::_S_token_line_end))
+ {
+ // __m.push(_Matcher::_S_opcode_line_end);
+ return true;
+ }
+ if (_M_match_token(_ScannerT::_S_token_word_begin))
+ {
+ // __m.push(_Matcher::_S_opcode_word_begin);
+ return true;
+ }
+ if (_M_match_token(_ScannerT::_S_token_word_end))
+ {
+ // __m.push(_Matcher::_S_opcode_word_end);
+ return true;
+ }
+ return false;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_quantifier()
+ {
+ if (_M_match_token(_ScannerT::_S_token_closure0))
+ {
+ if (_M_stack.empty())
+ __throw_regex_error(regex_constants::error_badrepeat);
+ _StateSeq __r(_M_stack.top(), -1);
+ __r._M_append(__r._M_front());
+ _M_stack.pop();
+ _M_stack.push(__r);
+ return true;
+ }
+ if (_M_match_token(_ScannerT::_S_token_closure1))
+ {
+ if (_M_stack.empty())
+ __throw_regex_error(regex_constants::error_badrepeat);
+ _StateSeq __r(_M_state_store,
+ _M_state_store._M_insert_alt(_S_invalid_state_id,
+ _M_stack.top()._M_front()));
+ _M_stack.top()._M_append(__r);
+ return true;
+ }
+ if (_M_match_token(_ScannerT::_S_token_opt))
+ {
+ if (_M_stack.empty())
+ __throw_regex_error(regex_constants::error_badrepeat);
+ _StateSeq __r(_M_stack.top(), -1);
+ _M_stack.pop();
+ _M_stack.push(__r);
+ return true;
+ }
+ if (_M_match_token(_ScannerT::_S_token_interval_begin))
+ {
+ if (_M_stack.empty())
+ __throw_regex_error(regex_constants::error_badrepeat);
+ if (!_M_match_token(_ScannerT::_S_token_dup_count))
+ __throw_regex_error(regex_constants::error_badbrace);
+ _StateSeq __r(_M_stack.top());
+ int __min_rep = _M_cur_int_value(10);
+ for (int __i = 1; __i < __min_rep; ++__i)
+ _M_stack.top()._M_append(__r._M_clone());
+ if (_M_match_token(_ScannerT::_S_token_comma))
+ if (_M_match_token(_ScannerT::_S_token_dup_count))
+ {
+ int __n = _M_cur_int_value(10) - __min_rep;
+ if (__n < 0)
+ __throw_regex_error(regex_constants::error_badbrace);
+ for (int __i = 0; __i < __n; ++__i)
+ {
+ _StateSeq __r(_M_state_store,
+ _M_state_store._M_insert_alt(_S_invalid_state_id,
+ _M_stack.top()._M_front()));
+ _M_stack.top()._M_append(__r);
+ }
+ }
+ else
+ {
+ _StateSeq __r(_M_stack.top(), -1);
+ __r._M_push_back(__r._M_front());
+ _M_stack.pop();
+ _M_stack.push(__r);
+ }
+ if (!_M_match_token(_ScannerT::_S_token_interval_end))
+ __throw_regex_error(regex_constants::error_brace);
+ return true;
+ }
+ return false;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_atom()
+ {
+ using std::bind;
+ using std::placeholders::_1;
+ using std::placeholders::_2;
+ typedef _CharMatcher<_InIter, _TraitsT> _CMatcher;
+ typedef _StartTagger<_InIter, _TraitsT> _Start;
+ typedef _EndTagger<_InIter, _TraitsT> _End;
+
+ if (_M_match_token(_ScannerT::_S_token_anychar))
+ {
+ _M_stack.push(_StateSeq(_M_state_store,
+ _M_state_store._M_insert_matcher(bind(_AnyMatcher, _1))));
+ return true;
+ }
+ if (_M_match_token(_ScannerT::_S_token_ord_char))
+ {
+ _M_stack.push(_StateSeq(_M_state_store,
+ _M_state_store._M_insert_matcher(
+ bind(_CMatcher(_M_cur_value[0], _M_traits), _1))));
+ return true;
+ }
+ if (_M_match_token(_ScannerT::_S_token_quoted_char))
+ {
+ // note that in the ECMA grammar, this case covers backrefs.
+ _M_stack.push(_StateSeq(_M_state_store,
+ _M_state_store._M_insert_matcher(
+ bind(_CMatcher(_M_cur_value[0], _M_traits), _1))));
+ return true;
+ }
+ if (_M_match_token(_ScannerT::_S_token_backref))
+ {
+ // __m.push(_Matcher::_S_opcode_ordchar, _M_cur_value);
+ return true;
+ }
+ if (_M_match_token(_ScannerT::_S_token_subexpr_begin))
+ {
+ int __mark = _M_state_store._M_sub_count();
+ _StateSeq __r(_M_state_store,
+ _M_state_store._M_insert_subexpr_begin(bind(_Start(__mark), _1, _2)));
+ this->_M_disjunction();
+ if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
+ __throw_regex_error(regex_constants::error_paren);
+ if (!_M_stack.empty())
+ {
+ __r._M_append(_M_stack.top());
+ _M_stack.pop();
+ }
+ __r._M_append(_M_state_store._M_insert_subexpr_end(__mark,
+ bind(_End(__mark), _1, _2)));
+ _M_stack.push(__r);
+ return true;
+ }
+ return _M_bracket_expression();
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_bracket_expression()
+ {
+ using std::bind;
+ using std::placeholders::_1;
+ if (_M_match_token(_ScannerT::_S_token_bracket_begin))
+ {
+ _RMatcherT __matcher(_M_match_token(_ScannerT::_S_token_line_begin),
+ _M_traits);
+ if (!_M_bracket_list(__matcher)
+ || !_M_match_token(_ScannerT::_S_token_bracket_end))
+ __throw_regex_error(regex_constants::error_brack);
+ _M_stack.push(_StateSeq(_M_state_store,
+ _M_state_store._M_insert_matcher(
+ bind(__matcher, _1))));
+ return true;
+ }
+ return false;
+ }
+
+ // If the dash is the last character in the bracket expression, it is not
+ // special.
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_bracket_list(_RMatcherT& __matcher)
+ {
+ if (_M_follow_list(__matcher))
+ {
+ if (_M_match_token(_ScannerT::_S_token_dash))
+ __matcher._M_add_char(_M_cur_value[0]);
+ return true;
+ }
+ return false;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_follow_list(_RMatcherT& __matcher)
+ { return _M_expression_term(__matcher) && _M_follow_list2(__matcher); }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_follow_list2(_RMatcherT& __matcher)
+ {
+ if (_M_expression_term(__matcher))
+ return _M_follow_list2(__matcher);
+ return true;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_expression_term(_RMatcherT& __matcher)
+ {
+ return _M_collating_symbol(__matcher)
+ || _M_character_class(__matcher)
+ || _M_equivalence_class(__matcher)
+ || (_M_start_range(__matcher) && _M_range_expression(__matcher));
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_range_expression(_RMatcherT& __matcher)
+ {
+ if (!_M_collating_symbol(__matcher))
+ if (!_M_match_token(_ScannerT::_S_token_dash))
+ __throw_regex_error(regex_constants::error_range);
+ __matcher._M_make_range();
+ return true;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_start_range(_RMatcherT& __matcher)
+ { return _M_match_token(_ScannerT::_S_token_dash); }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_collating_symbol(_RMatcherT& __matcher)
+ {
+ if (_M_match_token(_ScannerT::_S_token_collelem_single))
+ {
+ __matcher._M_add_char(_M_cur_value[0]);
+ return true;
+ }
+ if (_M_match_token(_ScannerT::_S_token_collsymbol))
+ {
+ __matcher._M_add_collating_element(_M_cur_value);
+ return true;
+ }
+ return false;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_equivalence_class(_RMatcherT& __matcher)
+ {
+ if (_M_match_token(_ScannerT::_S_token_equiv_class_name))
+ {
+ __matcher._M_add_equivalence_class(_M_cur_value);
+ return true;
+ }
+ return false;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ bool
+ _Compiler<_InIter, _TraitsT>::
+ _M_character_class(_RMatcherT& __matcher)
+ {
+ if (_M_match_token(_ScannerT::_S_token_char_class_name))
+ {
+ __matcher._M_add_character_class(_M_cur_value);
+ return true;
+ }
+ return false;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ int
+ _Compiler<_InIter, _TraitsT>::
+ _M_cur_int_value(int __radix)
+ {
+ int __v = 0;
+ for (typename _StringT::size_type __i = 0;
+ __i < _M_cur_value.length(); ++__i)
+ __v =__v * __radix + _M_traits.value(_M_cur_value[__i], __radix);
+ return __v;
+ }
+
+ template<typename _InIter, typename _TraitsT>
+ _AutomatonPtr
+ __compile(const _InIter& __b, const _InIter& __e, _TraitsT& __t,
+ regex_constants::syntax_option_type __f)
+ { return _AutomatonPtr(new _Nfa(_Compiler<_InIter, _TraitsT>(__b, __e, __t,
+ __f)._M_nfa())); }
+
+} // namespace __regex
+} // namespace std
+
+/* vim: set ts=8 sw=2 sts=2: */
--- /dev/null
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file bits/regex_constants
+ * @brief Constant definitions for the std regex library.
+ *
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+
+/**
+ * @namespace std::regex_constants
+ * @brief ISO C++-0x entities sub namespace for regex.
+ */
+namespace regex_constants
+{
+ /**
+ * @name 5.1 Regular Expression Syntax Options
+ */
+ //@{
+ 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 section [28.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:
+ * \\\\, \\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;
+
+ //@}
+
+ /**
+ * @name 5.2 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.
+ *
+ */
+ //@{
+
+ 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.
+ *
+ * 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;
+
+ /**
+ * The default matching rules.
+ */
+ 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 matches 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]):
+ * @li $$ The dollar-sign itself ($)
+ * @li $& The matched substring.
+ * @li $` The portion of @a string that precedes the matched substring.
+ * This would be match_results::prefix().
+ * @li $' The portion of @a string that follows the matched substring.
+ * This would be match_results::suffix().
+ * @li $n The nth capture, where n is in [1,9] and $n is not followed by a
+ * decimal digit. If n <= match_results::size() and the nth capture
+ * is undefined, use the empty string instead. If n >
+ * match_results::size(), the result is implementation-defined.
+ * @li $nn The nnth capture, where nn is a two-digit decimal number on
+ * [01, 99]. If nn <= match_results::size() and the nth capture is
+ * undefined, use the empty string instead. If
+ * nn > match_results::size(), 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;
+
+ //@}
+
+} // namespace regex_constants
+} // namespace std
+
--- /dev/null
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file bits/regex_cursor.h
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+namespace __regex
+{
+ // ABC for pattern matching
+ struct _PatternCursor
+ {
+ virtual ~_PatternCursor() { };
+ virtual void _M_next() = 0;
+ virtual bool _M_at_end() const = 0;
+ };
+
+ // Provides a cursor into the specific target string.
+ template<typename _FwdIterT>
+ class _SpecializedCursor
+ : public _PatternCursor
+ {
+ public:
+ _SpecializedCursor(const _FwdIterT& __b, const _FwdIterT __e)
+ : _M_b(__b), _M_c(__b), _M_e(__e)
+ { }
+
+ typename std::iterator_traits<_FwdIterT>::value_type
+ _M_current() const
+ { return *_M_c; }
+
+ void
+ _M_next()
+ { ++_M_c; }
+
+ _FwdIterT
+ _M_pos() const
+ { return _M_c; }
+
+ const _FwdIterT&
+ _M_begin() const
+ { return _M_b; }
+
+ const _FwdIterT&
+ _M_end() const
+ { return _M_e; }
+
+ bool
+ _M_at_end() const
+ { return _M_c == _M_e; }
+
+ private:
+ _FwdIterT _M_b;
+ _FwdIterT _M_c;
+ _FwdIterT _M_e;
+ };
+
+ // Helper funxtion to create a cursor specialized for an iterator class.
+ template<typename _FwdIterT>
+ _SpecializedCursor<_FwdIterT>
+ __cursor(const _FwdIterT& __b, const _FwdIterT __e)
+ { return _SpecializedCursor<_FwdIterT>(__b, __e); }
+
+} // namespace __regex
+} // namespace std
+
+/* vim: set ts=8 sw=2 sts=2: */
--- /dev/null
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file bits/regex_error
+ * @brief Error and exception objects for the std regex library.
+ *
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+
+namespace regex_constants
+{
+ /**
+ * @name 5.3 Error Types
+ */
+ //@{
+
+ 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 <em>*?+{<em> 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
+ /**
+ * @brief A regular expression exception class.
+ * @ingroup exceptions
+ *
+ * The regular expression library throws objects of this class on error.
+ */
+ 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;
+ };
+
+
+ inline void
+ __throw_regex_error(regex_constants::error_type __ecode)
+ { throw regex_error(__ecode); }
+
+} // namespace std
+
--- /dev/null
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file bits/regex_executor.h
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+
+namespace std
+{
+ template<typename _BiIter>
+ class sub_match;
+
+ template<typename _Bi_iter, typename _Allocator>
+ class match_results;
+
+namespace __regex
+{
+ // A _Results facade specialized for wrapping a templated sub_match.
+ template<typename _FwdIterT, typename _Alloc>
+ class _SpecializedResults
+ : public _Results
+ {
+ public:
+ _SpecializedResults(const _Automaton::_SizeT __size,
+ const _SpecializedCursor<_FwdIterT>& __cursor,
+ match_results<_FwdIterT, _Alloc>& __m);
+
+ void
+ _M_set_pos(int __i, int __j, const _PatternCursor& __pc);
+
+ void
+ _M_set_matched(int __i, bool __is_matched)
+ { _M_results.at(__i).matched = __is_matched; }
+
+ private:
+ match_results<_FwdIterT, _Alloc>& _M_results;
+ };
+
+ template<typename _FwdIterT, typename _Alloc>
+ _SpecializedResults<_FwdIterT, _Alloc>::
+ _SpecializedResults(const _Automaton::_SizeT __size,
+ const _SpecializedCursor<_FwdIterT>& __cursor,
+ match_results<_FwdIterT, _Alloc>& __m)
+ : _M_results(__m)
+ {
+ typedef typename match_results<_FwdIterT, _Alloc>::size_type size_type;
+ _M_results.clear();
+ std::sub_match<_FwdIterT> __sm;
+ __sm.matched = false;
+ size_type __result_count = __size + 2;
+ for (size_type __i = 0; __i < __result_count; ++__i)
+ _M_results.push_back(__sm);
+ _M_results.at(__size+0).first = __cursor._M_begin();
+ _M_results.at(__size+0).second = __cursor._M_begin();
+ _M_results.at(__size+1).first = __cursor._M_end();
+ _M_results.at(__size+1).second = __cursor._M_end();
+ }
+
+ template<typename _FwdIterT, typename _Alloc>
+ void
+ _SpecializedResults<_FwdIterT, _Alloc>::
+ _M_set_pos(int __i, int __j, const _PatternCursor& __pc)
+ {
+ typedef const _SpecializedCursor<_FwdIterT>& _CursorT;
+ _CursorT __c = static_cast<_CursorT>(__pc);
+ if (__j == 0)
+ _M_results.at(__i).first = __c._M_pos();
+ else
+ _M_results.at(__i).second = __c._M_pos()+1;
+ }
+
+ // A stack of states used in evaluating the NFA.
+ typedef std::stack<_StateIdT, std::vector<_StateIdT> > _StateStack;
+
+ // Executes a regular expression NFA/DFA over a range using a variant of
+ // the parallel execution algorithm featured in the grep utility, modified
+ // to use Laurikari tags.
+ class _Grep_matcher
+ {
+ public:
+ _Grep_matcher(_PatternCursor& __p,
+ _Results& __r,
+ const _AutomatonPtr& __automaton,
+ regex_constants::match_flag_type __flags);
+
+ private:
+ _StateSet
+ _M_e_closure(_StateIdT __i);
+
+ _StateSet
+ _M_e_closure(const _StateSet& __s);
+
+ _StateSet
+ _M_e_closure(_StateStack& __stack, const _StateSet& __s);
+
+ private:
+ const std::shared_ptr<_Nfa> _M_nfa;
+ _PatternCursor& _M_pattern;
+ _Results& _M_results;
+ };
+
+} // namespace __regex
+} // namespace std
+
+#include <bits/regex_grep_matcher.tcc>
+
+/* vim: set ts=8 sw=2 sts=2: */
--- /dev/null
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file regex_grep_matcher.cc
+ */
+#include <regex>
+
+namespace std
+{
+
+namespace
+{
+
+ // A stack of states used in evaluating the NFA.
+ typedef std::stack<
+ std::__regex::_StateIdT,
+ std::vector<std::__regex::_StateIdT>
+ > _StateStack;
+
+ // Obtains the next state set given the current state set __s and the current
+ // input character.
+ inline std::__regex::_StateSet
+ __move(const std::__regex::_PatternCursor& __p,
+ const std::__regex::_Nfa& __nfa,
+ const std::__regex::_StateSet& __s)
+ {
+ std::__regex::_StateSet __m;
+ for (std::__regex::_StateSet::const_iterator __i = __s.begin();
+ __i != __s.end(); ++__i)
+ {
+ if (*__i == std::__regex::_S_invalid_state_id)
+ continue;
+
+ const std::__regex::_State& __state = __nfa[*__i];
+ if (__state._M_opcode == std::__regex::_S_opcode_match
+ && __state._M_matches(__p))
+ __m.insert(__state._M_next);
+ }
+ return __m;
+ }
+
+ // returns true if (__s intersect __t) is not empty
+ inline bool
+ __includes_some(const std::__regex::_StateSet& __s,
+ const std::__regex::_StateSet& __t)
+ {
+ if (__s.size() > 0 && __t.size() > 0)
+ {
+ std::__regex::_StateSet::const_iterator __first = __s.begin();
+ std::__regex::_StateSet::const_iterator __second = __t.begin();
+ while (__first != __s.end() && __second != __t.end())
+ {
+ if (*__first < *__second)
+ ++__first;
+ else if (*__second < *__first)
+ ++__second;
+ else
+ return true;
+ }
+ }
+ return false;
+ }
+
+ // If an identified state __u is not already in the current state set __e,
+ // insert it and push it on the current state stack __s.
+ inline void
+ __add_visited_state(const std::__regex::_StateIdT __u,
+ _StateStack& __s,
+ std::__regex::_StateSet& __e)
+ {
+ if (__e.count(__u) == 0)
+ {
+ __e.insert(__u);
+ __s.push(__u);
+ }
+ }
+
+} // anonymous namespace
+
+namespace __regex
+{
+ inline _Grep_matcher::
+ _Grep_matcher(_PatternCursor& __p,
+ _Results& __r,
+ const _AutomatonPtr& __nfa,
+ regex_constants::match_flag_type __flags)
+ : _M_nfa(static_pointer_cast<_Nfa>(__nfa)), _M_pattern(__p), _M_results(__r)
+ {
+ __regex::_StateSet __t = this->_M_e_closure(_M_nfa->_M_start());
+ for (; !_M_pattern._M_at_end(); _M_pattern._M_next())
+ __t = this->_M_e_closure(__move(_M_pattern, *_M_nfa, __t));
+
+ _M_results._M_set_matched(0,
+ __includes_some(_M_nfa->_M_final_states(), __t));
+ }
+
+ // Creates the e-closure set for the initial state __i.
+ inline _StateSet _Grep_matcher::
+ _M_e_closure(_StateIdT __i)
+ {
+ _StateSet __s;
+ __s.insert(__i);
+ _StateStack __stack;
+ __stack.push(__i);
+ return this->_M_e_closure(__stack, __s);
+ }
+
+ // Creates the e-closure set for an arbitrary state set __s.
+ inline _StateSet _Grep_matcher::
+ _M_e_closure(const _StateSet& __s)
+ {
+ _StateStack __stack;
+ for (_StateSet::const_iterator __i = __s.begin(); __i != __s.end(); ++__i)
+ __stack.push(*__i);
+ return this->_M_e_closure(__stack, __s);
+ }
+
+ inline _StateSet _Grep_matcher::
+ _M_e_closure(_StateStack& __stack, const _StateSet& __s)
+ {
+ _StateSet __e = __s;
+ while (!__stack.empty())
+ {
+ _StateIdT __t = __stack.top(); __stack.pop();
+ if (__t == _S_invalid_state_id)
+ continue;
+ // for each __u with edge from __t to __u labeled e do ...
+ const _State& __state = _M_nfa->operator[](__t);
+ switch (__state._M_opcode)
+ {
+ case _S_opcode_alternative:
+ __add_visited_state(__state._M_next, __stack, __e);
+ __add_visited_state(__state._M_alt, __stack, __e);
+ break;
+ case _S_opcode_subexpr_begin:
+ __add_visited_state(__state._M_next, __stack, __e);
+ __state._M_tagger(_M_pattern, _M_results);
+ break;
+ case _S_opcode_subexpr_end:
+ __add_visited_state(__state._M_next, __stack, __e);
+ __state._M_tagger(_M_pattern, _M_results);
+ _M_results._M_set_matched(__state._M_subexpr, true);
+ break;
+ case _S_opcode_accept:
+ __add_visited_state(__state._M_next, __stack, __e);
+ break;
+ default:
+ break;
+ }
+ }
+ return __e;
+ }
+
+} // namespace __regex
+} // namespace std
+
+/* vim: set ts=8 sw=2 sts=2: */
--- /dev/null
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file bits/regex_nfa.h
+ * This is an internal header file, included by other library headers.
+ * You should not attempt to use it directly.
+ */
+
+namespace std
+{
+namespace __regex
+{
+
+ // Base class for, um, automata. Could be an NFA or a DFA. Your choice.
+ class _Automaton
+ {
+ public:
+ typedef unsigned int _SizeT;
+
+ public:
+ virtual
+ ~_Automaton()
+ { }
+
+ virtual _SizeT
+ _M_sub_count() const = 0;
+
+#ifdef _GLIBCXX_DEBUG
+ virtual std::ostream&
+ _M_dot(std::ostream& __ostr) const = 0;
+#endif
+ };
+
+ // Generic shred pointer to an automaton.
+ typedef std::shared_ptr<_Automaton> _AutomatonPtr;
+
+ // Operation codes that define the type of transitions within the base NFA
+ // that represents the regular expression.
+ enum _Opcode
+ {
+ _S_opcode_unknown = 0,
+ _S_opcode_alternative = 1,
+ _S_opcode_subexpr_begin = 4,
+ _S_opcode_subexpr_end = 5,
+ _S_opcode_match = 100,
+ _S_opcode_accept = 255
+ };
+
+ // Provides a generic facade for a templated match_results.
+ struct _Results
+ {
+ virtual void _M_set_pos(int __i, int __j, const _PatternCursor& __p) = 0;
+ virtual void _M_set_matched(int __i, bool __is_matched) = 0;
+ };
+
+ // Tags current state (for subexpr begin/end).
+ typedef std::function<void (const _PatternCursor&, _Results&)> _Tagger;
+
+ template<typename _FwdIterT, typename _TraitsT>
+ struct _StartTagger
+ : public _Tagger
+ {
+ explicit
+ _StartTagger(int __i)
+ : _M_index(__i)
+ { }
+
+ void
+ operator()(const _PatternCursor& __pc, _Results& __r)
+ { __r._M_set_pos(_M_index, 0, __pc); }
+
+ int _M_index;
+ };
+
+ template<typename _FwdIterT, typename _TraitsT>
+ struct _EndTagger
+ : public _Tagger
+ {
+ explicit
+ _EndTagger(int __i)
+ : _M_index(__i)
+ { }
+
+ void
+ operator()(const _PatternCursor& __pc, _Results& __r)
+ { __r._M_set_pos(_M_index, 1, __pc); }
+
+ int _M_index;
+ _FwdIterT _M_pos;
+ };
+ // Indicates if current state matches cursor current.
+ typedef std::function<bool (const _PatternCursor&)> _Matcher;
+
+ // Matches any character
+ inline bool
+ _AnyMatcher(const _PatternCursor&)
+ { return true; }
+
+ // Matches a single character
+ template<typename _InIterT, typename _TraitsT>
+ struct _CharMatcher
+ : public _Matcher
+ {
+ typedef typename _TraitsT::char_type char_type;
+
+ explicit
+ _CharMatcher(char_type __c, const _TraitsT& __t = _TraitsT())
+ : _M_traits(__t), _M_c(_M_traits.translate(__c))
+ { }
+
+ bool
+ operator()(const _PatternCursor& __pc) const
+ {
+ typedef const _SpecializedCursor<_InIterT>& _CursorT;
+ _CursorT __c = static_cast<_CursorT>(__pc);
+ return _M_traits.translate(__c._M_current()) == _M_c;
+ }
+
+ const _TraitsT& _M_traits;
+ char_type _M_c;
+ };
+
+ // Matches a character range (bracket expression)
+ template<typename _InIterT, typename _TraitsT>
+ struct _RangeMatcher
+ : public _Matcher
+ {
+ typedef typename _TraitsT::char_type _CharT;
+ typedef std::basic_string<_CharT> _StringT;
+
+ explicit
+ _RangeMatcher(bool __is_non_matching, const _TraitsT& __t = _TraitsT())
+ : _M_traits(__t), _M_is_non_matching(__is_non_matching)
+ { }
+
+ bool
+ operator()(const _PatternCursor& __pc) const
+ {
+ typedef const _SpecializedCursor<_InIterT>& _CursorT;
+ _CursorT __c = static_cast<_CursorT>(__pc);
+ return true;
+ }
+
+ void
+ _M_add_char(_CharT __c)
+ { }
+
+ void
+ _M_add_collating_element(const _StringT& __s)
+ { }
+
+ void
+ _M_add_equivalence_class(const _StringT& __s)
+ { }
+
+ void
+ _M_add_character_class(const _StringT& __s)
+ { }
+
+ void
+ _M_make_range()
+ { }
+
+ const _TraitsT& _M_traits;
+ bool _M_is_non_matching;
+ };
+
+ // Identifies a state in the NFA.
+ typedef int _StateIdT;
+
+ // The special case in which a state identifier is not an index.
+ static const _StateIdT _S_invalid_state_id = -1;
+
+
+ // An individual state in an NFA
+ //
+ // In this case a "state" is an entry in the NFA definition coupled with its
+ // outgoing transition(s). All states have a single outgoing transition,
+ // except for accepting states (which have no outgoing transitions) and alt
+ // states, which have two outgoing transitions.
+ //
+ struct _State
+ {
+ typedef int _OpcodeT;
+
+ _OpcodeT _M_opcode; // type of outgoing transition
+ _StateIdT _M_next; // outgoing tranition
+ _StateIdT _M_alt; // for _S_opcode_alternative
+ unsigned int _M_subexpr; // for _S_opcode_subexpr_*
+ _Tagger _M_tagger; // for _S_opcode_subexpr_*
+ _Matcher _M_matches; // for _S_opcode_match
+
+ explicit _State(_OpcodeT __opcode)
+ : _M_opcode(__opcode), _M_next(_S_invalid_state_id)
+ { }
+
+ _State(const _Matcher& __m)
+ : _M_opcode(_S_opcode_match), _M_next(_S_invalid_state_id), _M_matches(__m)
+ { }
+
+ _State(_OpcodeT __opcode, unsigned int __s, const _Tagger& __t)
+ : _M_opcode(__opcode), _M_next(_S_invalid_state_id), _M_subexpr(__s),
+ _M_tagger(__t)
+ { }
+
+ _State(_StateIdT __next, _StateIdT __alt)
+ : _M_opcode(_S_opcode_alternative), _M_next(__next), _M_alt(__alt)
+ { }
+
+#ifdef _GLIBCXX_DEBUG
+ std::ostream&
+ _M_print(std::ostream& ostr) const;
+
+ // Prints graphviz dot commands for state.
+ std::ostream&
+ _M_dot(std::ostream& __ostr, _StateIdT __id) const;
+#endif
+ };
+
+
+ // The Grep Matcher works on sets of states. Here are sets of states.
+ typedef std::set<_StateIdT> _StateSet;
+
+ // A collection of all states making up an NFA
+ //
+ // An NFA is a 4-tuple M = (K, S, s, F), where
+ // K is a finite set of states,
+ // S is the alphabet of the NFA,
+ // s is the initial state,
+ // F is a set of final (accepting) states.
+ //
+ // This NFA class is templated on S, a type that will hold values of the
+ // underlying alphabet (without regard to semantics of that alphabet). The
+ // other elements of the tuple are generated during construction of the NFA
+ // and are available through accessor member functions.
+ //
+ class _Nfa
+ : public _Automaton, public std::vector<_State>
+ {
+ public:
+ typedef _State _StateT;
+ typedef unsigned int _SizeT;
+ typedef regex_constants::syntax_option_type _FlagT;
+
+ public:
+ _Nfa(_FlagT __f)
+ : _M_flags(__f), _M_start_state(0), _M_subexpr_count(0)
+ { }
+
+ ~_Nfa()
+ { }
+
+ _FlagT
+ _M_options() const
+ { return _M_flags; }
+
+ _StateIdT
+ _M_start() const
+ { return _M_start_state; }
+
+ const _StateSet&
+ _M_final_states() const
+ { return _M_accepting_states; }
+
+ _SizeT
+ _M_sub_count() const
+ { return _M_subexpr_count; }
+
+ _StateIdT
+ _M_insert_accept()
+ {
+ this->push_back(_StateT(_S_opcode_accept));
+ _M_accepting_states.insert(this->size()-1);
+ return this->size()-1;
+ }
+
+ _StateIdT
+ _M_insert_alt(_StateIdT __next, _StateIdT __alt)
+ {
+ this->push_back(_StateT(__next, __alt));
+ return this->size()-1;
+ }
+
+ _StateIdT
+ _M_insert_matcher(_Matcher __m)
+ {
+ this->push_back(_StateT(__m));
+ return this->size()-1;
+ }
+
+ _StateIdT
+ _M_insert_subexpr_begin(const _Tagger& __t)
+ {
+ this->push_back(_StateT(_S_opcode_subexpr_begin, _M_subexpr_count++, __t));
+ return this->size()-1;
+ }
+
+ _StateIdT
+ _M_insert_subexpr_end(unsigned int __i, const _Tagger& __t)
+ {
+ this->push_back(_StateT(_S_opcode_subexpr_end, __i, __t));
+ return this->size()-1;
+ }
+
+#ifdef _GLIBCXX_DEBUG
+ std::ostream&
+ _M_dot(std::ostream& __ostr) const;
+#endif
+
+ private:
+ _FlagT _M_flags;
+ _StateIdT _M_start_state;
+ _StateSet _M_accepting_states;
+ _SizeT _M_subexpr_count;
+ };
+
+ // Describes a sequence of one or more %_State, its current start and end(s).
+ //
+ // This structure contains fragments of an NFA during construction.
+ class _StateSeq
+ {
+ public:
+ // Constructs a single-node sequence
+ _StateSeq(_Nfa& __ss, _StateIdT __s, _StateIdT __e = _S_invalid_state_id)
+ : _M_nfa(__ss), _M_start(__s), _M_end1(__s), _M_end2(__e)
+ { }
+ // Constructs a split sequence from two other sequencces
+ _StateSeq(const _StateSeq& __e1, const _StateSeq& __e2)
+ : _M_nfa(__e1._M_nfa),
+ _M_start(_M_nfa._M_insert_alt(__e1._M_start, __e2._M_start)),
+ _M_end1(__e1._M_end1), _M_end2(__e2._M_end1)
+ { }
+
+ // Constructs a split sequence from a single sequence
+ _StateSeq(const _StateSeq& __e, _StateIdT __id)
+ : _M_nfa(__e._M_nfa),
+ _M_start(_M_nfa._M_insert_alt(__id, __e._M_start)),
+ _M_end1(__id), _M_end2(__e._M_end1)
+ { }
+
+ // Constructs a copy of a %_StateSeq
+ _StateSeq(const _StateSeq& __rhs)
+ : _M_nfa(__rhs._M_nfa), _M_start(__rhs._M_start),
+ _M_end1(__rhs._M_end1), _M_end2(__rhs._M_end2)
+ { }
+
+
+ _StateSeq& operator=(const _StateSeq& __rhs);
+
+ _StateIdT
+ _M_front() const
+ { return _M_start; }
+
+ // Extends a sequence by one.
+ void
+ _M_push_back(_StateIdT __id);
+
+ // Extends and maybe joins a sequence.
+ void
+ _M_append(_StateIdT __id);
+
+ void
+ _M_append(_StateSeq& __rhs);
+
+ // Clones an entire sequence.
+ _StateIdT
+ _M_clone();
+
+ private:
+ _Nfa& _M_nfa;
+ _StateIdT _M_start;
+ _StateIdT _M_end1;
+ _StateIdT _M_end2;
+
+ };
+
+} // namespace __regex
+} // namespace std
+
+#include <bits/regex_nfa.tcc>
+
--- /dev/null
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file regex_nfa.cc
+ */
+#include <regex>
+
+namespace std
+{
+namespace __regex
+{
+#ifdef _GLIBCXX_DEBUG
+inline std::ostream& _State::
+_M_print(std::ostream& ostr) const
+{
+ switch (_M_opcode)
+ {
+ case _S_opcode_alternative:
+ ostr << "alt next=" << _M_next << " alt=" << _M_alt;
+ break;
+ case _S_opcode_subexpr_begin:
+ ostr << "subexpr begin next=" << _M_next << " index=" << _M_subexpr;
+ break;
+ case _S_opcode_subexpr_end:
+ ostr << "subexpr end next=" << _M_next << " index=" << _M_subexpr;
+ break;
+ case _S_opcode_match:
+ ostr << "match next=" << _M_next;
+ break;
+ case _S_opcode_accept:
+ ostr << "accept next=" << _M_next;
+ break;
+ default:
+ ostr << "unknown next=" << _M_next;
+ break;
+ }
+ return ostr;
+}
+
+// Prints graphviz dot commands for state.
+inline std::ostream& _State::
+_M_dot(std::ostream& __ostr, _StateIdT __id) const
+{
+ switch (_M_opcode)
+ {
+ case _S_opcode_alternative:
+ __ostr << __id << " [label=\"" << __id << "\\nALT\"];\n"
+ << __id << " -> " << _M_next
+ << " [label=\"epsilon\", tailport=\"s\"];\n"
+ << __id << " -> " << _M_alt
+ << " [label=\"epsilon\", tailport=\"n\"];\n";
+ break;
+ case _S_opcode_subexpr_begin:
+ __ostr << __id << " [label=\"" << __id << "\\nSBEGIN "
+ << _M_subexpr << "\"];\n"
+ << __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
+ break;
+ case _S_opcode_subexpr_end:
+ __ostr << __id << " [label=\"" << __id << "\\nSEND "
+ << _M_subexpr << "\"];\n"
+ << __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
+ break;
+ case _S_opcode_match:
+ __ostr << __id << " [label=\"" << __id << "\\nMATCH\"];\n"
+ << __id << " -> " << _M_next << " [label=\"<match>\"];\n";
+ break;
+ case _S_opcode_accept:
+ __ostr << __id << " [label=\"" << __id << "\\nACC\"];\n" ;
+ break;
+ default:
+ __ostr << __id << " [label=\"" << __id << "\\nUNK\"];\n"
+ << __id << " -> " << _M_next << " [label=\"?\"];\n";
+ break;
+ }
+ return __ostr;
+}
+
+inline std::ostream& _Nfa::
+_M_dot(std::ostream& __ostr) const
+{
+ __ostr << "digraph _Nfa {\n"
+ << " rankdir=LR;\n";
+ for (unsigned int __i = 0; __i < this->size(); ++__i)
+ { this->at(__i)._M_dot(__ostr, __i); }
+ __ostr << "}\n";
+ return __ostr;
+}
+#endif
+
+inline _StateSeq& _StateSeq::
+operator=(const _StateSeq& __rhs)
+{
+ _M_start = __rhs._M_start;
+ _M_end1 = __rhs._M_end1;
+ _M_end2 = __rhs._M_end2;
+ return *this;
+}
+
+inline void _StateSeq::
+_M_push_back(_StateIdT __id)
+{
+ if (_M_end1 != _S_invalid_state_id)
+ _M_nfa[_M_end1]._M_next = __id;
+ _M_end1 = __id;
+}
+
+inline void _StateSeq::
+_M_append(_StateIdT __id)
+{
+ if (_M_end2 != _S_invalid_state_id)
+ {
+ if (_M_end2 == _M_end1)
+ _M_nfa[_M_end2]._M_alt = __id;
+ else
+ _M_nfa[_M_end2]._M_next = __id;
+ _M_end2 = _S_invalid_state_id;
+ }
+ if (_M_end1 != _S_invalid_state_id)
+ _M_nfa[_M_end1]._M_next = __id;
+ _M_end1 = __id;
+}
+
+inline void _StateSeq::
+_M_append(_StateSeq& __rhs)
+{
+ if (_M_end2 != _S_invalid_state_id)
+ {
+ if (_M_end2 == _M_end1)
+ _M_nfa[_M_end2]._M_alt = __rhs._M_start;
+ else
+ _M_nfa[_M_end2]._M_next = __rhs._M_start;
+ _M_end2 = _S_invalid_state_id;
+ }
+ if (__rhs._M_end2 != _S_invalid_state_id)
+ _M_end2 = __rhs._M_end2;
+ if (_M_end1 != _S_invalid_state_id)
+ _M_nfa[_M_end1]._M_next = __rhs._M_start;
+ _M_end1 = __rhs._M_end1;
+}
+
+// @todo implement this function.
+inline _StateIdT _StateSeq::
+_M_clone()
+{ return 0; }
+
+} // namespace __regex
+} // namespace std
+
# include <bits/c++0x_warning.h>
#else
-#if defined(_GLIBCXX_INCLUDE_AS_TR1)
-# error C++0x header cannot be included from TR1 header
-#endif
-
#include <algorithm>
#include <bitset>
+#include <functional>
+#ifdef _GLIBCXX_DEBUG
+# include <iosfwd>
+#endif
#include <iterator>
#include <locale>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <stack>
#include <stdexcept>
#include <string>
-#include <vector>
#include <utility>
-#include <sstream>
+#include <vector>
-#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
-# include <tr1_impl/regex>
-#else
-# define _GLIBCXX_INCLUDE_AS_CXX0X
-# define _GLIBCXX_BEGIN_NAMESPACE_TR1
-# define _GLIBCXX_END_NAMESPACE_TR1
-# define _GLIBCXX_TR1
-# include <tr1_impl/regex>
-# undef _GLIBCXX_TR1
-# undef _GLIBCXX_END_NAMESPACE_TR1
-# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
-# undef _GLIBCXX_INCLUDE_AS_CXX0X
-#endif
+#include <bits/regex_constants.h>
+#include <bits/regex_error.h>
+#include <bits/regex_cursor.h>
+#include <bits/regex_nfa.h>
+#include <bits/regex_compiler.h>
+#include <bits/regex_grep_matcher.h>
+#include <bits/regex.h>
#endif // __GXX_EXPERIMENTAL_CXX0X__
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-02-17 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.3 Requirements [re.req]
+// 28.2 (4) Table 127 - Regular expression traits class requirements
+
+#include <regex>
+
+void
+test01()
+{
+ typedef std::regex_traits<char> traits;
+
+ typedef traits::char_type char_type;
+ typedef traits::string_type string_type;
+ typedef traits::locale_type locale_type;
+ typedef traits::char_class_type char_class_type;
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++98" }
+
+// Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <regex> // { dg-excess-errors "In file included from" }
+
+
--- /dev/null
+// { dg-options "-std=c++0x" }
+// { dg-do compile }
+//
+// 2009-06-17 Stephen M. Webb <stephen.webb@xandros.com>
+//
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.5.3
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex_constants::error_type err __attribute__((unused));
+
+ err = std::regex_constants::error_collate;
+ err = std::regex_constants::error_ctype;
+ err = std::regex_constants::error_escape;
+ err = std::regex_constants::error_backref;
+ err = std::regex_constants::error_brack;
+ err = std::regex_constants::error_paren;
+ err = std::regex_constants::error_brace;
+ err = std::regex_constants::error_badbrace;
+ err = std::regex_constants::error_range;
+ err = std::regex_constants::error_space;
+ err = std::regex_constants::error_badrepeat;
+ err = std::regex_constants::error_complexity;
+ err = std::regex_constants::error_stack;
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=c++0x" }
+// { dg-do compile }
+//
+// 2009-06-17 Stephen M. Webb <stephen.webb@xandros.com>
+//
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.5.1
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex_constants::match_flag_type flag = std::regex_constants::match_default;
+
+ flag |= std::regex_constants::match_not_bol;
+ flag |= std::regex_constants::match_not_eol;
+ flag |= std::regex_constants::match_not_bow;
+ flag |= std::regex_constants::match_not_eow;
+ flag |= std::regex_constants::match_any;
+ flag |= std::regex_constants::match_not_null;
+ flag |= std::regex_constants::match_continuous;
+ flag |= std::regex_constants::match_prev_avail;
+ flag |= std::regex_constants::format_default;
+ flag |= std::regex_constants::format_sed;
+ flag |= std::regex_constants::format_no_copy;
+ flag |= std::regex_constants::format_first_only;
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=c++0x" }
+// { dg-do compile }
+//
+// 2009-06-17 Stephen M. Webb <stephen.webb@xandros.com>
+//
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.5.1
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex_constants::syntax_option_type option = 0;
+
+ option |= std::regex_constants::icase;
+ option |= std::regex_constants::nosubs;
+ option |= std::regex_constants::optimize;
+ option |= std::regex_constants::collate;
+ option |= std::regex_constants::ECMAScript;
+ option |= std::regex_constants::basic;
+ option |= std::regex_constants::extended;
+ option |= std::regex_constants::awk;
+ option |= std::regex_constants::grep;
+ option |= std::regex_constants::egrep;
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=c++0x" }
+// { dg-do compile }
+//
+// 2009-06-17 Stephen M. Webb <stephen.webb@xandros.com>
+//
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.6 [re.badexp]
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex_error error(std::regex_constants::error_collate);
+ VERIFY(error.code() == std::regex_constants::error_collate);
+
+ try
+ {
+ throw error;
+ }
+ catch (std::runtime_error& ex)
+ {
+ }
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do link }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.7] class template regex_traits
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests default constructor of the regex_traits class. There is only the
+// default constructor.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::regex_traits<char> 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;
+};
--- /dev/null
+// { dg-do run { xfail *-*-* } }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-23 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.3 Requirements [re.req]
+// 28.2(4) Table 127 - Regular expression traits class requirements
+// 28.7(11) Class template regex_traits [re.traits]
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef char CharT;
+ typedef std::regex_traits<CharT> traits;
+
+ char name[] = "lower";
+ traits t;
+
+ VERIFY( t.isctype('e', t.lookup_classname(name, name+sizeof(name)-1)) );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do run }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-02-17 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.3 Requirements [re.req]
+// 28.2 (4) Table 127 - Regular expression traits class requirements
+// 28.7 Class template regex_traits [re.traits]
+// 28.7 (3) static std::size_t length(const char_type* p);
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ typedef char CharT;
+ typedef std::regex_traits<CharT> traits;
+ bool test __attribute__((unused)) = true;
+ const CharT* p = "";
+
+ std::size_t i = traits::length(p);
+
+ VERIFY( i == 0 );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do run { xfail *-*-* } }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-23 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.3 Requirements [re.req]
+// 28.2(4) Table 127 - Regular expression traits class requirements
+// 28.7(9) Class template regex_traits [re.traits]
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef char CharT;
+ typedef std::regex_traits<CharT> traits;
+
+ char n1[] = "lower";
+ char n2[] = "alpha";
+ traits t;
+
+ traits::char_class_type c1 = t.lookup_classname(n1, n1+sizeof(n1)-1);
+ VERIFY( c1 != 0 );
+
+ traits::char_class_type c2 = t.lookup_classname(n1, n1+sizeof(n1)-1, true);
+ traits::char_class_type c3 = t.lookup_classname(n2, n2+sizeof(n2)-1, true);
+ VERIFY( c2 == c3 );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do run { xfail *-*-* } }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-23 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.3 Requirements [re.req]
+// 28.2 (4) Table 127 - Regular expression traits class requirements
+// 28.7 (8) Class template regex_traits [re.traits]
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef char CharT;
+ typedef std::regex_traits<CharT> traits;
+
+ char name[] = "ll";
+ traits t;
+
+ traits::string_type sname = t.lookup_collatename(name, name+sizeof(name)-1);
+
+ VERIFY( !sname.empty() );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do run }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-02-17 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.3 Requirements [re.req]
+// 28.2 (4) Table 127 - Regular expression traits class requirements
+// 28.7 Class template regex_traits [re.traits]
+
+#include <regex>
+#include <string>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef char CharT;
+ typedef std::regex_traits<CharT> traits;
+
+ traits t;
+ traits::string_type G = "abc";
+ traits::string_type H = "def";
+
+ VERIFY( G < H );
+ VERIFY( t.transform(G.begin(), G.end()) < t.transform(H.begin(), H.end()) );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=c++0x" }
+// { dg-do run { xfail *-*-* } }
+
+//
+// 2010-02-17 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.3 Requirements [re.req]
+// 28.2 (4) Table 127 - Regular expression traits class requirements
+// 28.7 Class template regex_traits [re.traits]
+
+#include <regex>
+#include <string>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef char CharT;
+ typedef std::regex_traits<CharT> traits;
+
+ traits t;
+ traits::string_type G = "abc";
+ traits::string_type H = "def";
+ traits::string_type J = "ABC";
+
+ VERIFY( G < H );
+ VERIFY( t.transform_primary(G.begin(), G.end()) < t.transform_primary(H.begin(), H.end()) );
+
+ VERIFY( G == H );
+ VERIFY( t.transform_primary(G.begin(), G.end()) == t.transform_primary(J.begin(), J.end()) );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg_do run }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-02-17 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.3 Requirements [re.req]
+// 28.2 (4) Table 127 - Regular expression traits class requirements
+// 28.7 Class template regex_traits [re.traits]
+// 28.7 (3) static std::size_t length(const char_type* p);
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef char CharT;
+
+ std::regex_traits<CharT> t;
+ CharT c = 'a';
+ CharT d = 'a';
+
+ VERIFY( t.translate(c) == t.translate(d) );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do run }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.7] class template regex_traits (5) translate_nocase
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Verifies the workings of the regex_traits translate_nocase function.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef char CharT;
+
+ std::regex_traits<CharT> t;
+ CharT c = 'a';
+ CharT C = 'A';
+
+ VERIFY( t.translate_nocase(c) == t.translate_nocase(C) );
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do run }
+// { dg-options "-std=gnu++0x" }
+
+// 2008-08-11 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.7] class template regex_traits value() function
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests the value() function of the regex_traits<char> class.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ std::regex_traits<char> t;
+ VERIFY( t.value('7', 8) == 7 );
+ VERIFY( t.value('7', 10) == 7 );
+ VERIFY( t.value('7', 16) == 7 );
+ VERIFY( t.value('9', 8) == -1 );
+ VERIFY( t.value('9', 10) == 9 );
+ VERIFY( t.value('9', 16) == 9 );
+ VERIFY( t.value('d', 8) == -1 );
+ VERIFY( t.value('d', 10) == -1 );
+ VERIFY( t.value('d', 16) == 13 );
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do link }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.7] class template regex_traits
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests default constructor of the regex_traits class. There is only the
+// default constructor.
+void test01()
+{
+ typedef std::regex_traits<wchar_t> 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;
+};
--- /dev/null
+// { dg-do run }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-02-17 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.3 Requirements [re.req]
+// 28.2 (4) Table 127 - Regular expression traits class requirements
+// 28.7 Class template regex_traits [re.traits]
+// 28.7 (3) static std::size_t length(const char_type* p);
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ typedef wchar_t CharT;
+ typedef std::regex_traits<CharT> traits;
+ bool test __attribute__((unused)) = true;
+ const CharT* p = L"";
+
+ std::size_t i = traits::length(p);
+
+ VERIFY( i == 0 );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do run }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-02-17 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.3 Requirements [re.req]
+// 28.2 (4) Table 127 - Regular expression traits class requirements
+// 28.7 Class template regex_traits [re.traits]
+
+#include <regex>
+#include <string>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef wchar_t CharT;
+ typedef std::regex_traits<CharT> traits;
+
+ traits t;
+ traits::string_type G = L"abc";
+ traits::string_type H = L"def";
+
+ VERIFY( G < H );
+ VERIFY( t.transform(G.begin(), G.end()) < t.transform(H.begin(), H.end()) );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do run }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-02-17 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.3 Requirements [re.req]
+// 28.2 (4) Table 127 - Regular expression traits class requirements
+// 28.7 Class template regex_traits [re.traits]
+// 28.7 (3) static std::size_t length(const char_type* p);
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef wchar_t CharT;
+
+ std::regex_traits<CharT> t;
+ CharT c = L'a';
+ CharT d = L'a';
+
+ VERIFY( t.translate(c) == t.translate(d) );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do run }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.7] class template regex_traits (5) translate_nocase
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Verifies the workings of the regex_traits translate_nocase function.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef wchar_t CharT;
+
+ std::regex_traits<CharT> t;
+ CharT c = L'a';
+ CharT C = L'A';
+
+ VERIFY( t.translate_nocase(c) == t.translate_nocase(C) );
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do run }
+// { dg-options "-std=gnu++0x" }
+
+// 2008-08-11 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.7] class template regex_traits value() function
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests the value() function of the regex_traits<char> class.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ std::regex_traits<char> t;
+ VERIFY( t.value('7', 8) == 7 );
+ VERIFY( t.value('7', 10) == 7 );
+ VERIFY( t.value('7', 16) == 7 );
+ VERIFY( t.value('9', 8) == -1 );
+ VERIFY( t.value('9', 10) == 9 );
+ VERIFY( t.value('9', 16) == 9 );
+ VERIFY( t.value('d', 8) == -1 );
+ VERIFY( t.value('d', 10) == -1 );
+ VERIFY( t.value('d', 16) == 13 );
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+// 2009-06-05 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// C++0X [28.8.3] class template basic_regex assign()
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests assign operation from a C-style null-terminated-string.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::basic_regex<char> re;
+
+ const char* cs = "aab";
+ re.assign(cs);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3] class template basic_regex assign()
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests basic_regex assign operator from a C-style null-terminated-string.
+void test01()
+{
+ typedef std::basic_regex<char> test_type;
+
+ const char* cs = "aab";
+ test_type re;
+ re = cs;
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// 2010-07-07 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3](9-11) class template basic_regex assign
+
+#include <regex>
+#include <testsuite_hooks.h>
+#include <utility>
+
+// Tests assign operator of the basic_regex class for moveable rvalues.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex src_re("aaba");
+ const unsigned mark_count = src_re.mark_count();
+ const std::regex::flag_type flags = src_re.flags();
+
+ std::regex target_re;
+
+ target_re.assign(std::move(src_re));
+
+ VERIFY( target_re.flags() == flags );
+ VERIFY( target_re.mark_count() == mark_count );
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3] class template basic_regex assign()
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests assign operation from a Pascal-style counted-string.
+void test01()
+{
+ typedef std::basic_regex<char> test_type;
+
+ const char cs[] = "aab";
+ test_type re;
+ re.assign(cs, sizeof(cs)-1, std::regex_constants::basic);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3] class template basic_regex assign()
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests range assign of the basic_regex class.
+void test01()
+{
+ typedef std::basic_regex<char> test_type;
+
+ char s[] = "a+b|c";
+ test_type re;
+ re.assign(s, s + 5);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3] class template basic_regex assign()
+
+#include <string>
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests C++ string assignment of the basic_regex class.
+void test01()
+{
+ typedef std::basic_regex<char> test_type;
+
+ std::string s("a*b");
+ test_type re;
+ re.assign(s);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3] class template basic_regex assign()
+
+#include <string>
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests basic_regex assignment operator from a C++ string;
+void test01()
+{
+ typedef std::basic_regex<char> test_type;
+
+ std::string s("a*b");
+ test_type re;
+ re = s;
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3] class template basic_regex assign()
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests assign operation from a C-style null-terminated-string.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::basic_regex<wchar_t> test_type;
+
+ const wchar_t* cs = L"aab";
+ test_type re;
+ re.assign(cs);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3] class template basic_regex assign()
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests basic_regex assign operator from a C-style null-terminated-string.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::basic_regex<wchar_t> test_type;
+
+ const wchar_t* cs = L"aab";
+ test_type re;
+ re = cs;
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3] class template basic_regex assign()
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests assign operation from a Pascal-style counted-string.
+void test01()
+{
+ typedef std::basic_regex<wchar_t> test_type;
+
+ const wchar_t cs[] = L"aab";
+ test_type re;
+ re.assign(cs, sizeof(cs)-1, std::regex_constants::basic);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3] class template basic_regex assign()
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests range assign of the basic_regex class.
+void test01()
+{
+ typedef std::basic_regex<wchar_t> test_type;
+ bool test __attribute__((unused)) = true;
+
+ wchar_t s[] = L"a+b|c";
+ test_type re;
+ re.assign(s, s + 5);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3] class template basic_regex assign()
+
+#include <string>
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests C++ string assignment of the basic_regex class.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::basic_regex<wchar_t> test_type;
+
+ std::wstring s(L"a*b");
+ test_type re;
+ re.assign(s);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.3] class template basic_regex assign()
+
+#include <string>
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests basic_regex assignment operator from a C++ string;
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::basic_regex<wchar_t> test_type;
+
+ std::wstring s(L"a*b");
+ test_type re;
+ re = s;
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 7.8.2 basic_regex constructors
+
+#include <regex>
+
+void
+test01()
+{
+ std::regex re("(a|b)*abb", std::regex::basic);
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do run }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2] class template basic_regex constructor
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests Pascal-style counted-string constructor of the basic_regex class.
+void test01()
+{
+ const char* cs = "aab";
+ std::regex re(cs, 3, std::regex::basic);
+
+ VERIFY( re.flags() & std::regex_constants::basic );
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do run }
+// { dg-options "-std=c++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2] class template basic_regex constructor
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests Pascal-style counted-string constructor of the basic_regex class.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ const wchar_t* cs = L"aab";
+ std::wregex re(cs, 3, std::wregex::basic);
+
+ VERIFY( re.flags() & std::regex_constants::basic );
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-options "-std=c++0x" }
+// { dg-do run { xfail *-*-* } }
+
+//
+// 2010-06-16 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.8.2 basic_regex ctor
+// Tests for invalid range expression
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ try
+ {
+ std::regex re("a\\{1,2,3\\}", std::regex::basic);
+ }
+ catch (std::regex_error& ex)
+ {
+ VERIFY( ex.code() == std::regex_constants::error_badbrace );
+ }
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2] class template basic_regex constructor
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests C-style null-terminated-string constructor of the basic_regex class.
+void test01()
+{
+ typedef std::basic_regex<char> test_type;
+
+ const char* cs = "aab";
+ test_type re(cs);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 7.8.2 basic_regex constructors
+
+#include <regex>
+
+void
+test01()
+{
+ std::regex re("(a|b)*abb", std::regex::awk);
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 7.8.2 basic_regex constructors
+
+#include <regex>
+
+void
+test01()
+{
+ std::regex re("(a|b)*abb");
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 7.8.2 basic_regex constructors
+
+#include <regex>
+
+void
+test01()
+{
+ std::regex re("(a|b)*abb", std::regex::egrep);
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 7.8.2 basic_regex constructors
+
+#include <regex>
+
+void
+test01()
+{
+ using std::regex;
+
+ regex re("(a|b)*abb", regex::grep);
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2] class template basic_regex constructor
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests default constructor of the basic_regex class.
+void test01()
+{
+ typedef std::basic_regex<char> 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;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2] class template basic_regex constructor
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests range constructor of the basic_regex class.
+void test01()
+{
+ typedef std::basic_regex<char> test_type;
+
+ char s[] = "a+b|c";
+ test_type re(s, s + 5);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-options "-std=c++0x" }
+
+// 2010-07-07 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2](11) class template basic_regex constructors
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests copy constructor of the basic_regex class.
+void test01()
+{
+ typedef std::basic_regex<char> test_type;
+
+ test_type src_re("aaba");
+
+ test_type target_re(src_re);
+
+ VERIFY( target_re.flags() == src_re.flags() );
+ VERIFY( target_re.mark_count() == src_re.mark_count() );
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 7.8.2 basic_regex constructors
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex re("(wee|week)(knights|night)", std::regex::extended);
+
+ VERIFY( re.flags() == std::regex::extended );
+ VERIFY( re.mark_count() == 0 );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=c++0x" }
+// { dg-do run { xfail *-*-* } }
+
+//
+// 2010-06-16 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.8.2 basic_regex ctor
+// Tests for invalid range expression
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ try
+ {
+ std::regex re("a{1,2,3}", std::regex::extended);
+ }
+ catch (std::regex_error& ex)
+ {
+ VERIFY( ex.code() == std::regex_constants::error_badbrace );
+ }
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// 2010-07-07 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2](12-14) class template basic_regex constructors
+
+#include <regex>
+#include <testsuite_hooks.h>
+#include <utility>
+
+// Tests move constructor of the basic_regex class.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::basic_regex<char> test_type;
+
+ test_type src_re("aaba");
+ const unsigned mark_count = src_re.mark_count();
+ const test_type::flag_type flags = src_re.flags();
+
+ test_type target_re = std::move(src_re);
+
+ VERIFY( target_re.flags() == flags );
+ VERIFY( target_re.mark_count() == mark_count );
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2] class template basic_regex constructor
+
+#include <string>
+#include <regex>
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+// Tests C++ string constructor of the basic_regex class.
+void test01()
+{
+ typedef std::basic_regex<char> test_type;
+
+ std::string s("a*b");
+ test_type re(s);
+}
+
+void test02()
+{
+ typedef std::basic_regex<char> test_type;
+ typedef __gnu_test::tracker_allocator<char> alloc_type;
+
+ std::basic_string<char, std::char_traits<char>, alloc_type> s("a*b");
+ test_type re(s);
+}
+
+int
+main()
+{
+ test01();
+ test02();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2] class template basic_regex constructor
+
+#include <string>
+#include <regex>
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+// Tests C++ string constructor of the basic_regex class.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::basic_regex<wchar_t> test_type;
+
+ std::wstring s(L"a*b");
+ test_type re(s);
+}
+
+void test02()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::basic_regex<wchar_t> test_type;
+ typedef __gnu_test::tracker_allocator<wchar_t> alloc_type;
+
+ std::basic_string<wchar_t, std::char_traits<wchar_t>, alloc_type> s(L"a*b");
+ test_type re(s);
+}
+
+int
+main()
+{
+ test01();
+ test02();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2] class template basic_regex constructor
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests C-style null-terminated-string constructor of the basic_regex class.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::basic_regex<wchar_t> test_type;
+
+ const wchar_t* cs = L"aab";
+ test_type re(cs);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2] class template basic_regex constructor
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests default constructor of the basic_regex class.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::basic_regex<wchar_t> 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;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// [28.8.2] class template basic_regex constructor
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests range constructor of the basic_regex class.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::basic_regex<wchar_t> test_type;
+
+ wchar_t s[] = L"a+b|c";
+ test_type re(s, s + 5);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+// 2007-03-12 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 7.4 typedef std::regex
+
+#include <regex>
+
+void
+test01()
+{
+ std::regex re;
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-09 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.9.1 [re.submatch.members] sub_match members
+
+#include <regex>
+#include <string>
+#include <testsuite_hooks.h>
+
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ typedef char value_type;
+ typedef std::basic_string<value_type> string_type;
+ typedef std::sub_match<value_type*> sub_match_type;
+ value_type test_data[] = "cabbage";
+
+ sub_match_type sm;
+ sm.first = test_data + 0;
+ sm.second = test_data + sizeof(test_data)/sizeof(value_type);
+ sm.matched = true;
+
+ string_type sm_string = sm;
+
+ VERIFY( sm_string == string_type(test_data) );
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-09 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.9.1 [re.submatch.members] sub_match members
+
+#include <regex>
+#include <string>
+#include <testsuite_hooks.h>
+
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ typedef wchar_t value_type;
+ typedef std::basic_string<value_type> string_type;
+ typedef std::sub_match<value_type*> sub_match_type;
+ value_type test_data[] = L"cabbage";
+
+ sub_match_type sm;
+ sm.first = test_data + 0;
+ sm.second = test_data + sizeof(test_data)/sizeof(value_type);
+ sm.matched = true;
+
+ string_type sm_string = sm;
+
+ VERIFY( sm_string == string_type(test_data) );
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-09 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.9.1 [re.submatch.members] sub_match members
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ typedef std::sub_match<const char*> sm_t;
+ const char* test_data = "cabbage";
+ sm_t::difference_type test_len = 3;
+
+ sm_t sm1;
+ sm1.first = test_data + 0;
+ sm1.second = test_data + test_len;
+ sm1.matched = true;
+
+ sm_t sm2;
+ sm2.matched = false;
+
+ VERIFY( sm1.length() == test_len );
+ VERIFY( sm2.length() == 0 );
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-07 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.9 Class template sub_match
+
+#include <regex>
+
+
+void
+test01()
+{
+ typedef std::sub_match<char*> sm;
+
+ typedef sm::value_type value_type;
+ typedef sm::difference_type difference_type;
+ typedef sm::iterator iterator;
+ typedef sm::string_type string_type;
+}
--- /dev/null
+// { dg-options "-std=c++0x" }
+
+// 2009-06-10 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// C++0X [28.10.1] class template match_results constructor
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests default constructor of the match_result class.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::cmatch cm;
+ VERIFY( cm.size() == 0 );
+ VERIFY( cm.str() == std::cmatch::string_type() );
+}
+
+void test02()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::smatch sm;
+ VERIFY( sm.size() == 0 );
+ VERIFY( sm.str() == std::smatch::string_type() );
+}
+
+int
+main()
+{
+ test01();
+ test02();
+ return 0;
+};
--- /dev/null
+// { dg-options "-std=c++0x" }
+
+// 2009-06-05 Stephen M. Webb <stephen.webb@bregmasoft.com>
+//
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// C++0X [28.10.1] class template match_results constructor
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+// Tests default constructor of the match_result class.
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::wcmatch cm;
+ VERIFY( cm.size() == 0 );
+ VERIFY( cm.str() == std::wcmatch::string_type() );
+}
+
+void test02()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::wsmatch sm;
+ VERIFY( sm.size() == 0 );
+ VERIFY( sm.str() == std::wsmatch::string_type() );
+}
+
+int
+main()
+{
+ test01();
+ test02();
+ return 0;
+};
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-10 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.10 Class template sub_match
+
+#include <regex>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::match_results<char*> mr;
+
+ typedef mr::value_type value_type;
+ typedef mr::const_reference const_reference;
+ typedef mr::reference reference;
+ typedef mr::const_iterator const_iterator;
+ typedef mr::iterator iterator;
+ typedef mr::difference_type difference_type;
+ typedef mr::size_type size_type;
+ typedef mr::allocator_type allocator_type;
+ typedef mr::char_type char_type;
+ typedef mr::string_type string_type;
+}
--- /dev/null
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-11 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.11.2 regex_match
+// Tests BRE against a std::string target.
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex re("\\(a\\).*", std::regex::basic);
+ std::string target("aaba");
+ std::smatch m;
+
+ VERIFY( std::regex_match(target, m, re) );
+
+ VERIFY( m.size() == re.mark_count()+1 );
+ VERIFY( m.empty() == false );
+ VERIFY( m.prefix().first == target.begin() );
+ VERIFY( m.prefix().second == target.begin() );
+ VERIFY( m.prefix().matched == false );
+ VERIFY( m.suffix().first == target.end() );
+ VERIFY( m.suffix().second == target.end() );
+ VERIFY( m.suffix().matched == false );
+ VERIFY( m[0].first == target.begin() );
+ VERIFY( m[0].second == target.end() );
+ VERIFY( m[0].matched == true );
+ VERIFY( m[1].first == target.begin() );
+ VERIFY( m[1].second == target.begin()+1 );
+ VERIFY( m[1].matched == true );
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-16 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.11.2 regex_match
+// Tests BRE against a std::string target, exercising range {0,3}
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex re("a\\{0,3\\}", std::regex::basic);
+ std::string target("aa");
+ std::smatch m;
+
+ VERIFY( std::regex_match(target, m, re) );
+
+ VERIFY( m.size() == re.mark_count()+1 );
+ VERIFY( m.empty() == false );
+ VERIFY( m.prefix().first == target.begin() );
+ VERIFY( m.prefix().second == target.begin() );
+ VERIFY( m.prefix().matched == false );
+ VERIFY( m.suffix().first == target.end() );
+ VERIFY( m.suffix().second == target.end() );
+ VERIFY( m.suffix().matched == false );
+ VERIFY( m[0].first == target.begin() );
+ VERIFY( m[0].second == target.end() );
+ VERIFY( m[0].matched == true );
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-16 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.11.2 regex_match
+// Tests BRE against a std::string target, exercising range {1,3}
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex re("a\\{1,3\\}", std::regex::basic);
+ std::string target("aa");
+ std::smatch m;
+
+ VERIFY( std::regex_match(target, m, re) );
+
+ VERIFY( m.size() == re.mark_count()+1 );
+ VERIFY( m.empty() == false );
+ VERIFY( m.prefix().first == target.begin() );
+ VERIFY( m.prefix().second == target.begin() );
+ VERIFY( m.prefix().matched == false );
+ VERIFY( m.suffix().first == target.end() );
+ VERIFY( m.suffix().second == target.end() );
+ VERIFY( m.suffix().matched == false );
+ VERIFY( m[0].first == target.begin() );
+ VERIFY( m[0].second == target.end() );
+ VERIFY( m[0].matched == true );
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-options "-std=c++0x" }
+// { dg-do run { xfail *-*-* } }
+
+//
+// 2010-06-16 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.11.2 regex_match
+// Tests BRE against a std::string target, exercising range {2,3}
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex re("a\\{2,3\\}", std::regex::basic);
+ std::string target("aa");
+ std::smatch m;
+
+ VERIFY( std::regex_match(target, m, re) );
+
+ VERIFY( m.size() == re.mark_count()+1 );
+ VERIFY( m.empty() == false );
+ VERIFY( m.prefix().first == target.begin() );
+ VERIFY( m.prefix().second == target.begin() );
+ VERIFY( m.prefix().matched == false );
+ VERIFY( m.suffix().first == target.end() );
+ VERIFY( m.suffix().second == target.end() );
+ VERIFY( m.suffix().matched == false );
+ VERIFY( m[0].first == target.begin() );
+ VERIFY( m[0].second == target.end() );
+ VERIFY( m[0].matched == true );
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-options "-std=c++0x" }
+// { dg-do run { xfail *-*-* } }
+
+//
+// 2010-06-21 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.11.2 regex_match
+// Tests ERE against a C-string target, plus-sign match.
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex re("(a+)", std::regex::extended);
+ const char target[] = "aa";
+ std::cmatch m;
+
+ VERIFY( std::regex_match(target, m, re) );
+
+ VERIFY( re.mark_count() == 1 );
+ VERIFY( m.size() == re.mark_count()+1 );
+ VERIFY( m.empty() == false );
+ VERIFY( m.prefix().first == target );
+ VERIFY( m.prefix().second == target );
+ VERIFY( m.prefix().matched == false );
+ VERIFY( m.suffix().first == target+sizeof(target) );
+ VERIFY( m.suffix().second == target+sizeof(target) );
+ VERIFY( m.suffix().matched == false );
+ VERIFY( m[0].first == target );
+ VERIFY( m[0].second == target+sizeof(target) );
+ VERIFY( m[0].matched == true );
+ VERIFY( m[1].first == target );
+ VERIFY( m[1].second == target+sizeof(target) );
+ VERIFY( m[1].matched == true );
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-options "-std=c++0x" }
+// { dg-do run { xfail *-*-* } }
+
+//
+// 2010-06-21 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.11.2 regex_match
+// Tests ERE against a C-string target, question-mark match.
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex re("(aa?)", std::regex::extended);
+ char target[] = "a";
+ std::cmatch m;
+
+ VERIFY( std::regex_match(target, m, re) );
+
+ VERIFY( re.mark_count() == 1 );
+ VERIFY( m.size() == re.mark_count()+1 );
+ VERIFY( m.empty() == false );
+ VERIFY( m.prefix().first == target );
+ VERIFY( m.prefix().second == target );
+ VERIFY( m.prefix().matched == false );
+ VERIFY( m.suffix().first == target+sizeof(target) );
+ VERIFY( m.suffix().second == target+sizeof(target) );
+ VERIFY( m.suffix().matched == false );
+ VERIFY( m[0].first == target );
+ VERIFY( m[0].second == target+sizeof(target) );
+ VERIFY( m[0].matched == true );
+ VERIFY( m[1].first == target );
+ VERIFY( m[1].second == target+sizeof(target) );
+ VERIFY( m[1].matched == true );
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-11 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.11.2 regex_match
+// Tests ERE against a std::string target.
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex re(".*", std::regex::extended);
+ std::string target("aaba");
+ std::smatch m;
+
+ VERIFY( std::regex_match(target, m, re) );
+
+ VERIFY( m.size() == re.mark_count()+1 );
+ VERIFY( m.empty() == false );
+ VERIFY( m.prefix().first == target.begin() );
+ VERIFY( m.prefix().second == target.begin() );
+ VERIFY( m.prefix().matched == false );
+ VERIFY( m.suffix().first == target.end() );
+ VERIFY( m.suffix().second == target.end() );
+ VERIFY( m.suffix().matched == false );
+ VERIFY( m[0].first == target.begin() );
+ VERIFY( m[0].second == target.end() );
+ VERIFY( m[0].matched == true );
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-16 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.11.2 regex_match
+// Tests ERE against a std::string target, exercising range {0,3}
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex re("a{0,3}", std::regex::extended);
+ std::string target("aa");
+ std::smatch m;
+
+ VERIFY( std::regex_match(target, m, re) );
+
+ VERIFY( m.size() == re.mark_count()+1 );
+ VERIFY( m.empty() == false );
+ VERIFY( m.prefix().first == target.begin() );
+ VERIFY( m.prefix().second == target.begin() );
+ VERIFY( m.prefix().matched == false );
+ VERIFY( m.suffix().first == target.end() );
+ VERIFY( m.suffix().second == target.end() );
+ VERIFY( m.suffix().matched == false );
+ VERIFY( m[0].first == target.begin() );
+ VERIFY( m[0].second == target.end() );
+ VERIFY( m[0].matched == true );
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-16 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.11.2 regex_match
+// Tests ERE against a std::string target, exercising range {1,3}
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex re("a{1,3}", std::regex::extended);
+ std::string target("aa");
+ std::smatch m;
+
+ VERIFY( std::regex_match(target, m, re) );
+
+ VERIFY( m.size() == re.mark_count()+1 );
+ VERIFY( m.empty() == false );
+ VERIFY( m.prefix().first == target.begin() );
+ VERIFY( m.prefix().second == target.begin() );
+ VERIFY( m.prefix().matched == false );
+ VERIFY( m.suffix().first == target.end() );
+ VERIFY( m.suffix().second == target.end() );
+ VERIFY( m.suffix().matched == false );
+ VERIFY( m[0].first == target.begin() );
+ VERIFY( m[0].second == target.end() );
+ VERIFY( m[0].matched == true );
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-options "-std=c++0x" }
+// { dg-do run { xfail *-*-* } }
+
+//
+// 2010-06-16 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.11.2 regex_match
+// Tests ERE against a std::string target, exercising range {2,3}
+
+#include <regex>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ std::regex re("a{2,3}", std::regex::extended);
+ std::string target("aa");
+ std::smatch m;
+
+ VERIFY( std::regex_match(target, m, re) );
+
+ VERIFY( m.size() == re.mark_count()+1 );
+ VERIFY( m.empty() == false );
+ VERIFY( m.prefix().first == target.begin() );
+ VERIFY( m.prefix().second == target.begin() );
+ VERIFY( m.prefix().matched == false );
+ VERIFY( m.suffix().first == target.end() );
+ VERIFY( m.suffix().second == target.end() );
+ VERIFY( m.suffix().matched == false );
+ VERIFY( m[0].first == target.begin() );
+ VERIFY( m[0].second == target.end() );
+ VERIFY( m[0].matched == true );
+}
+
+
+int
+main()
+{
+ test01();
+ return 0;
+}
+
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-10 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.12.1 Class template regex_iterator
+
+#include <regex>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ std::regex_iterator<char*> it;
+ std::cregex_iterator cit;
+ std::sregex_iterator sit;
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-10 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.12.1 Class template regex_iterator
+
+#include <regex>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ std::regex_iterator<wchar_t*> it;
+ std::wcregex_iterator cit;
+ std::wsregex_iterator sit;
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-10 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.12.1 Class template regex_iterator
+
+#include <regex>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::regex_iterator<char*> it;
+
+ typedef it::regex_type regex_type;
+ typedef it::value_type value_type;
+ typedef it::difference_type difference_type;
+ typedef it::pointer pointer;
+ typedef it::reference reference;
+ typedef it::iterator_category iterator_category;
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-10 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.12.2 Class template regex_token_iterator
+
+#include <regex>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ std::regex_token_iterator<char*> it;
+ std::cregex_token_iterator cit;
+ std::sregex_token_iterator sit;
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+//
+// 2010-06-10 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.12.2 Class template regex_token_iterator
+
+#include <regex>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ std::regex_token_iterator<wchar_t*> it;
+ std::wcregex_token_iterator cit;
+ std::wsregex_token_iterator sit;
+}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+//
+// 2010-06-10 Stephen M. Webb <stephen.webb@bregmasoft.ca>
+//
+// Copyright (C) 2010 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 28.12.2 Class template regex_token_iterator
+
+#include <regex>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ typedef std::regex_token_iterator<char*> it;
+
+ typedef it::regex_type regex_type;
+ typedef it::value_type value_type;
+ typedef it::difference_type difference_type;
+ typedef it::pointer pointer;
+ typedef it::reference reference;
+ typedef it::iterator_category iterator_category;
+}
projects / platform / upstream / gcc.git / commitdiff