N1551, Changes to N1540 to Implement N1499 Parts 1 and 2

Document number:   N1551=03-0134
Date:   October 30, 2003
Project:   Programming Language C++
Reference:   ISO/IEC IS 14882:1998(E)
Reply to:   Pete Becker
  Dinkumware, Ltd.
  petebecker@acm.org


Move to amend N1540 as follows:

Change paragraph 2 of clause 7.3 [tr.re.sym] from:

The header <regex> defines a container-like class template that holds the result of a regular expression match.

to:

The header <regex> defines a class template that holds the result of a regular expression match.

In clause 7.4 [tr.re.syn] change the forward declaration of basic_regex from:

    template <class charT,
            class traits = regex_traits<charT>,
            class Allocator = allocator<charT> >
        class basic_regex;

to:

    template <class charT,
            class traits = regex_traits<charT> >
        class basic_regex;

In clause 7.4 [tr.re.syn] remove the following template functions:

    template <class charT, class traits, class Allocator>
        bool operator == (const basic_regex<charT, traits, Allocator>& lhs,
            const basic_regex<charT, traits, Allocator>& rhs);
        template <class charT, class traits, class Allocator>
        bool operator != (const basic_regex<charT, traits, Allocator>& lhs,
            const basic_regex<charT, traits, Allocator>& rhs);
        template <class charT, class traits, class Allocator>
        bool operator < (const basic_regex<charT, traits, Allocator>& lhs,
            const basic_regex<charT, traits, Allocator>& rhs);
        template <class charT, class traits, class Allocator>
        bool operator <= (const basic_regex<charT, traits, Allocator>& lhs,
            const basic_regex<charT, traits, Allocator>& rhs);
        template <class charT, class traits, class Allocator>
        bool operator >= (const basic_regex<charT, traits, Allocator>& lhs,
            const basic_regex<charT, traits, Allocator>& rhs);
        template <class charT, class traits, class Allocator>
        bool operator > (const basic_regex<charT, traits, Allocator>& lhs,
            const basic_regex<charT, traits, Allocator>& rhs);
        template <class charT, class io_traits, class re_traits, class Allocator>
        basic_ostream<charT, io_traits>&
            operator << (basic_ostream<charT, io_traits>& os,
                const basic_regex<charT, re_traits, Allocator>& e);

In clause 7.4 [tr.re.syn] change the declaration of the template function swap from:

    template <class charT, class traits, class Allocator>
    void swap(basic_regex<charT, traits, Allocator>& e1,
        basic_regex<charT, traits, Allocator>& e2);

to:

    template <class charT, class traits>
    void swap(basic_regex<charT, traits>& e1,
        basic_regex<charT, traits>& e2);

In clause 7.4 [tr.re.syn] change the declarations of regex_match, regex_search, and regex_replace from:

    template <class BidirectionalIterator, class Allocator, class charT,
        class traits, class Allocator2>
    bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
        match_results<BidirectionalIterator, Allocator>& m,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);
    template <class BidirectionalIterator,
        class charT, class traits,
        class Allocator2>
    bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);
    template <class charT, class Allocator, class traits, class Allocator2>
    bool regex_match(const charT* str, match_results<const charT*, Allocator>& m,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);
    template <class ST, class SA, class Allocator, class charT,
        class traits, class Allocator2>
    bool regex_match(const basic_string<charT, ST, SA>& s,
        match_results<typename basic_string<charT, ST, SA>
        ::const_iterator,
        Allocator>& m,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);
    template <class charT, class traits, class Allocator2>
    bool regex_match(const charT* str,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);
    template <class ST, class SA, class charT, class traits, class Allocator2>
    bool regex_match(const basic_string<charT, ST, SA>& s,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);
    template <class BidirectionalIterator, class Allocator, class charT,
        class traits, class Allocator2>

    bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
        match_results<BidirectionalIterator, Allocator>& m,
    const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);
    template <class charT, class Allocator, class traits, class Allocator2>
    bool regex_search(const charT* str, match_results<const charT*, Allocator>& m,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);
    template <class BidirectionalIterator, class Allocator, class charT,
        class traits>
    bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
        const reg_expression<charT, traits, Allocator>& e,
        match_flag_type flags = match_default);
    template <class charT, class Allocator, class traits>
    bool regex_search(const charT* str
        const reg_expression<charT, traits, Allocator>& e,
        match_flag_type flags = match_default);
    template <class ST, class SA, class Allocator, class charT,
        class traits>
    bool regex_search(const basic_string<charT, ST, SA>& s,
        const reg_expression<charT, traits, Allocator>& e,
        match_flag_type flags = match_default);
    template <class ST, class SA, class Allocator, class charT,
        class traits, class Allocator2>
    bool regex_search(const basic_string<charT, ST, SA>& s,
        match_results<typename basic_string<charT, ST, SA>
        ::const_iterator,
        Allocator>& m,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);

    template <class OutputIterator, class BidirectionalIterator, class traits,
        class Allocator, class charT>
    OutputIterator regex_replace(OutputIterator out,
        BidirectionalIterator first,
        BidirectionalIterator last,
        const reg_expression<charT, traits, Allocator>& e,
        const basic_string<charT>& fmt,
        match_flag_type flags = match_default);
    template <class traits, class Allocator, class charT>
    basic_string<charT> regex_replace(const basic_string<charT>& s,
        const reg_expression<charT, traits, Allocator>& e,
        const basic_string<charT>& fmt,
        match_flag_type flags = match_default);

to:

    template <class BidirectionalIterator, class Allocator, class charT,
        class traits>
    bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
        match_results<BidirectionalIterator, Allocator>& m,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);
    template <class BidirectionalIterator,
        class charT, class traits>
    bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);
    template <class charT, class Allocator, class traits>
    bool regex_match(const charT* str, match_results<const charT*, Allocator>& m,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);
    template <class ST, class SA, class Allocator, class charT,
        class traits>
    bool regex_match(const basic_string<charT, ST, SA>& s,
        match_results<typename basic_string<charT, ST, SA>
        ::const_iterator,
        Allocator>& m,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);
    template <class charT, class traits>
    bool regex_match(const charT* str,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);
    template <class ST, class SA, class charT, class traits>
    bool regex_match(const basic_string<charT, ST, SA>& s,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

    template <class BidirectionalIterator, class Allocator, class charT,
        class traits>
    bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
        match_results<BidirectionalIterator, Allocator>& m,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);
    template <class charT, class Allocator, class traits>
    bool regex_search(const charT* str, match_results<const charT*, Allocator>& m,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);
    template <class BidirectionalIterator, class charT,
        class traits>
    bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);
    template <class charT, class traits>
    bool regex_search(const charT* str
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);
    template <class ST, class SA, class charT,
        class traits>
    bool regex_search(const basic_string<charT, ST, SA>& s,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);
    template <class ST, class SA, class Allocator, class charT,
        class traits>
    bool regex_search(const basic_string<charT, ST, SA>& s,
        match_results<typename basic_string<charT, ST, SA>
        ::const_iterator,
        Allocator>& m,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

    template <class OutputIterator, class BidirectionalIterator, class traits,
        class charT>
    OutputIterator regex_replace(OutputIterator out,
        BidirectionalIterator first,
        BidirectionalIterator last,
        const reg_expression<charT, traits>& e,
        const basic_string<charT>& fmt,
        match_flag_type flags = match_default);
    template <class traits, class charT>
    basic_string<charT> regex_replace(const basic_string<charT>& s,
        const reg_expression<charT, traits>& e,
        const basic_string<charT>& fmt,
        match_flag_type flags = match_default);

In clause 7.4 [tr.re.syn] change the forward declarations of regex_iterator and regex_token_iterator from:

    template <class BidirectionalIterator,
        class charT = iterator_traits<BidirectionalIterator>::value_type,
        class traits = regex_traits<charT>,
        class Allocator = allocator<charT> >
    class regex_iterator;
    template <class BidirectionalIterator,
        class charT = iterator_traits<BidirectionalIterator>::value_type,
        class traits = regex_traits<charT>,
        class Allocator = allocator<charT> >
    class regex_token_iterator;

to:

    template <class BidirectionalIterator,
        class charT = iterator_traits<BidirectionalIterator>::value_type,
        class traits = regex_traits<charT> >
    class regex_iterator;
    template <class BidirectionalIterator,
        class charT = iterator_traits<BidirectionalIterator>::value_type,
        class traits = regex_traits<charT> >
    class regex_token_iterator;

In clause 7.8 [tr.re.regex] remove the first sentence of the second paragraph, which currently reads:

The template class basic_regex conforms to the requirements of a Sequence, as specified in [lib.sequence.reqmts], except that only operations defined for const-qualified Sequences are supported.

In clause 7.8 [tr.re.regex] change the definition of template class basic_regex from:

    template <class charT,
        class traits = regex_traits<charT>,
        class Allocator = allocator<charT> >
    class basic_regex
    {
    public:
        // types:
        typedef charT value_type;
        typedef implementation-defined const_iterator;
        typedef const_iterator iterator;
        typedef typename Allocator::reference reference;
        typedef typename Allocator::const_reference const_reference;
        typedef typename Allocator::difference_type difference_type;
        typedef typename Allocator::size_type size_type;
        typedef Allocator allocator_type;
        typedef regex_constants::syntax_option_type flag_type;
        typedef typename traits::locale_type locale_type;

        // constants:
        static const regex_constants::syntax_option_type normal = regex_constants::normal;
        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 = normal;
        static const regex_constants::syntax_option_type JavaScript = normal;
        static const regex_constants::syntax_option_type JScript = normal;
        // these flags are optional, if the functionality is supported
        // then the flags shall take these names.
        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;
        static const regex_constants::syntax_option_type sed = basic = regex_constants::sed;
        static const regex_constants::syntax_option_type perl = regex_constants::perl;

        // construct/copy/destroy:
        explicit basic_regex(const Allocator& a = Allocator());
        explicit basic_regex(const charT* p, flag_type f = regex_constants::normal,
            const Allocator& a = Allocator());
        basic_regex(const charT* p1, const charT* p2, flag_type f = regex_constants::normal,
            const Allocator& a = Allocator());
        basic_regex(const charT* p, size_type len, flag_type f,
            const Allocator& a = Allocator());
        basic_regex(const basic_regex&);
        template <class ST, class SA>
        explicit basic_regex(const basic_string<charT, ST, SA>& p,
            flag_type f = regex_constants::normal,
            const Allocator& a = Allocator());
        template <class InputIterator>
        basic_regex(InputIterator first, inputIterator last,
            flag_type f = regex_constants::normal,
            const Allocator& a = Allocator());

        ˜basic_regex();
        basic_regex& operator=(const basic_regex&);
        basic_regex& operator=(const charT* ptr);
        template <class ST, class SA>
        basic_regex& operator=(const basic_string<charT, ST, SA>& p);

        // iterators:
        const_iterator begin() const;
        const_iterator end() const;
        // capacity:
        size_type size() const;
        size_type max_size() const;
        bool empty() const;
        unsigned mark_count() const;

        //
        // modifiers:
        basic_regex& assign(const basic_regex& that);
        basic_regex& assign(const charT* ptr, flag_type f = regex_constants::normal);
        basic_regex& assign(const charT* first, const charT* last,
            flag_type f = regex_constants::normal);
        template <class string_traits, class A>
        basic_regex& assign(const basic_string<charT, string_traits, A>& s,
            flag_type f = regex_constants::normal);
        template <class InputIterator>
        basic_regex& assign(InputIterator first, InputIterator last,
            flag_type f = regex_constants::normal);

        // const operations:
        Allocator get_allocator() const;
        flag_type getflags() const;
        basic_string<charT> str() const;
        int compare(basic_regex&) const;
        // locale:
        locale_type imbue(locale_type loc);
        locale_type getloc() const;
        // swap
        void swap(basic_regex&) throw();
    };

to:

    template <class charT,
        class traits = regex_traits<charT> >
    class basic_regex
    {
    public:
        // types:
        typedef charT value_type;
        typedef regex_constants::syntax_option_type flag_type;
        typedef typename traits::locale_type locale_type;

        // constants:
        static const regex_constants::syntax_option_type normal = regex_constants::normal;
        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 = normal;
        static const regex_constants::syntax_option_type JavaScript = normal;
        static const regex_constants::syntax_option_type JScript = normal;
        // these flags are optional, if the functionality is supported
        // then the flags shall take these names.
        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;
        static const regex_constants::syntax_option_type sed = basic = regex_constants::sed;
        static const regex_constants::syntax_option_type perl = regex_constants::perl;

        // construct/copy/destroy:
        basic_regex();
        explicit basic_regex(const charT* p, flag_type f = regex_constants::normal);
        basic_regex(const charT* p1, const charT* p2, flag_type f = regex_constants::normal);
        basic_regex(const charT* p, size_type len, flag_type f);
        basic_regex(const basic_regex&);
        template <class ST, class SA>
        explicit basic_regex(const basic_string<charT, ST, SA>& p,
            flag_type f = regex_constants::normal);
        template <class InputIterator>
        basic_regex(InputIterator first, inputIterator last,
            flag_type f = regex_constants::normal);

        ˜basic_regex();
        basic_regex& operator=(const basic_regex&);
        basic_regex& operator=(const charT* ptr);
        template <class ST, class SA>
        basic_regex& operator=(const basic_string<charT, ST, SA>& p);

        // capacity:
        bool empty() const;
        unsigned mark_count() const;

        //
        // modifiers:
        basic_regex& assign(const basic_regex& that);
        basic_regex& assign(const charT* ptr, flag_type f = regex_constants::normal);
        basic_regex& assign(const charT* first, const charT* last,
            flag_type f = regex_constants::normal);
        template <class string_traits, class A>
        basic_regex& assign(const basic_string<charT, string_traits, A>& s,
            flag_type f = regex_constants::normal);
        template <class InputIterator>
        basic_regex& assign(InputIterator first, InputIterator last,
            flag_type f = regex_constants::normal);

        // const operations:
        flag_type getflags() const;
        // locale:
        locale_type imbue(locale_type loc);
        locale_type getloc() const;
        // swap
        void swap(basic_regex&) throw();
    };

In clause 7.8.2 [tr.re.regex.construct], remove the first paragraph, which currently reads:

In all basic regex constructors, a copy of the Allocator argument is used for any memory allocation performed by the constructor or member functions during the lifetime of the object.

In clause 7.8.2 [tr.re.regex.construct], change the declaration of the first constructor from:

    basic_regex(const Allocator& a = Allocator());

to:

    basic_regex();

In clause 7.8.2 [tr.re.regex.construct], change the title of Table 7.7 from:

basic_regex(const Allocator&) effects

to:

basic_regex() effects

In clause 7.8.2 [tr.re.regex.construct], change the declaration of the second constructor from:

    basic_regex(const charT* p,
        flag_type f = regex_constants::normal,
        const Allocator& a = Allocator());

to:

    basic_regex(const charT* p,
        flag_type f = regex_constants::normal);

In clause 7.8.2 [tr.re.regex.construct], change the title of Table 7.8 from:

basic_regex(const charT* p, flag_type f, const Allocator&) effects

to:

basic_regex(const charT* p, flag_type f) effects

In clause 7.8.2 [tr.re.regex.construct], change the declaration of the third constructor from:

    basic_regex(const charT* p1, const charT* p2,
        flag_type f = regex_constants::normal,
        const Allocator& a = Allocator());

to:

    basic_regex(const charT* p1, const charT* p2,
        flag_type f = regex_constants::normal);

In clause 7.8.2 [tr.re.regex.construct], change the title of Table 7.9 from:

basic_regex(const charT* p1, const charT* p2, flag_type f, const Allocator&) effects

to:

basic_regex(const charT* p1, const charT* p2, flag_type f) effects

In clause 7.8.2 [tr.re.regex.construct], change the declaration of the fourth constructor from:

    basic_regex(const charT* p, size_type len,
        flag_type f,
        const Allocator& a = Allocator());

to:

    basic_regex(const charT* p, size_type len,
        flag_type f);

In clause 7.8.2 [tr.re.regex.construct], change the Requires clause of the fourth constructor from:

Requires: p shall not be a null pointer, len < max_size().

to:

Requires: p shall not be a null pointer.

In clause 7.8.2 [tr.re.regex.construct], change the title of Table 7.10 from:

basic_regex(const charT* p1, size_type len, flag_type f) effects

In clause 7.8.2 [tr.re.regex.construct], change the declaration of the sixth constructor from:

    template 
    basic_regex(const basic_string& s,
        flag_type f = regex_constants::normal,
        const Allocator& a = Allocator());

to:

    template 
    basic_regex(const basic_string& s,
        flag_type f = regex_constants::normal)

In clause 7.8.2 [tr.re.regex.construct], change the declaration of the seventh constructor from:

    template 
    basic_regex(ForwardIterator first, ForwardIterator last,
        flag_type f = regex_constants::normal,
        const Allocator& a = Allocator());

to:

    template 
    basic_regex(ForwardIterator first, ForwardIterator last,
        flag_type f = regex_constants::normal)

In clause 7.8.2 [tr.re.regex.construct], change the title of Table 7.13 from:

basic_regex(ForwardIterator first, ForwardIterator last, flag_type f, const Allocator&) effects

to:

basic_regex(ForwardIterator first, ForwardIterator last, flag_type f) effects

Remove clause 7.8.3 [tr.re.regex.iter].

In clause 7.8.4 [tr.re.regex.cap] remove the declaration of the member function size and its Effects clause, and remove the declaration of the member function max_size and its Effects clause.

In clause 7.8.6 [tr.re.regex.operations] remove the declaration of the member function get_allocator and its Effects clause, remove the declaration of the member function str and its Effects clause, and remove the declaration of the member function compare and its Effects clause.

Remove clause 7.8.9.1 [tr.re.regex.comp] and remove clause 7.8.9.2 [tr.re.regex.inserter].

In clause 7.8.9.3 [tr.re.regex.nmswap], change the declaration of the member function swap from:

    template <class charT, class traits, class Allocator>
    void swap(basic_regex<charT, traits, Allocator>& lhs,
        basic_regex<charT, traits, Allocator>& rhs);

to:

    template <class charT, class traits>
    void swap(basic_regex<charT, traits>& lhs,
        basic_regex<charT, traits>& rhs);

In clause 7.10.1 [tr.re.alg.match] change the declaration of the first version of regex_match from:

    template <class BidirectionalIterator, class Allocator, class charT,
        class traits, class Allocator2>
    bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
        match_results<BidirectionalIterator, Allocator>& m,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);

to:

    template <class BidirectionalIterator, class Allocator, class charT,
        class traits>
    bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
        match_results<BidirectionalIterator, Allocator>& m,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.1 [tr.re.alg.match] change the declaration of the second version of regex_match from:

    template <class BidirectionalIterator, class charT, class traits, class Allocator2>
    bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);

to:

    template <class BidirectionalIterator, class charT, class traits>
    bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.1 [tr.re.alg.match] change the declaration of the third version of regex_match from:

    template <class charT, class Allocator, class traits, class Allocator2>
    bool regex_match(const charT* str, match_results<const charT*, Allocator>& m,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);

to:

    template <class charT, class Allocator, class traits>
    bool regex_match(const charT* str, match_results<const charT*, Allocator>& m,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.1 [tr.re.alg.match] change the declaration of the fourth version of regex_match from:

    template <class ST, class SA, class Allocator, class charT,
        class traits, class Allocator2>
    bool regex_match(const basic_string<charT, ST, SA>& s,
        match_results<typename basic_string<charT, ST, SA>::const_iterator,
            const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);

to:

    template <class ST, class SA, class Allocator, class charT,
        class traits>
    bool regex_match(const basic_string<charT, ST, SA>& s,
        match_results<typename basic_string<charT, ST, SA>::const_iterator,
            const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.1 [tr.re.alg.match] change the declaration of the fifth version of regex_match from:

   template <class charT, class traits, class Allocator2>
    bool regex_match(const charT* str,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);

to:

   template <class charT, class traits>
    bool regex_match(const charT* str,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.1 [tr.re.alg.match] change the declaration of the sixth version of regex_match from:

    template <class ST, class SA, class charT, class traits, class Allocator2>
    bool regex_match(const basic_string<charT, ST, SA>& s,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);

to:

    template <class ST, class SA, class charT, class traits>
    bool regex_match(const basic_string<charT, ST, SA>& s,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.2 [tr.re.alg.search] change the declaration of the first version of regex_search from:

   template <class BidirectionalIterator, class Allocator, class charT,
        class traits, class Allocator2>
    bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
        match_results<BidirectionalIterator, Allocator>& m,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);

to:

   template <class BidirectionalIterator, class Allocator, class charT,
        class traits>
    bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
        match_results<BidirectionalIterator, Allocator>& m,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.2 [tr.re.alg.search] change the declaration of the second version of regex_search from:

    template <class charT, class Allocator, class traits, class Allocator2>
    bool regex_search(const charT* str, match_results<const charT*, Allocator>& m,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);

to:

    template <class charT, class Allocator, class traits>
    bool regex_search(const charT* str, match_results<const charT*, Allocator>& m,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.2 [tr.re.alg.search] change the declaration of the third version of regex_search from:

    template <class ST, class SA, class Allocator, class charT,
        class traits, class Allocator2>
    bool regex_search(const basic_string<charT, ST, SA>& s,
        match_results<typename basic_string<charT, ST, SA>::const_iterator,
        const reg_expression<charT, traits, Allocator2>& e,
        match_flag_type flags = match_default);

to:

    template <class ST, class SA, class Allocator, class charT,
        class traits>
    bool regex_search(const basic_string<charT, ST, SA>& s,
        match_results<typename basic_string<charT, ST, SA>::const_iterator,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.2 [tr.re.alg.search] change the declaration of the fourth version of regex_search from:

    template <class iterator, class Allocator, class charT,
        class traits>
    bool regex_search(iterator first, iterator last,
        const reg_expression<charT, traits, Allocator>& e,
        match_flag_type flags = match_default);

to:

    template <class iterator, class charT,
        class traits>
    bool regex_search(iterator first, iterator last,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.2 [tr.re.alg.search] change the declaration of the fifth version of regex_search from:

    template <class charT, class Allocator, class traits>
    bool regex_search(const charT* str,
        const reg_expression<charT, traits, Allocator>& e,
        match_flag_type flags = match_default);

to:

    template <class charT, class traits>
    bool regex_search(const charT* str,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.2 [tr.re.alg.search] change the declaration of the sixth version of regex_search from:

    template <class ST, class SA, class Allocator, class charT,
        class traits>
    bool regex_search(const basic_string<charT, ST, SA>& s,
        const reg_expression<charT, traits, Allocator>& e,
        match_flag_type flags = match_default);

to:

    template <class ST, class SA, class charT,
        class traits>
    bool regex_search(const basic_string<charT, ST, SA>& s,
        const reg_expression<charT, traits>& e,
        match_flag_type flags = match_default);

In clause 7.10.3 [tr.re.alg.replace] change the declaration of the first version of regex_replace from:

    template <class OutputIterator, class BidirectionalIterator, class traits,
        class Allocator, class charT>
    OutputIterator regex_replace(OutputIterator out,
        BidirectionalIterator first,
        BidirectionalIterator last,
        const reg_expression<charT, traits, Allocator>& e,
        const basic_string<charT>& fmt,
        match_flag_type flags = match_default);

to:

    template <class OutputIterator, class BidirectionalIterator, class traits,
        class charT>
    OutputIterator regex_replace(OutputIterator out,
        BidirectionalIterator first,
        BidirectionalIterator last,
        const reg_expression<charT, traits>& e,
        const basic_string<charT>& fmt,
        match_flag_type flags = match_default);

In clause 7.10.3 [tr.re.alg.replace] change the declaration of the second version of regex_replace from:

    template <class traits, class Allocator, class charT>
    basic_string<charT> regex_replace(const basic_string<charT<& s,
        const reg_expression<charT, traits, Allocator>& e,
        const basic_string<charT>& fmt,
        match_flag_type flags = match_default);

to:

    template <class traits, class charT>
    basic_string<charT> regex_replace(const basic_string<charT<& s,
        const reg_expression<charT, traits>& e,
        const basic_string<charT>& fmt,
        match_flag_type flags = match_default);

In clause 7.11.1 [tr.re.regiter] change the beginning of the definition of the template class regex_iterator from:

    template <class BidirectionalIterator,
        class charT = iterator_traits<BidirectionalIterator>::value_type,
        class traits = regex_traits<charT>,
        class Allocator = allocator<charT> >
    class regex_iterator
    {
    public:
        typedef basic_regex<charT, traits, Allocator>
            regex_type;

to:

    template <class BidirectionalIterator,
        class charT = iterator_traits<BidirectionalIterator>::value_type,
        class traits = regex_traits<charT> >
    class regex_iterator
    {
    public:
        typedef basic_regex<charT, traits>
            regex_type;

In clause 7.11.2 [tr.re.tokiter] change the beginning of the definition of the template class regex_token_iterator from:

    template <class BidirectionalIterator,
        class charT = iterator_traits<BidirectionalIterator>::value_type,
        class traits = regex_traits<charT>,
        class Allocator = allocator<charT> >
    class regex_token_iterator
    {
    public:
        typedef basic_regex<charT, traits, Allocator>
        regex_type;

to:

    template <class BidirectionalIterator,
        class charT = iterator_traits<BidirectionalIterator>::value_type,
        class traits = regex_traits<charT> >
    class regex_token_iterator
    {
    public:
        typedef basic_regex<charT, traits>
        regex_type;