| 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: