This is the mail archive of the
libstdc++@gcc.gnu.org
mailing list for the libstdc++ project.
Re: [RFC] Removal of allocator::construct / destroy vs our containers
- From: Paolo Carlini <pcarlini at suse dot de>
- To: Paolo Carlini <pcarlini at suse dot de>
- Cc: Benjamin Kosnik <bkoz at redhat dot com>, libstdc++ <libstdc++ at gcc dot gnu dot org>
- Date: Sat, 28 Apr 2007 04:30:22 +0200
- Subject: Re: [RFC] Removal of allocator::construct / destroy vs our containers
- References: <463127A8.9050804@suse.de> <4631DA16.8020604@redhat.com> <4631DD0C.1060706@suse.de>
Hi,
Can you imagine problems with such a plan? Do we have principled
reasons to delay it to when a full C++0x implementation of the
library will be delivered?
Not that I can see. You're still keeping the C++98 interface.
At the very least, I think this is worth having a patch for, just so
that somebody can indicate that this has been implemented and the
issues were not severe.
Excellent. I will prepare one.
In practice, the below (+ removal of a few tests only exercising
construct / destroy) passes the testsuite and appear to work well.
Mechanical changes, as expected.
All in all, I'm starting lo like this clean-up a lot. As already
mentioned, we also avoid passing around allocators unnecessarily.
I'm thinking, maybe the risk would not be that big: for one, nowhere the
standard says the containers must call allocator::construct / destroy.
Moreover, the current consensus in the LWG is that there isn't much
point in calling them. Therefore, even if, for some reason, eventually
they will be remain in C++0x, so what? In any case, we would mention the
implementation change in the release notes.
What do you think?
Paolo.
/////////////////////
Index: include/ext/hashtable.h
===================================================================
--- include/ext/hashtable.h (revision 124242)
+++ include/ext/hashtable.h (working copy)
@@ -1,6 +1,6 @@
// Hashtable implementation used by containers -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
@@ -605,7 +605,7 @@
__n->_M_next = 0;
try
{
- this->get_allocator().construct(&__n->_M_val, __obj);
+ _Construct(&__n->_M_val, __obj);
return __n;
}
catch(...)
@@ -618,7 +618,7 @@
void
_M_delete_node(_Node* __n)
{
- this->get_allocator().destroy(&__n->_M_val);
+ _Destroy(&__n->_M_val);
_M_put_node(__n);
}
Index: include/ext/slist
===================================================================
--- include/ext/slist (revision 124242)
+++ include/ext/slist (working copy)
@@ -1,6 +1,7 @@
// Singly-linked list implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2004, 2005 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
+// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@@ -262,7 +263,7 @@
_Slist_node<_Tp>* __next = (_Slist_node<_Tp>*) (__pos->_M_next);
_Slist_node_base* __next_next = __next->_M_next;
__pos->_M_next = __next_next;
- get_allocator().destroy(&__next->_M_data);
+ _Destroy(&__next->_M_data);
_M_put_node(__next);
return __next_next;
}
@@ -279,7 +280,7 @@
{
_Slist_node<_Tp>* __tmp = __cur;
__cur = (_Slist_node<_Tp>*) __cur->_M_next;
- get_allocator().destroy(&__tmp->_M_data);
+ _Destroy(&__tmp->_M_data);
_M_put_node(__tmp);
}
__before_first->_M_next = __last_node;
@@ -329,7 +330,7 @@
_Node* __node = this->_M_get_node();
try
{
- get_allocator().construct(&__node->_M_data, __x);
+ _Construct(&__node->_M_data, __x);
__node->_M_next = 0;
}
catch(...)
@@ -346,7 +347,7 @@
_Node* __node = this->_M_get_node();
try
{
- get_allocator().construct(&__node->_M_data, value_type());
+ _Construct(&__node->_M_data, value_type());
__node->_M_next = 0;
}
catch(...)
@@ -492,7 +493,7 @@
{
_Node* __node = (_Node*) this->_M_head._M_next;
this->_M_head._M_next = __node->_M_next;
- get_allocator().destroy(&__node->_M_data);
+ _Destroy(&__node->_M_data);
this->_M_put_node(__node);
}
Index: include/ext/ropeimpl.h
===================================================================
--- include/ext/ropeimpl.h (revision 124242)
+++ include/ext/ropeimpl.h (working copy)
@@ -1,6 +1,6 @@
// SGI's rope class implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
@@ -347,7 +347,7 @@
if (0 != __cstr)
{
size_t __size = this->_M_size + 1;
- _Destroy(__cstr, __cstr + __size, get_allocator());
+ _Destroy(__cstr, __cstr + __size);
this->_Data_deallocate(__cstr, __size);
}
}
@@ -358,8 +358,8 @@
_S_free_string(_CharT* __s, size_t __n, allocator_type __a)
{
if (!_S_is_basic_char_type((_CharT*)0))
- _Destroy(__s, __s + __n, __a);
-
+ _Destroy(__s, __s + __n);
+
// This has to be a static member, so this gets a bit messy
__a.deallocate(__s,
_Rope_RopeLeaf<_CharT, _Alloc>::_S_rounded_up_size(__n));
@@ -1549,8 +1549,7 @@
else
{
__rest_buffer = this->_Data_allocate(_S_rounded_up_size(__rest));
- __uninitialized_fill_n_a(__rest_buffer, __rest, __c,
- get_allocator());
+ uninitialized_fill_n(__rest_buffer, __rest, __c);
_S_cond_store_eos(__rest_buffer[__rest]);
try
{ __remainder = _S_new_RopeLeaf(__rest_buffer, __rest, __a); }
@@ -1567,8 +1566,7 @@
this->_Data_allocate(_S_rounded_up_size(__exponentiate_threshold));
_RopeLeaf* __base_leaf;
rope __base_rope;
- __uninitialized_fill_n_a(__base_buffer, __exponentiate_threshold, __c,
- get_allocator());
+ uninitialized_fill_n(__base_buffer, __exponentiate_threshold, __c);
_S_cond_store_eos(__base_buffer[__exponentiate_threshold]);
try
{
Index: include/ext/rope
===================================================================
--- include/ext/rope (revision 124242)
+++ include/ext/rope (working copy)
@@ -79,6 +79,7 @@
using std::size_t;
using std::ptrdiff_t;
using std::allocator;
+ using std::_Construct;
using std::_Destroy;
// The _S_eos function is used for those functions that
@@ -1654,7 +1655,7 @@
return 0;
_CharT* __buf = __a.allocate(_S_rounded_up_size(__size));
- __uninitialized_copy_n_a(__s, __size, __buf, __a);
+ uninitialized_copy_n(__s, __size, __buf);
_S_cond_store_eos(__buf[__size]);
try
{ return _S_new_RopeLeaf(__buf, __size, __a); }
@@ -1802,7 +1803,7 @@
{
_CharT* __buf = this->_Data_allocate(_S_rounded_up_size(1));
- get_allocator().construct(__buf, __c);
+ _Construct(__buf, __c);
try
{ this->_M_tree_ptr = _S_new_RopeLeaf(__buf, 1, __a); }
catch(...)
@@ -1916,7 +1917,7 @@
void
copy(_CharT* __buffer) const
{
- _Destroy(__buffer, __buffer + size(), get_allocator());
+ _Destroy(__buffer, __buffer + size());
_S_flatten(this->_M_tree_ptr, __buffer);
}
@@ -1931,7 +1932,7 @@
size_t __size = size();
size_t __len = (__pos + __n > __size? __size - __pos : __n);
- _Destroy(__buffer, __buffer + __len, get_allocator());
+ _Destroy(__buffer, __buffer + __len);
_S_flatten(this->_M_tree_ptr, __pos, __len, __buffer);
return __len;
}
Index: include/bits/stl_list.h
===================================================================
--- include/bits/stl_list.h (revision 124243)
+++ include/bits/stl_list.h (working copy)
@@ -452,7 +452,7 @@
_Node* __p = this->_M_get_node();
try
{
- _M_get_Tp_allocator().construct(&__p->_M_data, __x);
+ std::_Construct(&__p->_M_data, __x);
}
catch(...)
{
@@ -1168,7 +1168,7 @@
{
__position._M_node->unhook();
_Node* __n = static_cast<_Node*>(__position._M_node);
- _M_get_Tp_allocator().destroy(&__n->_M_data);
+ std::_Destroy(&__n->_M_data);
_M_put_node(__n);
}
Index: include/bits/stl_vector.h
===================================================================
--- include/bits/stl_vector.h (revision 124243)
+++ include/bits/stl_vector.h (working copy)
@@ -211,8 +211,7 @@
const allocator_type& __a = allocator_type())
: _Base(__n, __a)
{
- std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
- _M_get_Tp_allocator());
+ std::uninitialized_fill_n(this->_M_impl._M_start, __n, __value);
this->_M_impl._M_finish = this->_M_impl._M_start + __n;
}
@@ -228,9 +227,8 @@
vector(const vector& __x)
: _Base(__x.size(), __x._M_get_Tp_allocator())
{ this->_M_impl._M_finish =
- std::__uninitialized_copy_a(__x.begin(), __x.end(),
- this->_M_impl._M_start,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__x.begin(), __x.end(),
+ this->_M_impl._M_start);
}
/**
@@ -265,8 +263,7 @@
* responsibilty.
*/
~vector()
- { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
- _M_get_Tp_allocator()); }
+ { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish); }
/**
* @brief %Vector assignment operator.
@@ -598,7 +595,7 @@
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
- this->_M_impl.construct(this->_M_impl._M_finish, __x);
+ std::_Construct(this->_M_impl._M_finish, __x);
++this->_M_impl._M_finish;
}
else
@@ -618,7 +615,7 @@
pop_back()
{
--this->_M_impl._M_finish;
- this->_M_impl.destroy(this->_M_impl._M_finish);
+ std::_Destroy(this->_M_impl._M_finish);
}
/**
@@ -763,8 +760,7 @@
pointer __result = this->_M_allocate(__n);
try
{
- std::__uninitialized_copy_a(__first, __last, __result,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__first, __last, __result);
return __result;
}
catch(...)
@@ -788,10 +784,8 @@
this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
this->_M_impl._M_end_of_storage =
this->_M_impl._M_start + static_cast<size_type>(__n);
- std::__uninitialized_fill_n_a(this->_M_impl._M_start,
- static_cast<size_type>(__n),
- __value,
- _M_get_Tp_allocator());
+ std::uninitialized_fill_n(this->_M_impl._M_start,
+ static_cast<size_type>(__n), __value);
this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
}
@@ -826,9 +820,7 @@
this->_M_impl._M_start = this->_M_allocate(__n);
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
this->_M_impl._M_finish =
- std::__uninitialized_copy_a(__first, __last,
- this->_M_impl._M_start,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__first, __last, this->_M_impl._M_start);
}
@@ -935,7 +927,7 @@
void
_M_erase_at_end(pointer __pos)
{
- std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
+ std::_Destroy(__pos, this->_M_impl._M_finish);
this->_M_impl._M_finish = __pos;
}
};
Index: include/bits/stl_deque.h
===================================================================
--- include/bits/stl_deque.h (revision 124243)
+++ include/bits/stl_deque.h (working copy)
@@ -705,9 +705,8 @@
*/
deque(const deque& __x)
: _Base(__x._M_get_Tp_allocator(), __x.size())
- { std::__uninitialized_copy_a(__x.begin(), __x.end(),
- this->_M_impl._M_start,
- _M_get_Tp_allocator()); }
+ { std::uninitialized_copy(__x.begin(), __x.end(),
+ this->_M_impl._M_start); }
/**
* @brief Builds a %deque from a range.
@@ -1033,7 +1032,7 @@
{
if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
{
- this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, __x);
+ std::_Construct(this->_M_impl._M_start._M_cur - 1, __x);
--this->_M_impl._M_start._M_cur;
}
else
@@ -1055,7 +1054,7 @@
if (this->_M_impl._M_finish._M_cur
!= this->_M_impl._M_finish._M_last - 1)
{
- this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __x);
+ std::_Construct(this->_M_impl._M_finish._M_cur, __x);
++this->_M_impl._M_finish._M_cur;
}
else
@@ -1076,7 +1075,7 @@
if (this->_M_impl._M_start._M_cur
!= this->_M_impl._M_start._M_last - 1)
{
- this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
+ std::_Destroy(this->_M_impl._M_start._M_cur);
++this->_M_impl._M_start._M_cur;
}
else
@@ -1098,7 +1097,7 @@
!= this->_M_impl._M_finish._M_first)
{
--this->_M_impl._M_finish._M_cur;
- this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
+ std::_Destroy(this->_M_impl._M_finish._M_cur);
}
else
_M_pop_back_aux();
Index: include/bits/stl_uninitialized.h
===================================================================
--- include/bits/stl_uninitialized.h (revision 124242)
+++ include/bits/stl_uninitialized.h (working copy)
@@ -110,8 +110,7 @@
template<typename _ForwardIterator, typename _Tp>
void
__uninitialized_fill_aux(_ForwardIterator __first,
- _ForwardIterator __last,
- const _Tp& __x)
+ _ForwardIterator __last, const _Tp& __x)
{
_ForwardIterator __cur = __first;
try
@@ -188,93 +187,6 @@
std::__uninitialized_fill_n_aux(__first, __n, __x);
}
- // Extensions: versions of uninitialized_copy, uninitialized_fill,
- // and uninitialized_fill_n that take an allocator parameter.
- // We dispatch back to the standard versions when we're given the
- // default allocator. For nondefault allocators we do not use
- // any of the POD optimizations.
-
- template<typename _InputIterator, typename _ForwardIterator,
- typename _Allocator>
- _ForwardIterator
- __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
- _ForwardIterator __result,
- _Allocator __alloc)
- {
- _ForwardIterator __cur = __result;
- try
- {
- for (; __first != __last; ++__first, ++__cur)
- __alloc.construct(&*__cur, *__first);
- return __cur;
- }
- catch(...)
- {
- std::_Destroy(__result, __cur, __alloc);
- __throw_exception_again;
- }
- }
-
- template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
- inline _ForwardIterator
- __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
- _ForwardIterator __result,
- allocator<_Tp>)
- { return std::uninitialized_copy(__first, __last, __result); }
-
- template<typename _ForwardIterator, typename _Tp, typename _Allocator>
- void
- __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
- const _Tp& __x, _Allocator __alloc)
- {
- _ForwardIterator __cur = __first;
- try
- {
- for (; __cur != __last; ++__cur)
- __alloc.construct(&*__cur, __x);
- }
- catch(...)
- {
- std::_Destroy(__first, __cur, __alloc);
- __throw_exception_again;
- }
- }
-
- template<typename _ForwardIterator, typename _Tp, typename _Tp2>
- inline void
- __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
- const _Tp& __x, allocator<_Tp2>)
- { std::uninitialized_fill(__first, __last, __x); }
-
- template<typename _ForwardIterator, typename _Size, typename _Tp,
- typename _Allocator>
- void
- __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
- const _Tp& __x,
- _Allocator __alloc)
- {
- _ForwardIterator __cur = __first;
- try
- {
- for (; __n > 0; --__n, ++__cur)
- __alloc.construct(&*__cur, __x);
- }
- catch(...)
- {
- std::_Destroy(__first, __cur, __alloc);
- __throw_exception_again;
- }
- }
-
- template<typename _ForwardIterator, typename _Size, typename _Tp,
- typename _Tp2>
- inline void
- __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
- const _Tp& __x,
- allocator<_Tp2>)
- { std::uninitialized_fill_n(__first, __n, __x); }
-
-
// Extensions: __uninitialized_copy_copy, __uninitialized_copy_fill,
// __uninitialized_fill_copy. All of these algorithms take a user-
// supplied allocator, which is used for construction and destruction.
@@ -285,25 +197,23 @@
// [result, result + (last1 - first1) + (last2 - first2)).
template<typename _InputIterator1, typename _InputIterator2,
- typename _ForwardIterator, typename _Allocator>
+ typename _ForwardIterator>
inline _ForwardIterator
__uninitialized_copy_copy(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
- _ForwardIterator __result,
- _Allocator __alloc)
+ _ForwardIterator __result)
{
- _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
- __result,
- __alloc);
+ _ForwardIterator __mid = std::uninitialized_copy(__first1, __last1,
+ __result);
try
{
- return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
+ return std::uninitialized_copy(__first2, __last2, __mid);
}
catch(...)
{
- std::_Destroy(__result, __mid, __alloc);
+ std::_Destroy(__result, __mid);
__throw_exception_again;
}
}
@@ -311,22 +221,20 @@
// __uninitialized_fill_copy
// Fills [result, mid) with x, and copies [first, last) into
// [mid, mid + (last - first)).
- template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
- typename _Allocator>
+ template<typename _ForwardIterator, typename _Tp, typename _InputIterator>
inline _ForwardIterator
__uninitialized_fill_copy(_ForwardIterator __result, _ForwardIterator __mid,
const _Tp& __x, _InputIterator __first,
- _InputIterator __last,
- _Allocator __alloc)
+ _InputIterator __last)
{
- std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
+ std::uninitialized_fill(__result, __mid, __x);
try
{
- return std::__uninitialized_copy_a(__first, __last, __mid, __alloc);
+ return std::uninitialized_copy(__first, __last, __mid);
}
catch(...)
{
- std::_Destroy(__result, __mid, __alloc);
+ std::_Destroy(__result, __mid);
__throw_exception_again;
}
}
@@ -334,24 +242,21 @@
// __uninitialized_copy_fill
// Copies [first1, last1) into [first2, first2 + (last1 - first1)), and
// fills [first2 + (last1 - first1), last2) with x.
- template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
- typename _Allocator>
+ template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
inline void
__uninitialized_copy_fill(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2,
- _ForwardIterator __last2, const _Tp& __x,
- _Allocator __alloc)
+ _ForwardIterator __last2, const _Tp& __x)
{
- _ForwardIterator __mid2 = std::__uninitialized_copy_a(__first1, __last1,
- __first2,
- __alloc);
+ _ForwardIterator __mid2 = std::uninitialized_copy(__first1, __last1,
+ __first2);
try
{
- std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
+ std::uninitialized_fill(__mid2, __last2, __x);
}
catch(...)
{
- std::_Destroy(__first2, __mid2, __alloc);
+ std::_Destroy(__first2, __mid2);
__throw_exception_again;
}
}
Index: include/bits/vector.tcc
===================================================================
--- include/bits/vector.tcc (revision 124242)
+++ include/bits/vector.tcc (working copy)
@@ -76,8 +76,7 @@
const size_type __old_size = size();
pointer __tmp = _M_allocate_and_copy(__n, this->_M_impl._M_start,
this->_M_impl._M_finish);
- std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
@@ -96,7 +95,7 @@
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
&& __position == end())
{
- this->_M_impl.construct(this->_M_impl._M_finish, __x);
+ std::_Construct(this->_M_impl._M_finish, __x);
++this->_M_impl._M_finish;
}
else
@@ -112,7 +111,7 @@
if (__position + 1 != end())
std::copy(__position + 1, end(), __position);
--this->_M_impl._M_finish;
- this->_M_impl.destroy(this->_M_impl._M_finish);
+ std::_Destroy(this->_M_impl._M_finish);
return __position;
}
@@ -139,8 +138,7 @@
{
pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
__x.end());
- std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
@@ -148,18 +146,14 @@
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
}
else if (size() >= __xlen)
- {
- std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
- end(), _M_get_Tp_allocator());
- }
+ std::_Destroy(std::copy(__x.begin(), __x.end(), begin()), end());
else
{
std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
this->_M_impl._M_start);
- std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
- __x._M_impl._M_finish,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__x._M_impl._M_start + size(),
+ __x._M_impl._M_finish,
+ this->_M_impl._M_finish);
}
this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
}
@@ -179,9 +173,8 @@
else if (__n > size())
{
std::fill(begin(), end(), __val);
- std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
- __n - size(), __val,
- _M_get_Tp_allocator());
+ std::uninitialized_fill_n(this->_M_impl._M_finish,
+ __n - size(), __val);
this->_M_impl._M_finish += __n - size();
}
else
@@ -217,8 +210,7 @@
if (__len > capacity())
{
pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
- std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
@@ -234,9 +226,8 @@
std::advance(__mid, size());
std::copy(__first, __mid, this->_M_impl._M_start);
this->_M_impl._M_finish =
- std::__uninitialized_copy_a(__mid, __last,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__mid, __last,
+ this->_M_impl._M_finish);
}
}
@@ -247,8 +238,8 @@
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
- this->_M_impl.construct(this->_M_impl._M_finish,
- *(this->_M_impl._M_finish - 1));
+ std::_Construct(this->_M_impl._M_finish,
+ *(this->_M_impl._M_finish - 1));
++this->_M_impl._M_finish;
_Tp __x_copy = __x;
std::copy_backward(__position.base(),
@@ -265,25 +256,22 @@
try
{
__new_finish =
- std::__uninitialized_copy_a(this->_M_impl._M_start,
- __position.base(), __new_start,
- _M_get_Tp_allocator());
- this->_M_impl.construct(__new_finish, __x);
+ std::uninitialized_copy(this->_M_impl._M_start,
+ __position.base(), __new_start);
+ std::_Construct(__new_finish, __x);
++__new_finish;
__new_finish =
- std::__uninitialized_copy_a(__position.base(),
- this->_M_impl._M_finish,
- __new_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__position.base(),
+ this->_M_impl._M_finish,
+ __new_finish);
}
catch(...)
{
- std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
+ std::_Destroy(__new_start, __new_finish);
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
- std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
@@ -308,10 +296,9 @@
pointer __old_finish(this->_M_impl._M_finish);
if (__elems_after > __n)
{
- std::__uninitialized_copy_a(this->_M_impl._M_finish - __n,
- this->_M_impl._M_finish,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(this->_M_impl._M_finish - __n,
+ this->_M_impl._M_finish,
+ this->_M_impl._M_finish);
this->_M_impl._M_finish += __n;
std::copy_backward(__position.base(), __old_finish - __n,
__old_finish);
@@ -320,14 +307,11 @@
}
else
{
- std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
- __n - __elems_after,
- __x_copy,
- _M_get_Tp_allocator());
+ std::uninitialized_fill_n(this->_M_impl._M_finish,
+ __n - __elems_after, __x_copy);
this->_M_impl._M_finish += __n - __elems_after;
- std::__uninitialized_copy_a(__position.base(), __old_finish,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__position.base(), __old_finish,
+ this->_M_impl._M_finish);
this->_M_impl._M_finish += __elems_after;
std::fill(__position.base(), __old_finish, __x_copy);
}
@@ -341,28 +325,22 @@
try
{
__new_finish =
- std::__uninitialized_copy_a(this->_M_impl._M_start,
- __position.base(),
- __new_start,
- _M_get_Tp_allocator());
- std::__uninitialized_fill_n_a(__new_finish, __n, __x,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(this->_M_impl._M_start,
+ __position.base(), __new_start);
+ std::uninitialized_fill_n(__new_finish, __n, __x);
__new_finish += __n;
__new_finish =
- std::__uninitialized_copy_a(__position.base(),
- this->_M_impl._M_finish,
- __new_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__position.base(),
+ this->_M_impl._M_finish,
+ __new_finish);
}
catch(...)
{
- std::_Destroy(__new_start, __new_finish,
- _M_get_Tp_allocator());
+ std::_Destroy(__new_start, __new_finish);
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
- std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
@@ -404,10 +382,9 @@
pointer __old_finish(this->_M_impl._M_finish);
if (__elems_after > __n)
{
- std::__uninitialized_copy_a(this->_M_impl._M_finish - __n,
- this->_M_impl._M_finish,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(this->_M_impl._M_finish - __n,
+ this->_M_impl._M_finish,
+ this->_M_impl._M_finish);
this->_M_impl._M_finish += __n;
std::copy_backward(__position.base(), __old_finish - __n,
__old_finish);
@@ -417,14 +394,12 @@
{
_ForwardIterator __mid = __first;
std::advance(__mid, __elems_after);
- std::__uninitialized_copy_a(__mid, __last,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__mid, __last,
+ this->_M_impl._M_finish);
this->_M_impl._M_finish += __n - __elems_after;
- std::__uninitialized_copy_a(__position.base(),
- __old_finish,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__position.base(),
+ __old_finish,
+ this->_M_impl._M_finish);
this->_M_impl._M_finish += __elems_after;
std::copy(__first, __mid, __position);
}
@@ -438,28 +413,23 @@
try
{
__new_finish =
- std::__uninitialized_copy_a(this->_M_impl._M_start,
- __position.base(),
- __new_start,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(this->_M_impl._M_start,
+ __position.base(),
+ __new_start);
__new_finish =
- std::__uninitialized_copy_a(__first, __last, __new_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__first, __last, __new_finish);
__new_finish =
- std::__uninitialized_copy_a(__position.base(),
- this->_M_impl._M_finish,
- __new_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__position.base(),
+ this->_M_impl._M_finish,
+ __new_finish);
}
catch(...)
{
- std::_Destroy(__new_start, __new_finish,
- _M_get_Tp_allocator());
+ std::_Destroy(__new_start, __new_finish);
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
- std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
Index: include/bits/deque.tcc
===================================================================
--- include/bits/deque.tcc (revision 124242)
+++ include/bits/deque.tcc (working copy)
@@ -185,8 +185,8 @@
iterator __new_start = _M_reserve_elements_at_front(__n);
try
{
- std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
- __x, _M_get_Tp_allocator());
+ std::uninitialized_fill(__new_start, this->_M_impl._M_start,
+ __x);
this->_M_impl._M_start = __new_start;
}
catch(...)
@@ -201,9 +201,8 @@
iterator __new_finish = _M_reserve_elements_at_back(__n);
try
{
- std::__uninitialized_fill_a(this->_M_impl._M_finish,
- __new_finish, __x,
- _M_get_Tp_allocator());
+ std::uninitialized_fill(this->_M_impl._M_finish,
+ __new_finish, __x);
this->_M_impl._M_finish = __new_finish;
}
catch(...)
@@ -228,16 +227,14 @@
for (__cur = this->_M_impl._M_start._M_node;
__cur < this->_M_impl._M_finish._M_node;
++__cur)
- std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
- __value, _M_get_Tp_allocator());
- std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
- this->_M_impl._M_finish._M_cur,
- __value, _M_get_Tp_allocator());
+ std::uninitialized_fill(*__cur, *__cur + _S_buffer_size(),
+ __value);
+ std::uninitialized_fill(this->_M_impl._M_finish._M_first,
+ this->_M_impl._M_finish._M_cur, __value);
}
catch(...)
{
- std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
- _M_get_Tp_allocator());
+ std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur));
__throw_exception_again;
}
}
@@ -281,19 +278,16 @@
{
_ForwardIterator __mid = __first;
std::advance(__mid, _S_buffer_size());
- std::__uninitialized_copy_a(__first, __mid, *__cur_node,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__first, __mid, *__cur_node);
__first = __mid;
}
- std::__uninitialized_copy_a(__first, __last,
- this->_M_impl._M_finish._M_first,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__first, __last,
+ this->_M_impl._M_finish._M_first);
}
catch(...)
{
std::_Destroy(this->_M_impl._M_start,
- iterator(*__cur_node, __cur_node),
- _M_get_Tp_allocator());
+ iterator(*__cur_node, __cur_node));
__throw_exception_again;
}
}
@@ -309,7 +303,7 @@
*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
try
{
- this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __t_copy);
+ std::_Construct(this->_M_impl._M_finish._M_cur, __t_copy);
this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
+ 1);
this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
@@ -335,7 +329,7 @@
this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
- 1);
this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
- this->_M_impl.construct(this->_M_impl._M_start._M_cur, __t_copy);
+ std::_Construct(this->_M_impl._M_start._M_cur, __t_copy);
}
catch(...)
{
@@ -353,7 +347,7 @@
_M_deallocate_node(this->_M_impl._M_finish._M_first);
this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
- this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
+ std::_Destroy(this->_M_impl._M_finish._M_cur);
}
// Called only if _M_impl._M_start._M_cur == _M_impl._M_start._M_last - 1.
@@ -365,7 +359,7 @@
void deque<_Tp, _Alloc>::
_M_pop_front_aux()
{
- this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
+ std::_Destroy(this->_M_impl._M_start._M_cur);
_M_deallocate_node(this->_M_impl._M_start._M_first);
this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
@@ -394,8 +388,7 @@
iterator __new_start = _M_reserve_elements_at_front(__n);
try
{
- std::__uninitialized_copy_a(__first, __last, __new_start,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__first, __last, __new_start);
this->_M_impl._M_start = __new_start;
}
catch(...)
@@ -410,9 +403,8 @@
iterator __new_finish = _M_reserve_elements_at_back(__n);
try
{
- std::__uninitialized_copy_a(__first, __last,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__first, __last,
+ this->_M_impl._M_finish);
this->_M_impl._M_finish = __new_finish;
}
catch(...)
@@ -478,9 +470,8 @@
{
iterator __start_n = (this->_M_impl._M_start
+ difference_type(__n));
- std::__uninitialized_copy_a(this->_M_impl._M_start,
- __start_n, __new_start,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(this->_M_impl._M_start,
+ __start_n, __new_start);
this->_M_impl._M_start = __new_start;
std::copy(__start_n, __pos, __old_start);
std::fill(__pos - difference_type(__n), __pos, __x_copy);
@@ -490,8 +481,7 @@
std::__uninitialized_copy_fill(this->_M_impl._M_start,
__pos, __new_start,
this->_M_impl._M_start,
- __x_copy,
- _M_get_Tp_allocator());
+ __x_copy);
this->_M_impl._M_start = __new_start;
std::fill(__old_start, __pos, __x_copy);
}
@@ -516,10 +506,9 @@
{
iterator __finish_n = (this->_M_impl._M_finish
- difference_type(__n));
- std::__uninitialized_copy_a(__finish_n,
- this->_M_impl._M_finish,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__finish_n,
+ this->_M_impl._M_finish,
+ this->_M_impl._M_finish);
this->_M_impl._M_finish = __new_finish;
std::copy_backward(__pos, __finish_n, __old_finish);
std::fill(__pos, __pos + difference_type(__n), __x_copy);
@@ -529,8 +518,7 @@
std::__uninitialized_fill_copy(this->_M_impl._M_finish,
__pos + difference_type(__n),
__x_copy, __pos,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ this->_M_impl._M_finish);
this->_M_impl._M_finish = __new_finish;
std::fill(__pos, __old_finish, __x_copy);
}
@@ -565,9 +553,8 @@
{
iterator __start_n = (this->_M_impl._M_start
+ difference_type(__n));
- std::__uninitialized_copy_a(this->_M_impl._M_start,
- __start_n, __new_start,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(this->_M_impl._M_start,
+ __start_n, __new_start);
this->_M_impl._M_start = __new_start;
std::copy(__start_n, __pos, __old_start);
std::copy(__first, __last, __pos - difference_type(__n));
@@ -578,8 +565,7 @@
std::advance(__mid, difference_type(__n) - __elemsbefore);
std::__uninitialized_copy_copy(this->_M_impl._M_start,
__pos, __first, __mid,
- __new_start,
- _M_get_Tp_allocator());
+ __new_start);
this->_M_impl._M_start = __new_start;
std::copy(__mid, __last, __old_start);
}
@@ -604,10 +590,9 @@
{
iterator __finish_n = (this->_M_impl._M_finish
- difference_type(__n));
- std::__uninitialized_copy_a(__finish_n,
- this->_M_impl._M_finish,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ std::uninitialized_copy(__finish_n,
+ this->_M_impl._M_finish,
+ this->_M_impl._M_finish);
this->_M_impl._M_finish = __new_finish;
std::copy_backward(__pos, __finish_n, __old_finish);
std::copy(__first, __last, __pos);
@@ -618,8 +603,7 @@
std::advance(__mid, __elemsafter);
std::__uninitialized_copy_copy(__mid, __last, __pos,
this->_M_impl._M_finish,
- this->_M_impl._M_finish,
- _M_get_Tp_allocator());
+ this->_M_impl._M_finish);
this->_M_impl._M_finish = __new_finish;
std::copy(__first, __mid, __pos);
}
@@ -640,19 +624,15 @@
{
for (_Map_pointer __node = __first._M_node + 1;
__node < __last._M_node; ++__node)
- std::_Destroy(*__node, *__node + _S_buffer_size(),
- _M_get_Tp_allocator());
+ std::_Destroy(*__node, *__node + _S_buffer_size());
if (__first._M_node != __last._M_node)
{
- std::_Destroy(__first._M_cur, __first._M_last,
- _M_get_Tp_allocator());
- std::_Destroy(__last._M_first, __last._M_cur,
- _M_get_Tp_allocator());
+ std::_Destroy(__first._M_cur, __first._M_last);
+ std::_Destroy(__last._M_first, __last._M_cur);
}
else
- std::_Destroy(__first._M_cur, __last._M_cur,
- _M_get_Tp_allocator());
+ std::_Destroy(__first._M_cur, __last._M_cur);
}
template <typename _Tp, typename _Alloc>
Index: include/bits/list.tcc
===================================================================
--- include/bits/list.tcc (revision 124242)
+++ include/bits/list.tcc (working copy)
@@ -75,7 +75,7 @@
{
_Node* __tmp = __cur;
__cur = static_cast<_Node*>(__cur->_M_next);
- _M_get_Tp_allocator().destroy(&__tmp->_M_data);
+ std::_Destroy(&__tmp->_M_data);
_M_put_node(__tmp);
}
}
Index: include/bits/stl_construct.h
===================================================================
--- include/bits/stl_construct.h (revision 124242)
+++ include/bits/stl_construct.h (working copy)
@@ -83,21 +83,6 @@
/**
* @if maint
- * Constructs an object in existing memory by invoking an allocated
- * object's default constructor (no initializers).
- * @endif
- */
- template<typename _T1>
- inline void
- _Construct(_T1* __p)
- {
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 402. wrong new expression in [some_]allocator::construct
- ::new(static_cast<void*>(__p)) _T1();
- }
-
- /**
- * @if maint
* Destroy the object pointed to by a pointer type.
* @endif
*/
@@ -124,34 +109,6 @@
std::_Destroy(&*__first);
}
- /**
- * @if maint
- * Destroy a range of objects using the supplied allocator. For
- * nondefault allocators we do not optimize away invocation of
- * destroy() even if _Tp has a trivial destructor.
- * @endif
- */
-
- template <typename _Tp> class allocator;
-
- template<typename _ForwardIterator, typename _Allocator>
- void
- _Destroy(_ForwardIterator __first, _ForwardIterator __last,
- _Allocator __alloc)
- {
- for (; __first != __last; ++__first)
- __alloc.destroy(&*__first);
- }
-
- template<typename _ForwardIterator, typename _Tp>
- inline void
- _Destroy(_ForwardIterator __first, _ForwardIterator __last,
- allocator<_Tp>)
- {
- _Destroy(__first, __last);
- }
-
_GLIBCXX_END_NAMESPACE
#endif /* _STL_CONSTRUCT_H */
-
Index: include/bits/stl_tree.h
===================================================================
--- include/bits/stl_tree.h (revision 124242)
+++ include/bits/stl_tree.h (working copy)
@@ -66,6 +66,7 @@
#include <bits/stl_algobase.h>
#include <bits/allocator.h>
+#include <bits/stl_construct.h>
#include <bits/stl_function.h>
#include <bits/cpp_type_traits.h>
@@ -365,7 +366,7 @@
{
_Link_type __tmp = _M_get_node();
try
- { get_allocator().construct(&__tmp->_M_value_field, __x); }
+ { std::_Construct(&__tmp->_M_value_field, __x); }
catch(...)
{
_M_put_node(__tmp);
@@ -387,7 +388,7 @@
void
_M_destroy_node(_Link_type __p)
{
- get_allocator().destroy(&__p->_M_value_field);
+ std::_Destroy(&__p->_M_value_field);
_M_put_node(__p);
}
Index: include/tr1/hashtable
===================================================================
--- include/tr1/hashtable (revision 124242)
+++ include/tr1/hashtable (working copy)
@@ -58,6 +58,7 @@
#include <bits/stl_iterator_base_types.h>
#include <bits/stl_iterator_base_funcs.h>
#include <bits/allocator.h>
+#include <bits/stl_construct.h>
#include <bits/functexcept.h>
#include <tr1/type_traits> // For true_type and false_type
#include <tr1/hashtable_policy.h>
@@ -451,7 +452,7 @@
_Node* __n = _M_node_allocator.allocate(1);
try
{
- _M_get_Value_allocator().construct(&__n->_M_v, __v);
+ std::_Construct(&__n->_M_v, __v);
__n->_M_next = 0;
return __n;
}
@@ -471,7 +472,7 @@
_H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
_M_deallocate_node(_Node* __n)
{
- _M_get_Value_allocator().destroy(&__n->_M_v);
+ std::_Destroy(&__n->_M_v);
_M_node_allocator.deallocate(__n, 1);
}
Index: include/std/list
===================================================================
--- include/std/list (revision 124242)
+++ include/std/list (working copy)
@@ -65,6 +65,7 @@
#include <bits/stl_algobase.h>
#include <bits/allocator.h>
+#include <bits/stl_construct.h>
#include <bits/stl_list.h>
#ifndef _GLIBCXX_EXPORT_TEMPLATE
Index: testsuite/23_containers/requirements/sequences/dr438/vector/assign_neg.cc
===================================================================
--- testsuite/23_containers/requirements/sequences/dr438/vector/assign_neg.cc (revision 124243)
+++ testsuite/23_containers/requirements/sequences/dr438/vector/assign_neg.cc (working copy)
@@ -19,7 +19,7 @@
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 845 }
+// { dg-error "no matching" "" { target *-*-* } 837 }
// { dg-excess-errors "" }
#include <vector>
Index: testsuite/23_containers/requirements/sequences/dr438/vector/insert_neg.cc
===================================================================
--- testsuite/23_containers/requirements/sequences/dr438/vector/insert_neg.cc (revision 124243)
+++ testsuite/23_containers/requirements/sequences/dr438/vector/insert_neg.cc (working copy)
@@ -19,7 +19,7 @@
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 886 }
+// { dg-error "no matching" "" { target *-*-* } 878 }
// { dg-excess-errors "" }
#include <vector>
Index: testsuite/23_containers/requirements/sequences/dr438/deque/assign_neg.cc
===================================================================
--- testsuite/23_containers/requirements/sequences/dr438/deque/assign_neg.cc (revision 124243)
+++ testsuite/23_containers/requirements/sequences/dr438/deque/assign_neg.cc (working copy)
@@ -19,7 +19,7 @@
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1297 }
+// { dg-error "no matching" "" { target *-*-* } 1296 }
// { dg-excess-errors "" }
#include <deque>
Index: testsuite/23_containers/requirements/sequences/dr438/deque/insert_neg.cc
===================================================================
--- testsuite/23_containers/requirements/sequences/dr438/deque/insert_neg.cc (revision 124243)
+++ testsuite/23_containers/requirements/sequences/dr438/deque/insert_neg.cc (working copy)
@@ -19,7 +19,7 @@
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1377 }
+// { dg-error "no matching" "" { target *-*-* } 1376 }
// { dg-excess-errors "" }
#include <deque>
Index: testsuite/23_containers/requirements/sequences/dr438/deque/constructor_1_neg.cc
===================================================================
--- testsuite/23_containers/requirements/sequences/dr438/deque/constructor_1_neg.cc (revision 124243)
+++ testsuite/23_containers/requirements/sequences/dr438/deque/constructor_1_neg.cc (working copy)
@@ -19,7 +19,7 @@
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1232 }
+// { dg-error "no matching" "" { target *-*-* } 1231 }
// { dg-excess-errors "" }
#include <deque>
Index: testsuite/23_containers/requirements/sequences/dr438/deque/constructor_2_neg.cc
===================================================================
--- testsuite/23_containers/requirements/sequences/dr438/deque/constructor_2_neg.cc (revision 124243)
+++ testsuite/23_containers/requirements/sequences/dr438/deque/constructor_2_neg.cc (working copy)
@@ -19,7 +19,7 @@
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1232 }
+// { dg-error "no matching" "" { target *-*-* } 1231 }
// { dg-excess-errors "" }
#include <deque>
Index: testsuite/23_containers/set/operators/1_neg.cc
===================================================================
--- testsuite/23_containers/set/operators/1_neg.cc (revision 124242)
+++ testsuite/23_containers/set/operators/1_neg.cc (working copy)
@@ -40,5 +40,5 @@
test &= itr == setByName.end(); // { dg-error "no" }
}
-// { dg-error "candidates are" "" { target *-*-* } 285 }
-// { dg-error "candidates are" "" { target *-*-* } 289 }
+// { dg-error "candidates are" "" { target *-*-* } 286 }
+// { dg-error "candidates are" "" { target *-*-* } 290 }
Index: testsuite/23_containers/map/operators/1_neg.cc
===================================================================
--- testsuite/23_containers/map/operators/1_neg.cc (revision 124242)
+++ testsuite/23_containers/map/operators/1_neg.cc (working copy)
@@ -42,5 +42,5 @@
test &= itr == mapByName.end(); // { dg-error "no" }
}
-// { dg-error "candidates are" "" { target *-*-* } 210 }
-// { dg-error "candidates are" "" { target *-*-* } 214 }
+// { dg-error "candidates are" "" { target *-*-* } 211 }
+// { dg-error "candidates are" "" { target *-*-* } 215 }