+2008-11-11 Bob Walters <bob.s.walters@gmail.com>
+
+ * include/bits/forward_list.h: Support non-standard pointer types
+ (_Fwd_list_node_base): Add _Alloc template parameter.
+ (_Fwd_list_node<>): Likewise.
+ (_Fwd_list_iterator<>): Likewise.
+ (_Fwd_list_const_iterator<>): Likewise.
+ (_Fwd_list_node_base::_M_next, _M_transfer_after, _M_reverse_after):
+ Use _Alloc<_Tp>::pointer.
+ (_Fwd_list_iterator<>::_M_node): Use _Node_base::_Pointer.
+ (_Fwd_list_base<>::_M_get_node, _M_create_node, _M_create_node,
+ _M_insert_after, _M_put_node, _M_erase_after): Likewise.
+ (_Fwd_list_const_iterator<>::_M_node): use _Node_base::_Const_pointer.
+ (forward_list<>): Use __static_pointer_cast in place of static_cast,
+ and __const_pointer_cast in place of const_cast.
+ * include/bits/forward_list.tcc
+ (_Fwd_list_node<>::_M_sort_after): Using _Pointer typedefs in place
+ of standard pointers, __static_pointer_cast in place of static_cast.
+ (_Fwd_list_base<>::_Fwd_list_base, _M_insert_after, _M_erase_after):
+ Likewise.
+ (forward_list<>::_M_initialize_dispatch, _M_fill_initialize,
+ splice_after, remove, remove_if, merge): Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/modifiers/1.cc: New.
+ * testsuite/23_containers/forward_list/ext_pointer/modifiers/2.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/modifiers/3.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/modifiers/4.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/modifiers/5.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/operations/1.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/operations/2.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/operations/3.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/operations/4.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/operations/5.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/operations/6.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/operations/7.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/requirements/1.cc:
+ Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/requirements/
+ explicit_instantiation/1.cc: Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/requirements/
+ explicit_instantiation/3.cc: Likewise.
+ * testsuite/23_containers/forward_list/ext_pointer/1.cc: Likewise.
+
2008-11-11 Paolo Carlini <paolo.carlini@oracle.com>
* include/ext/extptr_allocator.h: Minor tweaks.
#include <memory>
#include <initializer_list>
+#include <ext/cast.h>
_GLIBCXX_BEGIN_NAMESPACE(std)
+ using __gnu_cxx::__static_pointer_cast;
+ using __gnu_cxx::__const_pointer_cast;
+
/**
* @brief A helper basic node class for @forward_list.
* This is just a linked list with nothing inside it.
* There are purely list shuffling utility methods here.
*/
- struct _Fwd_list_node_base
- {
- _Fwd_list_node_base() : _M_next(0) { }
-
- _Fwd_list_node_base* _M_next;
-
- static void
- swap(_Fwd_list_node_base& __x, _Fwd_list_node_base& __y)
- { std::swap(__x._M_next, __y._M_next); }
-
- void
- _M_transfer_after(_Fwd_list_node_base* __bbegin,
- _Fwd_list_node_base* __bend)
- {
- _Fwd_list_node_base* __keep = __bbegin->_M_next;
- if (__bend)
- {
- __bbegin->_M_next = __bend->_M_next;
- __bend->_M_next = this->_M_next;
- }
- else
- __bbegin->_M_next = 0;
- this->_M_next = __keep;
- }
-
- void
- _M_transfer_after(_Fwd_list_node_base* __bbegin)
+ template<typename _Alloc>
+ struct _Fwd_list_node_base
{
- _Fwd_list_node_base* __bend = __bbegin;
- while (__bend && __bend->_M_next)
- __bend = __bend->_M_next;
- _M_transfer_after(__bbegin, __bend);
- }
-
- void
- _M_reverse_after()
- {
- _Fwd_list_node_base* __tail = this->_M_next;
- if (!__tail)
- return;
- while (_Fwd_list_node_base* __temp = __tail->_M_next)
- {
- _Fwd_list_node_base* __keep = this->_M_next;
- this->_M_next = __temp;
- __tail->_M_next = __temp->_M_next;
- this->_M_next->_M_next = __keep;
- }
- }
- };
+ // The type allocated by _Alloc cannot be this type, so we rebind
+ typedef typename _Alloc::template rebind<_Fwd_list_node_base<_Alloc> >
+ ::other::pointer _Pointer;
+ typedef typename _Alloc::template rebind<_Fwd_list_node_base<_Alloc> >
+ ::other::const_pointer _Const_pointer;
+
+ _Pointer _M_next;
+
+ _Fwd_list_node_base() : _M_next(0) { }
+
+ static void
+ swap(_Fwd_list_node_base& __x, _Fwd_list_node_base& __y)
+ { std::swap(__x._M_next, __y._M_next); }
+
+ void
+ _M_transfer_after(_Pointer __bbegin, _Pointer __bend)
+ {
+ _Pointer __keep = __bbegin->_M_next;
+ if (__bend)
+ {
+ __bbegin->_M_next = __bend->_M_next;
+ __bend->_M_next = this->_M_next;
+ }
+ else
+ __bbegin->_M_next = 0;
+ this->_M_next = __keep;
+ }
+
+ void
+ _M_transfer_after(_Pointer __bbegin)
+ {
+ _Pointer __bend = __bbegin;
+ while (__bend && __bend->_M_next)
+ __bend = __bend->_M_next;
+ _M_transfer_after(__bbegin, __bend);
+ }
+
+ void
+ _M_reverse_after()
+ {
+ _Pointer __tail = this->_M_next;
+ if (!__tail)
+ return;
+ while (_Pointer __temp = __tail->_M_next)
+ {
+ _Pointer __keep = this->_M_next;
+ this->_M_next = __temp;
+ __tail->_M_next = __temp->_M_next;
+ this->_M_next->_M_next = __keep;
+ }
+ }
+ };
/**
* @brief A helper node class for @forward_list.
* This is just a linked list with a data value in each node.
* There is a sorting utility method.
*/
- template<typename _Tp>
- struct _Fwd_list_node : public _Fwd_list_node_base
+ template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+ struct _Fwd_list_node : public _Fwd_list_node_base<_Alloc>
{
+ typedef typename _Alloc::template rebind<_Fwd_list_node<_Tp, _Alloc> >
+ ::other::pointer _Pointer;
+
template<typename... _Args>
_Fwd_list_node(_Args&&... __args)
- : _Fwd_list_node_base(), _M_value(std::forward<_Args>(__args)...) { }
+ : _Fwd_list_node_base<_Alloc>(),
+ _M_value(std::forward<_Args>(__args)...) { }
template<typename _Comp>
void
*
* All the functions are op overloads.
*/
- template<typename _Tp>
+ template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
struct _Fwd_list_iterator
{
- typedef _Fwd_list_iterator<_Tp> _Self;
- typedef _Fwd_list_node<_Tp> _Node;
+ typedef _Fwd_list_iterator<_Tp, _Alloc> _Self;
+ typedef _Fwd_list_node<_Tp, _Alloc> _Node;
+ typedef _Fwd_list_node_base<_Alloc> _Node_base;
typedef _Tp value_type;
- typedef _Tp* pointer;
- typedef _Tp& reference;
- typedef ptrdiff_t difference_type;
+ typedef typename _Alloc::pointer pointer;
+ typedef typename _Alloc::reference reference;
+ typedef typename _Alloc::difference_type difference_type;
typedef std::forward_iterator_tag iterator_category;
_Fwd_list_iterator() : _M_node() { }
explicit
- _Fwd_list_iterator(_Fwd_list_node_base* __n) : _M_node(__n) { }
+ _Fwd_list_iterator(typename _Node_base::_Pointer __n)
+ : _M_node(__n) { }
reference
operator*() const
- { return static_cast<_Node*>(this->_M_node)->_M_value; }
+ { return __static_pointer_cast<_Node*>(this->_M_node)->_M_value; }
pointer
operator->() const
- { return &static_cast<_Node*>(this->_M_node)->_M_value; }
+ { return &__static_pointer_cast<_Node*>(this->_M_node)->_M_value; }
_Self&
operator++()
return _Fwd_list_iterator(0);
}
- _Fwd_list_node_base* _M_node;
+ typename _Node_base::_Pointer _M_node;
};
/**
*
* All the functions are op overloads.
*/
- template<typename _Tp>
+ template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
struct _Fwd_list_const_iterator
{
- typedef _Fwd_list_const_iterator<_Tp> _Self;
- typedef const _Fwd_list_node<_Tp> _Node;
- typedef _Fwd_list_iterator<_Tp> iterator;
+ typedef _Fwd_list_const_iterator<_Tp, _Alloc> _Self;
+ typedef const _Fwd_list_node<_Tp, _Alloc> _Node;
+ typedef const _Fwd_list_node_base<_Alloc> _Node_base;
+ typedef _Fwd_list_iterator<_Tp, _Alloc> iterator;
- typedef _Tp value_type;
- typedef const _Tp* pointer;
- typedef const _Tp& reference;
- typedef ptrdiff_t difference_type;
- typedef std::forward_iterator_tag iterator_category;
+ typedef _Tp value_type;
+ typedef typename _Alloc::const_pointer pointer;
+ typedef typename _Alloc::const_reference reference;
+ typedef typename _Alloc::difference_type difference_type;
+ typedef std::forward_iterator_tag iterator_category;
_Fwd_list_const_iterator() : _M_node() { }
explicit
- _Fwd_list_const_iterator(const _Fwd_list_node_base* __n)
+ _Fwd_list_const_iterator(typename _Node_base::_Const_pointer __n)
: _M_node(__n) { }
_Fwd_list_const_iterator(const iterator& __iter)
reference
operator*() const
- { return static_cast<_Node*>(this->_M_node)->_M_value; }
+ { return __static_pointer_cast<_Node*>(this->_M_node)->_M_value; }
pointer
operator->() const
- { return &static_cast<_Node*>(this->_M_node)->_M_value; }
+ { return &__static_pointer_cast<_Node*>(this->_M_node)->_M_value; }
_Self&
operator++()
return _Fwd_list_const_iterator(0);
}
- const _Fwd_list_node_base* _M_node;
+ typename _Node_base::_Const_pointer _M_node;
};
/**
* @brief Forward list iterator equality comparison.
*/
- template<typename _Tp>
+ template<typename _Tp,class _Alloc>
inline bool
- operator==(const _Fwd_list_iterator<_Tp>& __x,
- const _Fwd_list_const_iterator<_Tp>& __y)
+ operator==(const _Fwd_list_iterator<_Tp, _Alloc>& __x,
+ const _Fwd_list_const_iterator<_Tp, _Alloc>& __y)
{ return __x._M_node == __y._M_node; }
/**
* @brief Forward list iterator inequality comparison.
*/
- template<typename _Tp>
+ template<typename _Tp,class _Alloc>
inline bool
- operator!=(const _Fwd_list_iterator<_Tp>& __x,
- const _Fwd_list_const_iterator<_Tp>& __y)
+ operator!=(const _Fwd_list_iterator<_Tp, _Alloc>& __x,
+ const _Fwd_list_const_iterator<_Tp, _Alloc>& __y)
{ return __x._M_node != __y._M_node; }
/**
* @brief Base class for @forward_list.
*/
- template<typename _Tp, typename _Alloc>
+ template<typename _Tp, typename _Alloc = allocator<_Tp> >
struct _Fwd_list_base
{
protected:
- typedef typename _Alloc::template rebind<_Fwd_list_node<_Tp>>::other
- _Node_alloc_type;
-
typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
+ typedef typename _Alloc::template
+ rebind<_Fwd_list_node<_Tp, _Tp_alloc_type>>::other _Node_alloc_type;
+
struct _Fwd_list_impl
: public _Node_alloc_type
{
- _Fwd_list_node_base _M_head;
+ _Fwd_list_node_base<_Tp_alloc_type> _M_head;
- _Fwd_list_impl()
- : _Node_alloc_type(), _M_head()
- { }
+ _Fwd_list_impl()
+ : _Node_alloc_type(), _M_head()
+ { }
_Fwd_list_impl(const _Node_alloc_type& __a)
- : _Node_alloc_type(__a), _M_head()
- { }
+ : _Node_alloc_type(__a), _M_head()
+ { }
};
_Fwd_list_impl _M_impl;
public:
- typedef _Fwd_list_iterator<_Tp> iterator;
- typedef _Fwd_list_const_iterator<_Tp> const_iterator;
+ typedef _Fwd_list_iterator<_Tp, _Tp_alloc_type> iterator;
+ typedef _Fwd_list_const_iterator<_Tp, _Tp_alloc_type> const_iterator;
- typedef _Fwd_list_node<_Tp> _Node;
+ typedef _Fwd_list_node<_Tp, _Tp_alloc_type> _Node;
+ typedef _Fwd_list_node_base<_Tp_alloc_type> _Node_base;
_Node_alloc_type&
_M_get_Node_allocator()
_Fwd_list_base(_Fwd_list_base&& __lst, const _Alloc& __a)
: _M_impl(__a)
- { _Fwd_list_node_base::swap(this->_M_impl._M_head,
- __lst._M_impl._M_head); }
+ { _Node_base::swap(this->_M_impl._M_head,
+ __lst._M_impl._M_head); }
_Fwd_list_base(_Fwd_list_base&& __lst)
: _M_impl(__lst._M_get_Node_allocator())
- { _Fwd_list_node_base::swap(this->_M_impl._M_head,
- __lst._M_impl._M_head); }
+ { _Node_base::swap(this->_M_impl._M_head,
+ __lst._M_impl._M_head); }
~_Fwd_list_base()
{ _M_erase_after(&_M_impl._M_head, 0); }
protected:
- _Node*
+ typename _Node::_Pointer
_M_get_node()
{ return _M_get_Node_allocator().allocate(1); }
template<typename... _Args>
- _Node*
+ typename _Node::_Pointer
_M_create_node(_Args&&... __args)
- {
- _Node* __node = this->_M_get_node();
- try
- {
- _M_get_Node_allocator().construct(__node,
- std::forward<_Args>(__args)...);
- __node->_M_next = 0;
- }
- catch(...)
- {
- this->_M_put_node(__node);
- __throw_exception_again;
- }
- return __node;
- }
+ {
+ typename _Node::_Pointer __node = this->_M_get_node();
+ try
+ {
+ _M_get_Node_allocator().construct(__node,
+ std::forward<_Args>(__args)...);
+ __node->_M_next = 0;
+ }
+ catch(...)
+ {
+ this->_M_put_node(__node);
+ __throw_exception_again;
+ }
+ return __node;
+ }
template<typename... _Args>
- _Fwd_list_node_base*
+ typename _Node_base::_Pointer
_M_insert_after(const_iterator __pos, _Args&&... __args);
void
- _M_put_node(_Node* __p)
+ _M_put_node(typename _Node::_Pointer __p)
{ _M_get_Node_allocator().deallocate(__p, 1); }
- _Fwd_list_node_base*
- _M_erase_after(_Fwd_list_node_base* __pos);
+ typename _Node_base::_Pointer
+ _M_erase_after(typename _Node_base::_Pointer __pos);
- _Fwd_list_node_base*
- _M_erase_after(_Fwd_list_node_base* __pos,
- _Fwd_list_node_base* __last);
+ typename _Node_base::_Pointer
+ _M_erase_after(typename _Node_base::_Pointer __pos,
+ typename _Node_base::_Pointer __last);
};
/**
{
private:
typedef _Fwd_list_base<_Tp, _Alloc> _Base;
- typedef _Fwd_list_node<_Tp> _Node;
+ typedef typename _Base::_Node _Node;
+ typedef typename _Base::_Node_base _Node_base;
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
public:
typedef typename _Tp_alloc_type::const_pointer const_pointer;
typedef typename _Tp_alloc_type::reference reference;
typedef typename _Tp_alloc_type::const_reference const_reference;
- typedef _Fwd_list_iterator<_Tp> iterator;
- typedef _Fwd_list_const_iterator<_Tp> const_iterator;
+
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef _Alloc allocator_type;
reference
front()
{
- _Node* __front = static_cast<_Node*>(this->_M_impl._M_head._M_next);
+ _Node* __front = __static_pointer_cast<_Node*>(this->_M_impl._M_head._M_next);
return __front->_M_value;
}
const_reference
front() const
{
- _Node* __front = static_cast<_Node*>(this->_M_impl._M_head._M_next);
+ _Node* __front =
+ __static_pointer_cast<_Node*>(this->_M_impl._M_head._M_next);
return __front->_M_value;
}
void
emplace_front(_Args&&... __args)
{ this->_M_insert_after(cbefore_begin(),
- std::forward<_Args>(__args)...); }
+ std::forward<_Args>(__args)...); }
/**
* @brief Add data to the front of the %forward_list.
iterator
emplace_after(const_iterator __pos, _Args&&... __args)
{ return iterator(this->_M_insert_after(__pos,
- std::forward<_Args>(__args)...)); }
+ std::forward<_Args>(__args)...)); }
/**
* @brief Inserts given value into %forward_list after specified
iterator
erase_after(const_iterator __pos)
{
- _Fwd_list_node_base* __tmp
- = const_cast<_Fwd_list_node_base*>(__pos._M_node);
+ _Node_base* __tmp = __const_pointer_cast<_Node_base*>(__pos._M_node);
if (__tmp)
return iterator(this->_M_erase_after(__tmp));
else
iterator
erase_after(const_iterator __pos, iterator __last)
{
- _Fwd_list_node_base* __tmp
- = const_cast<_Fwd_list_node_base*>(__pos._M_node);
- return iterator(this->_M_erase_after(__tmp, __last._M_node));
+ _Node_base* __tmp = __const_pointer_cast<_Node_base*>(__pos._M_node);
+ return iterator(this->_M_erase_after(__tmp, &*__last._M_node));
}
/**
*/
void
swap(forward_list&& __list)
- { _Fwd_list_node_base::swap(this->_M_impl._M_head,
- __list._M_impl._M_head); }
+ { _Node_base::swap(this->_M_impl._M_head, __list._M_impl._M_head); }
/**
* @brief Resizes the %forward_list to the specified number of
void
sort()
{
- _Node* __tmp = static_cast<_Node*>(&this->_M_impl._M_head);
+ _Node* __tmp = __static_pointer_cast<_Node*>(&this->_M_impl._M_head);
__tmp->_M_sort_after(std::less<_Tp>());
}
template<typename _Comp>
void
sort(_Comp __comp)
- {
- _Node* __tmp = static_cast<_Node*>(&this->_M_impl._M_head);
- __tmp->_M_sort_after(__comp);
- }
+ {
+ _Node* __tmp = __static_pointer_cast<_Node*>(&this->_M_impl._M_head);
+ __tmp->_M_sort_after(__comp);
+ }
/**
* @brief Reverse the elements in list.
private:
template<typename _Integer>
- void
- _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
- { _M_fill_initialize(static_cast<size_type>(__n), __x); }
+ void
+ _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+ { _M_fill_initialize(static_cast<size_type>(__n), __x); }
// Called by the range constructor to implement [23.1.1]/9
template<typename _InputIterator>
- void
- _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
- __false_type);
+ void
+ _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+ __false_type);
// Called by forward_list(n,v,a), and the range constructor when it
// turns out to be the same thing.
operator<(const forward_list<_Tp, _Alloc>& __lx,
const forward_list<_Tp, _Alloc>& __ly)
{ return std::lexicographical_compare(__lx.cbegin(), __lx.cend(),
- __ly.cbegin(), __ly.cend()); }
+ __ly.cbegin(), __ly.cend()); }
/// Based on operator==
template<typename _Tp, typename _Alloc>
* This node is assumed to be an empty head node (of type
* _Fwd_list_node_base).
*/
- template<typename _Tp>
+ template<typename _Tp, class _Alloc>
template<typename _Comp>
void
- _Fwd_list_node<_Tp>::
+ _Fwd_list_node<_Tp, _Alloc>::
_M_sort_after(_Comp __comp)
{
- // If `next' is 0, return immediately.
- _Fwd_list_node* __list = static_cast<_Fwd_list_node*>(this->_M_next);
- if (!__list)
- return;
-
- unsigned long __insize = 1;
-
- while (1)
- {
- _Fwd_list_node* __p = __list;
- __list = 0;
- _Fwd_list_node* __tail = 0;
-
- // Count number of merges we do in this pass.
- unsigned long __nmerges = 0;
-
- while (__p)
- {
- ++__nmerges;
- // There exists a merge to be done.
- // Step `insize' places along from p.
- _Fwd_list_node* __q = __p;
- unsigned long __psize = 0;
- for (unsigned long __i = 0; __i < __insize; ++__i)
- {
- ++__psize;
- __q = static_cast<_Fwd_list_node*>(__q->_M_next);
- if (!__q)
- break;
- }
-
- // If q hasn't fallen off end, we have two lists to merge.
- unsigned long __qsize = __insize;
-
- // Now we have two lists; merge them.
- while (__psize > 0 || (__qsize > 0 && __q))
- {
- // Decide whether next node of merge comes from p or q.
- _Fwd_list_node<_Tp>* __e;
- if (__psize == 0)
- {
- // p is empty; e must come from q.
- __e = __q;
- __q = static_cast<_Fwd_list_node*>(__q->_M_next);
- --__qsize;
- }
- else if (__qsize == 0 || !__q)
- {
- // q is empty; e must come from p.
- __e = __p;
- __p = static_cast<_Fwd_list_node*>(__p->_M_next);
- --__psize;
- }
- else if (__comp(__p->_M_value, __q->_M_value))
- {
- // First node of p is lower; e must come from p.
- __e = __p;
- __p = static_cast<_Fwd_list_node*>(__p->_M_next);
- --__psize;
- }
- else
- {
- // First node of q is lower; e must come from q.
- __e = __q;
- __q = static_cast<_Fwd_list_node*>(__q->_M_next);
- --__qsize;
- }
-
- // Add the next node to the merged list.
- if (__tail)
- __tail->_M_next = __e;
- else
- __list = __e;
- __tail = __e;
- }
-
- // Now p has stepped `insize' places along, and q has too.
- __p = __q;
- }
- __tail->_M_next = 0;
-
- // If we have done only one merge, we're finished.
- // Allow for nmerges == 0, the empty list case.
- if (__nmerges <= 1)
- {
- this->_M_next = __list;
- return;
- }
-
- // Otherwise repeat, merging lists twice the size.
- __insize *= 2;
- }
+ // If `next' is 0, return immediately.
+ _Pointer __list = __static_pointer_cast<_Pointer>(this->_M_next);
+ if (!__list)
+ return;
+
+ unsigned long __insize = 1;
+
+ while (1)
+ {
+ _Pointer __p = __list;
+ __list = 0;
+ _Pointer __tail = 0;
+
+ // Count number of merges we do in this pass.
+ unsigned long __nmerges = 0;
+
+ while (__p)
+ {
+ ++__nmerges;
+ // There exists a merge to be done.
+ // Step `insize' places along from p.
+ _Pointer __q = __p;
+ unsigned long __psize = 0;
+ for (unsigned long __i = 0; __i < __insize; ++__i)
+ {
+ ++__psize;
+ __q = __static_pointer_cast<_Pointer>(__q->_M_next);
+ if (!__q)
+ break;
+ }
+
+ // If q hasn't fallen off end, we have two lists to merge.
+ unsigned long __qsize = __insize;
+
+ // Now we have two lists; merge them.
+ while (__psize > 0 || (__qsize > 0 && __q))
+ {
+ // Decide whether next node of merge comes from p or q.
+ _Pointer __e;
+ if (__psize == 0)
+ {
+ // p is empty; e must come from q.
+ __e = __q;
+ __q = __static_pointer_cast<_Pointer>(__q->_M_next);
+ --__qsize;
+ }
+ else if (__qsize == 0 || !__q)
+ {
+ // q is empty; e must come from p.
+ __e = __p;
+ __p = __static_pointer_cast<_Pointer>(__p->_M_next);
+ --__psize;
+ }
+ else if (__comp(__p->_M_value, __q->_M_value))
+ {
+ // First node of p is lower; e must come from p.
+ __e = __p;
+ __p = __static_pointer_cast<_Pointer>(__p->_M_next);
+ --__psize;
+ }
+ else
+ {
+ // First node of q is lower; e must come from q.
+ __e = __q;
+ __q = __static_pointer_cast<_Pointer>(__q->_M_next);
+ --__qsize;
+ }
+
+ // Add the next node to the merged list.
+ if (__tail)
+ __tail->_M_next = __e;
+ else
+ __list = __e;
+ __tail = __e;
+ }
+
+ // Now p has stepped `insize' places along, and q has too.
+ __p = __q;
+ }
+ __tail->_M_next = 0;
+
+ // If we have done only one merge, we're finished.
+ // Allow for nmerges == 0, the empty list case.
+ if (__nmerges <= 1)
+ {
+ this->_M_next = __list;
+ return;
+ }
+
+ // Otherwise repeat, merging lists twice the size.
+ __insize *= 2;
+ }
}
template<typename _Tp, typename _Alloc>
: _M_impl(__a)
{
this->_M_impl._M_head._M_next = 0;
- _Fwd_list_node_base* __to = &this->_M_impl._M_head;
- _Node* __curr = static_cast<_Node*>(__lst._M_impl._M_head._M_next);
+ typename _Node_base::_Pointer __to = &this->_M_impl._M_head;
+ typename _Node::_Pointer __curr
+ = __static_pointer_cast<typename _Node::_Pointer>
+ (__lst._M_impl._M_head._M_next);
while (__curr)
- {
- __to->_M_next = _M_create_node(__curr->_M_value);
- __to = __to->_M_next;
- __curr = static_cast<_Node*>(__curr->_M_next);
- }
+ {
+ __to->_M_next = _M_create_node(__curr->_M_value);
+ __to = __to->_M_next;
+ __curr = __static_pointer_cast<typename _Node::_Pointer>
+ (__curr->_M_next);
+ }
}
template<typename _Tp, typename _Alloc>
template<typename... _Args>
- _Fwd_list_node_base*
+ typename _Fwd_list_base<_Tp, _Alloc>::_Node_base::_Pointer
_Fwd_list_base<_Tp, _Alloc>::
_M_insert_after(const_iterator __pos, _Args&&... __args)
{
- _Fwd_list_node_base* __to
- = const_cast<_Fwd_list_node_base*>(__pos._M_node);
- _Node* __thing = _M_create_node(std::forward<_Args>(__args)...);
- __thing->_M_next = __to->_M_next;
- __to->_M_next = __thing;
- return __to->_M_next;
+ typename _Node_base::_Pointer __to
+ = __const_pointer_cast<typename _Node_base::_Pointer>
+ (__pos._M_node);
+ typename _Node::_Pointer __thing
+ = __static_pointer_cast<typename _Node::_Pointer>(
+ _M_create_node(std::forward<_Args>(__args)...) );
+ __thing->_M_next = __to->_M_next;
+ __to->_M_next = __thing;
+ return __static_pointer_cast<typename _Node_base::_Pointer>
+ (__to->_M_next);
}
template<typename _Tp, typename _Alloc>
- _Fwd_list_node_base*
+ typename _Fwd_list_base<_Tp, _Alloc>::_Node_base::_Pointer
_Fwd_list_base<_Tp, _Alloc>::
- _M_erase_after(_Fwd_list_node_base* __pos)
+ _M_erase_after(typename _Node_base::_Pointer __pos)
{
- _Node* __curr = static_cast<_Node*>(__pos->_M_next);
+ typename _Node::_Pointer __curr
+ = __static_pointer_cast<typename _Node::_Pointer>(__pos->_M_next);
if (__curr)
- {
- _Fwd_list_node_base* __next = __curr->_M_next;
- __pos->_M_next = __next;
- _M_get_Node_allocator().destroy(__curr);
- _M_put_node(__curr);
- }
+ {
+ typename _Node_base::_Pointer __next = __curr->_M_next;
+ __pos->_M_next = __next;
+ _M_get_Node_allocator().destroy(__curr);
+ _M_put_node(__curr);
+ }
return __pos;
}
template<typename _Tp, typename _Alloc>
- _Fwd_list_node_base*
+ typename _Fwd_list_base<_Tp, _Alloc>::_Node_base::_Pointer
_Fwd_list_base<_Tp, _Alloc>::
- _M_erase_after(_Fwd_list_node_base* __pos, _Fwd_list_node_base* __last)
+ _M_erase_after(typename _Node_base::_Pointer __pos,
+ typename _Node_base::_Pointer __last)
{
- _Node* __curr = static_cast<_Node*>(__pos->_M_next);
+ typename _Node::_Pointer __curr
+ = __static_pointer_cast<typename _Node::_Pointer>(__pos->_M_next);
while (__curr)
- {
- _Node* __temp = __curr;
- __curr = static_cast<_Node*>(__curr->_M_next);
- _M_get_Node_allocator().destroy(__temp);
- _M_put_node(__temp);
- __pos->_M_next = __curr;
- if (__temp == __last)
- break;
- }
+ {
+ typename _Node::_Pointer __temp = __curr;
+ __curr = __static_pointer_cast<typename _Node::_Pointer>
+ (__curr->_M_next);
+ _M_get_Node_allocator().destroy(__temp);
+ _M_put_node(__temp);
+ __pos->_M_next = __curr;
+ if (__temp == __last)
+ break;
+ }
return __pos;
}
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
- _Fwd_list_node_base* __to = &this->_M_impl._M_head;
+ typename _Node_base::_Pointer __to = &this->_M_impl._M_head;
for (; __first != __last; ++__first)
{
__to->_M_next = this->_M_create_node(*__first);
forward_list<_Tp, _Alloc>::
_M_fill_initialize(size_type __n, const value_type& __value)
{
- _Fwd_list_node_base* __to = &this->_M_impl._M_head;
+ typename _Node_base::_Pointer __to = &this->_M_impl._M_head;
for (; __n > 0; --__n)
{
__to->_M_next = this->_M_create_node(__value);
operator=(const forward_list& __list)
{
if (&__list != this)
- {
- iterator __prev1 = before_begin();
- iterator __curr1 = begin();
- iterator __last1 = end();
- const_iterator __first2 = __list.cbegin();
- const_iterator __last2 = __list.cend();
- while (__curr1 != __last1 && __first2 != __last2)
- {
- *__curr1 = *__first2;
- ++__prev1;
- ++__curr1;
- ++__first2;
- }
- if (__first2 == __last2)
- erase_after(__prev1, __last1);
- else
- insert_after(__prev1, __first2, __last2);
- }
+ {
+ iterator __prev1 = before_begin();
+ iterator __curr1 = begin();
+ iterator __last1 = end();
+ const_iterator __first2 = __list.cbegin();
+ const_iterator __last2 = __list.cend();
+ while (__curr1 != __last1 && __first2 != __last2)
+ {
+ *__curr1 = *__first2;
+ ++__prev1;
+ ++__curr1;
+ ++__first2;
+ }
+ if (__first2 == __last2)
+ erase_after(__prev1, __last1);
+ else
+ insert_after(__prev1, __first2, __last2);
+ }
return *this;
}
size_type __len = 0;
while (__k._M_next() != end() && __len < __sz)
- {
- ++__k;
- ++__len;
- }
+ {
+ ++__k;
+ ++__len;
+ }
if (__len == __sz)
- erase_after(__k, end());
+ erase_after(__k, end());
else
- insert_after(__k, __sz - __len, __val);
+ insert_after(__k, __sz - __len, __val);
}
template<typename _Tp, typename _Alloc>
splice_after(const_iterator __pos, forward_list&& __list)
{
if (!__list.empty() && &__list != this)
- {
- _Fwd_list_node_base* __tmp
- = const_cast<_Fwd_list_node_base*>(__pos._M_node);
- const_iterator __before = __list.cbefore_begin();
- __tmp->_M_transfer_after(const_cast<_Fwd_list_node_base*>
- (__before._M_node));
- }
+ {
+ typename _Node_base::_Pointer __tmp
+ = __const_pointer_cast<typename _Node_base::_Pointer>
+ (__pos._M_node);
+ const_iterator __before = __list.cbefore_begin();
+ __tmp->_M_transfer_after(__const_pointer_cast
+ <typename _Node_base::_Pointer>
+ (__before._M_node));
+ }
}
template<typename _Tp, typename _Alloc>
void
forward_list<_Tp, _Alloc>::
splice_after(const_iterator __pos, forward_list&& __list,
- const_iterator __before, const_iterator __last)
+ const_iterator __before, const_iterator __last)
{
- _Fwd_list_node_base* __tmp
- = const_cast<_Fwd_list_node_base*>(__pos._M_node);
- __tmp->_M_transfer_after(const_cast<_Fwd_list_node_base*>
- (__before._M_node),
- const_cast<_Fwd_list_node_base*>
- (__last._M_node));
+ typename _Node_base::_Pointer __tmp
+ = __const_pointer_cast<typename _Node_base::_Pointer>(__pos._M_node);
+ __tmp->_M_transfer_after(__const_pointer_cast
+ <typename _Node_base::_Pointer>
+ (__before._M_node),
+ __const_pointer_cast
+ <typename _Node_base::_Pointer>
+ (__last._M_node));
}
template<typename _Tp, typename _Alloc>
forward_list<_Tp, _Alloc>::
remove(const _Tp& __val)
{
- _Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head);
- while (_Node* __temp = static_cast<_Node*>(__curr->_M_next))
- {
- if (__temp->_M_value == __val)
- this->_M_erase_after(__curr);
- else
- __curr = static_cast<_Node*>(__curr->_M_next);
- }
+ typename _Node::_Pointer __curr
+ = __static_pointer_cast<typename _Node::_Pointer>
+ (&this->_M_impl._M_head);
+ while (typename _Node::_Pointer __temp =
+ __static_pointer_cast<typename _Node::_Pointer>(__curr->_M_next))
+ {
+ if (__temp->_M_value == __val)
+ this->_M_erase_after(__curr);
+ else
+ __curr = __static_pointer_cast<typename _Node::_Pointer>
+ (__curr->_M_next);
+ }
}
template<typename _Tp, typename _Alloc>
forward_list<_Tp, _Alloc>::
remove_if(_Pred __pred)
{
- _Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head);
- while (_Node* __temp = static_cast<_Node*>(__curr->_M_next))
- {
- if (__pred(__temp->_M_value))
- this->_M_erase_after(__curr);
- else
- __curr = static_cast<_Node*>(__curr->_M_next);
- }
+ typename _Node::_Pointer __curr
+ = __static_pointer_cast<typename _Node::_Pointer>
+ (&this->_M_impl._M_head);
+ while (typename _Node::_Pointer __temp =
+ __static_pointer_cast<typename _Node::_Pointer>(__curr->_M_next))
+ {
+ if (__pred(__temp->_M_value))
+ this->_M_erase_after(__curr);
+ else
+ __curr = __static_pointer_cast<typename _Node::_Pointer>
+ (__curr->_M_next);
+ }
}
template<typename _Tp, typename _Alloc>
iterator __first = begin();
iterator __last = end();
if (__first == __last)
- return;
+ return;
iterator __next = __first;
while (++__next != __last)
- {
- if (__binary_pred(*__first, *__next))
- erase_after(__first);
- else
- __first = __next;
- __next = __first;
- }
+ {
+ if (__binary_pred(*__first, *__next))
+ erase_after(__first);
+ else
+ __first = __next;
+ __next = __first;
+ }
}
template<typename _Tp, typename _Alloc>
forward_list<_Tp, _Alloc>::
merge(forward_list&& __list, _Comp __comp)
{
- _Fwd_list_node_base* __node = &this->_M_impl._M_head;
+ typename _Node_base::_Pointer __node = &this->_M_impl._M_head;
while (__node->_M_next && __list._M_impl._M_head._M_next)
{
- if (__comp(static_cast<_Node*>
- (__list._M_impl._M_head._M_next)->_M_value,
- static_cast<_Node*>
- (__node->_M_next)->_M_value))
+ if (__comp(__static_pointer_cast<typename _Node::_Pointer>
+ (__list._M_impl._M_head._M_next)->_M_value,
+ __static_pointer_cast<typename _Node::_Pointer>
+ (__node->_M_next)->_M_value))
__node->_M_transfer_after(&__list._M_impl._M_head,
__list._M_impl._M_head._M_next);
__node = __node->_M_next;
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list capacity [lib.forward_list.capacity]
+
+#include <forward_list>
+#include <ext/extptr_allocator.h>
+#include <testsuite_hooks.h>
+
+bool test __attribute__((unused)) = true;
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+// This test verifies the following.
+//
+void
+test01()
+{
+ std::forward_list<double, _ExtPtr_allocator<double> > fld;
+
+ VERIFY(fld.empty() == true);
+ fld.push_front(1.0);
+ VERIFY(fld.empty() == false);
+ fld.resize(0);
+ VERIFY(fld.empty() == true);
+}
+
+void
+test02()
+{
+ std::forward_list<int, _ExtPtr_allocator<int> > a, b;
+ a.push_front(1);
+
+ b = std::move(a);
+ VERIFY(b.empty() == false);
+ VERIFY(*b.begin() == 1);
+ VERIFY(a.empty() == true);
+
+ std::forward_list<int, _ExtPtr_allocator<int> > c(std::move(b));
+ VERIFY(c.empty() == false);
+ (*c.begin() == 1 );
+ VERIFY( b.empty() == true );
+}
+
+// Test various constrcutors
+void
+test03()
+{
+ const int ni = 10;
+ int i[ni] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+ _ExtPtr_allocator<int> alloc;
+
+ std::forward_list<int, _ExtPtr_allocator<int> > flccin(i, i+ni);
+ std::forward_list<int, _ExtPtr_allocator<int> > flc(flccin);
+ std::forward_list<int, _ExtPtr_allocator<int> > flm(std::move(flccin));
+ std::forward_list<int, _ExtPtr_allocator<int> > flcc(flccin, alloc );
+ std::forward_list<int, _ExtPtr_allocator<int> > flmc(
+ std::forward_list<int, _ExtPtr_allocator<int> >(i, i+ni), alloc);
+ std::forward_list<double, _ExtPtr_allocator<double> > flil(
+ {1.0, 2.0, 3.0, 4.0, 5.0});
+}
+
+// Test constrcutors
+// Construction from given number of default item
+// Construction from given number of given item
+void
+test04()
+{
+ std::forward_list<double, _ExtPtr_allocator<double> > flvd(10);
+ std::forward_list<float, _ExtPtr_allocator<float> > flv(10, 5.0F);
+}
+
+int
+main()
+{
+ test01();
+ test02();
+ test03();
+ test04();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <ext/extptr_allocator.h>
+#include <testsuite_hooks.h>
+
+#include <array>
+
+bool test __attribute__((unused)) = true;
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+class PathPoint
+{
+public:
+ PathPoint(char t, std::array<double, 3> & c)
+ : type(t), coord(c) { }
+ char getType() const { return type; }
+private:
+ char type;
+ std::array<double, 3> coord;
+};
+
+// This test verifies the following.
+// emplace_front
+// pop_front
+// emplace_after
+void
+test01()
+{
+ std::forward_list<PathPoint, _ExtPtr_allocator<PathPoint> > path;
+ std::array<double, 3> coord1 = { { 0.0, 1.0, 2.0 } };
+ path.emplace_front('a', coord1);
+
+ std::forward_list<PathPoint, _ExtPtr_allocator<PathPoint> >::const_iterator pos = path.cbegin();
+
+ std::array<double, 3> coord2 = { { 3.0, 4.0, 5.0 } };
+ path.emplace_after(pos, 'b', coord2);
+
+ VERIFY(path.front().getType() == 'a');
+
+ path.pop_front();
+
+ VERIFY(path.front().getType() == 'b');
+
+ path.pop_front();
+
+ VERIFY(path.empty() == true);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <ext/extptr_allocator.h>
+#include <testsuite_hooks.h>
+
+#include <string>
+
+bool test __attribute__((unused)) = true;
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+// This test verifies the following:
+// insert_after single item
+// before_begin iterator
+void
+test01()
+{
+ std::forward_list<int, _ExtPtr_allocator<int> > fl(
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+
+ fl.insert_after(fl.before_begin(), 42);
+ VERIFY(fl.front() == 42);
+}
+
+// This test verifies the following:
+void
+test02()
+{
+ std::forward_list<int, _ExtPtr_allocator<int> > fl(
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+
+ std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
+ pos = fl.cbegin();
+
+ ++pos;
+ VERIFY(*pos == 1);
+
+ // Note: Calling l.insert_after(pos, 5, 42); without the long five
+ // gets resolved to the iterator range version and fails to compile!
+ fl.insert_after(pos, 5, 42);
+ VERIFY(*pos == 1);
+
+ ++pos;
+ VERIFY(*pos == 42);
+ ++pos;
+ ++pos;
+ ++pos;
+ ++pos;
+ VERIFY(*pos == 42);
+}
+
+// This test verifies the following:
+void
+test03()
+{
+ std::forward_list<int, _ExtPtr_allocator<int> > fl(
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+
+ std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
+ pos = fl.cbegin();
+
+ ++pos;
+ VERIFY(*pos == 1);
+
+ int i[3] = {666, 777, 888};
+ fl.insert_after(pos, i, i+3);
+ VERIFY(*pos == 1);
+
+ ++pos;
+ ++pos;
+ ++pos;
+ VERIFY(*pos == 888);
+ ++pos;
+ VERIFY(*pos == 2);
+}
+
+// This test verifies the following:
+void
+test04()
+{
+ std::forward_list<int, _ExtPtr_allocator<int> > fl(
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+
+ std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
+ pos = fl.cbegin();
+
+ ++pos;
+ VERIFY(*pos == 1);
+
+ fl.insert_after(pos, {-1, -2, -3, -4, -5});
+ VERIFY(*pos == 1);
+
+ ++pos;
+ ++pos;
+ ++pos;
+ VERIFY(*pos == -3);
+}
+
+// This test verifies the following:
+void
+test05()
+{
+ std::forward_list<std::string, _ExtPtr_allocator<std::string> > fl(
+ {"AAA", "BBB", "CCC"});
+
+ std::forward_list<std::string, _ExtPtr_allocator<std::string> >::const_iterator
+ pos = fl.cbegin();
+
+ ++pos;
+ VERIFY(*pos == "BBB");
+
+ std::string x( "XXX" );
+ fl.insert_after(pos, std::move(x));
+ VERIFY(*pos == "BBB");
+ ++pos;
+ VERIFY(*pos == "XXX");
+ ++pos;
+ VERIFY(*pos == "CCC");
+}
+
+int
+main()
+{
+ test01();
+ test02();
+ test03();
+ test04();
+ test05();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <ext/extptr_allocator.h>
+#include <testsuite_hooks.h>
+
+bool test __attribute__((unused)) = true;
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+// This test verifies the following:
+// cbegin
+// erase_after one iterator
+// pos is useable and points to current element
+void
+test01()
+{
+ std::forward_list<int, _ExtPtr_allocator<int> > fl(
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+
+ std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
+ pos = fl.cbegin();
+
+ ++pos;
+ VERIFY(*pos == 1);
+
+ std::forward_list<int, _ExtPtr_allocator<int> >::iterator
+ next = fl.erase_after(pos);
+
+ VERIFY(*next == 1);
+
+ VERIFY(*pos == 1);
+ ++pos;
+ VERIFY(*pos == 3);
+}
+
+// This test verifies the following:
+// cbegin
+// erase_after iterator range
+// pos is useable and points to current element
+void
+test02()
+{
+ std::forward_list<int, _ExtPtr_allocator<int> > fl(
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+
+ std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
+ pos = fl.cbegin();
+
+ ++pos;
+ VERIFY(*pos == 1);
+
+ std::forward_list<int, _ExtPtr_allocator<int> >::iterator
+ stop = fl.begin();
+
+ ++stop;
+ ++stop;
+ ++stop;
+ ++stop;
+ VERIFY(*stop == 4);
+
+ std::forward_list<int, _ExtPtr_allocator<int> >::iterator
+ next = fl.erase_after(pos, stop);
+
+ VERIFY(*next == 1);
+
+ VERIFY(*pos == 1);
+ ++pos;
+ VERIFY(*pos == 5);
+}
+
+int
+main()
+{
+ test01();
+ test02();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <ext/extptr_allocator.h>
+#include <testsuite_hooks.h>
+
+bool test __attribute__((unused)) = true;
+
+
+// This test verifies the following:
+// swap
+void
+test01()
+{
+ std::forward_list<int> fl1({0, 1, 2, 3, 4, 5});
+ std::forward_list<int> fl2({666, 777, 888});
+
+ fl1.swap(fl2);
+
+ VERIFY(fl1.front() == 666);
+ VERIFY(fl2.front() == 0);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <ext/extptr_allocator.h>
+#include <testsuite_hooks.h>
+
+bool test __attribute__((unused)) = true;
+
+// This test verifies the following:
+// clear
+void
+test01()
+{
+ std::forward_list<int, __gnu_cxx::_ExtPtr_allocator<int> > fl(
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+
+ VERIFY(fl.empty() == false);
+
+ fl.clear();
+
+ VERIFY(fl.empty() == true);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <testsuite_hooks.h>
+#include <ext/extptr_allocator.h>
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+bool test __attribute__((unused)) = true;
+
+// This test verifies the following:
+//
+void
+test01()
+{
+ typedef std::forward_list<double, _ExtPtr_allocator<double> > fwd_list_type;
+
+ fwd_list_type a = {0.0, 1.0, 2.0, 3.0, 4.0};
+ fwd_list_type::const_iterator posa = a.cbefore_begin();
+
+ fwd_list_type x = {666.0, 777.0, 888.0};
+
+ a.splice_after(posa, x);
+
+ ++posa;
+ VERIFY(*posa == 666.0);
+
+ VERIFY(x.empty() == true);
+}
+
+// This test verifies the following:
+//
+void
+test02()
+{
+ typedef std::forward_list<double, _ExtPtr_allocator<double> > fwd_list_type;
+
+ fwd_list_type a = {0.0, 1.0, 2.0, 3.0, 4.0};
+ fwd_list_type::const_iterator posa = a.cbefore_begin();
+ ++posa;
+ VERIFY(*posa == 0.0);
+
+ fwd_list_type y = {10.0, 11.0, 12.0, 13.0, 14.0, 15.0};
+ fwd_list_type::const_iterator befy = y.cbefore_begin();
+ ++befy;
+ VERIFY(*befy == 10.0);
+ fwd_list_type::const_iterator endy = befy;
+ ++endy;
+ ++endy;
+ ++endy;
+ ++endy;
+ VERIFY(*endy == 14.0);
+
+ a.splice_after(posa, y, befy, endy);
+ VERIFY(*posa == 0.0);
+
+ VERIFY(*befy == 10.0);
+ ++befy;
+ VERIFY(*befy == 15.0);
+}
+
+// This test verifies the following:
+//
+void
+test03()
+{
+ typedef std::forward_list<double, _ExtPtr_allocator<double> > fwd_list_type;
+
+ fwd_list_type a = {0.0, 1.0, 2.0, 3.0, 4.0};
+ fwd_list_type::const_iterator posa = a.cbefore_begin();
+ ++posa;
+ ++posa;
+ VERIFY(*posa == 1.0);
+
+ fwd_list_type z = {42.0, 43.0, 44.0};
+ fwd_list_type::const_iterator posz = z.begin();
+ VERIFY(*posz == 42.0);
+
+ a.splice_after(posa, z, posz);
+ VERIFY(*posa == 1.0);
+ ++posa;
+ VERIFY(*posa == 43.0);
+
+ VERIFY(*posz == 42.0);
+ ++posz;
+ VERIFY(*posz == 44.0);
+}
+
+int
+main()
+{
+ test01();
+ test02();
+ test03();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <testsuite_hooks.h>
+#include <ext/extptr_allocator.h>
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+bool test __attribute__((unused)) = true;
+
+// This test verifies the following:
+// remove
+void
+test01()
+{
+ std::forward_list<int, _ExtPtr_allocator<int> > fl =
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+ fl.remove(7);
+
+ std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
+ pos = fl.cbefore_begin();
+
+ for (std::size_t i = 0; i < 7; ++i)
+ ++pos;
+ VERIFY(*pos == 6);
+
+ ++pos;
+ VERIFY(*pos == 8);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <testsuite_hooks.h>
+#include <ext/extptr_allocator.h>
+
+#include <algorithm>
+
+bool test __attribute__((unused)) = true;
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+// This test verifies the following:
+// remove_if
+void
+test01()
+{
+ std::forward_list<int, _ExtPtr_allocator<int> > fl =
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+ fl.remove_if(std::bind2nd(std::less<int>(),5));
+
+ std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
+ pos = fl.cbegin();
+ VERIFY(*pos == 5);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <testsuite_hooks.h>
+#include <ext/extptr_allocator.h>
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+bool test __attribute__((unused)) = true;
+
+// This test verifies the following:
+// unique
+void
+test01()
+{
+ std::forward_list<int, _ExtPtr_allocator<int> > fl =
+ {99, 5, 99, 6, -5, 666, 777, 888, 42, 42, 42, 42, 42, 7, 0, 0, 0, 9, 9, 9};
+
+ fl.unique();
+
+ std::forward_list<int, _ExtPtr_allocator<int> > fl2 =
+ {99, 5, 99, 6, -5, 666, 777, 888, 42, 7, 0, 9};
+
+ VERIFY(fl == fl2);
+}
+
+// Test comparison predicate.
+template<typename Num>
+ class Mod
+ {
+ public:
+ Mod(const Num & mod)
+ {
+ m = mod;
+ }
+ bool operator()(const Num i, const Num j)
+ {
+ return i%m == j%m;
+ }
+ private:
+ Num m;
+ };
+
+// This test verifies the following:
+// unique with predicate
+void
+test02()
+{
+ std::forward_list<int, _ExtPtr_allocator<int> > fl =
+ {99, 5, 99, 6, -5, 666, 777, 888, 42, 7, 0, 9};
+
+ fl.unique(Mod<int>(111));
+
+ std::forward_list<int, _ExtPtr_allocator<int> > fl2 =
+ {99, 5, 99, 6, -5, 666, 42, 7, 0, 9};
+
+ VERIFY(fl == fl2);
+}
+
+int
+main()
+{
+ test01();
+ test02();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <testsuite_hooks.h>
+#include <ext/extptr_allocator.h>
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+bool test __attribute__((unused)) = true;
+
+// This test verifies the following:
+//
+void
+test01()
+{
+ typedef std::forward_list<double, _ExtPtr_allocator<double> > fwd_list_type;
+
+ fwd_list_type a = {0.0, 1.0, 2.0, 3.0, 4.0};
+ fwd_list_type b = {1.0, 2.0, 3.0, 4.0, 4.0, 5.0};
+
+ a.merge(b);
+
+ fwd_list_type r = {0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 4.0, 5.0};
+
+ VERIFY(a == r);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <testsuite_hooks.h>
+#include <ext/extptr_allocator.h>
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+bool test __attribute__((unused)) = true;
+
+// Comparison functor.
+template<typename Num>
+ class Comp
+ {
+ public:
+ Comp(const Num & num)
+ {
+ n = num;
+ }
+ bool operator()(const Num i, const Num j)
+ {
+ return (n * i) < (n * j);
+ }
+ private:
+ Num n;
+ };
+
+// This test verifies the following:
+//
+void
+test01()
+{
+ typedef std::forward_list<int, _ExtPtr_allocator<int> > fwd_list_type;
+
+ const unsigned int n = 13;
+ int order[][n] = {
+ { 0,1,2,3,4,5,6,7,8,9,10,11,12 },
+ { 6,2,8,4,11,1,12,7,3,9,5,0,10 },
+ { 12,11,10,9,8,7,6,5,4,3,2,1,0 },
+ };
+ fwd_list_type sorted(order[0], order[0] + n);
+
+ for (unsigned int i = 0; i < sizeof(order)/sizeof(*order); ++i)
+ {
+ fwd_list_type head(order[i], order[i] + n);
+
+ head.sort();
+
+ VERIFY(head == sorted);
+ }
+
+ fwd_list_type reversed(order[2], order[2] + n);
+ for (unsigned int i = 0; i < sizeof(order)/sizeof(*order); ++i)
+ {
+ fwd_list_type head(order[i], order[i] + n);
+
+ Comp<int> comp(-1);
+ head.sort( comp );
+
+ VERIFY(head == reversed);
+ }
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <testsuite_hooks.h>
+#include <ext/extptr_allocator.h>
+
+#include <algorithm>
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+bool test __attribute__((unused)) = true;
+
+// This test verifies the following:
+//
+void
+test01()
+{
+ const unsigned int n = 13;
+ int order[n] = {0,1,2,3,4,5,6,7,8,9,10,11,12};
+
+ std::forward_list<int, _ExtPtr_allocator<int> > fl(order, order + n);
+
+ std::forward_list<int, _ExtPtr_allocator<int> > fl2;
+ for (std::size_t i = 0; i < n; ++i)
+ fl2.push_front(order[i]);
+
+ fl.reverse();
+
+ VERIFY(std::lexicographical_compare(fl.begin(), fl.end(),
+ fl2.begin(), fl2.end()) == false);
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
+
+#include <forward_list>
+#include <ext/extptr_allocator.h>
+#include <testsuite_hooks.h>
+
+using __gnu_cxx::_ExtPtr_allocator;
+
+bool test __attribute__((unused)) = true;
+
+// A nontrivial type.
+template<typename T>
+ struct A { };
+
+// Another nontrivial type
+struct B { };
+
+// A nontrivial type convertible from an int
+struct C
+{
+ C(int i) : i_(i) { }
+ bool operator==(const C& rhs) { return i_ == rhs.i_; }
+ int i_;
+};
+
+// This test verifies the following.
+//
+void
+test01()
+{
+ std::forward_list< A<B>, _ExtPtr_allocator<A<B> > > lst;
+ VERIFY(lst.begin() == lst.end());
+ VERIFY(std::distance(lst.begin(), lst.end()) == 0);
+
+ // check type definitions -- will fail compile if missing
+ typedef std::forward_list< A<B> >::reference reference;
+ typedef std::forward_list< A<B> >::const_reference const_reference;
+ typedef std::forward_list< A<B> >::iterator iterator;
+ typedef std::forward_list< A<B> >::const_iterator const_iterator;
+ typedef std::forward_list< A<B> >::size_type size_type;
+ typedef std::forward_list< A<B> >::difference_type difference_type;
+ typedef std::forward_list< A<B> >::value_type value_type;
+ typedef std::forward_list< A<B> >::allocator_type allocator_type;
+ typedef std::forward_list< A<B> >::pointer pointer;
+ typedef std::forward_list< A<B> >::const_pointer const_pointer;
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// This file tests explicit instantiation of library containers
+
+#include <forward_list>
+#include <ext/extptr_allocator.h>
+
+// { dg-do compile }
+
+template class std::forward_list<int, __gnu_cxx::_ExtPtr_allocator<int> >;
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// This file tests explicit instantiation of library containers
+
+#include <forward_list>
+#include <ext/extptr_allocator.h>
+
+// { dg-do compile }
+
+// libstdc++/21770
+template class std::forward_list<int, __gnu_cxx::_ExtPtr_allocator<char> >;
OSDN Git Service
