+2004-04-16 Benjamin Kosnik <bkoz@redhat.com>
+
+ * include/bits/c++config (_GLIBCXX_STD): New.
+ * src/list.cc: Use it.
+ * include/std/std_bitset.h: Same.
+ * include/bits/vector.tcc: Same.
+ * include/bits/stl_set.h: Same.
+ * include/bits/stl_multiset.h: Same.
+ * include/bits/stl_multimap.h: Same.
+ * include/bits/stl_map.h: Same.
+ * include/bits/stl_list.h: Same.
+ * include/bits/stl_vector.h: Same.
+ * include/bits/stl_bvector.h: Same.
+ * include/bits/stl_deque.h: Same.
+ * include/bits/deque.tcc: Same.
+ * include/bits/list.tcc: Same.
+ * include/debug/vector: Same.
+ * include/debug/set.h: Same.
+ * include/debug/multiset.h: Same.
+ * include/debug/multimap.h: Same.
+ * include/debug/map.h: Same.
+ * include/debug/list: Same.
+ * include/debug/deque: Same.
+ * include/debug/bitset: Same.
+ * include/debug/formatter.h (__gnu_debug): Remove using directive.
+ Add using declaration for std::type_info.
+ * include/debug/safe_iterator.h: Add using declaration for
+ std::iterator_traits and std::pair.
+ * src/debug_list.cc: New.
+ * src/Makefile.am: Add debug_list.cc.
+ * src/Makefile.in: Regenerate.
+ * config/linker-map.gnu: Add _List_node_base exports for std and
+ __gnu_norm.
+
+ * include/bits/stl_bvector.h (_Bvector_base): Use _Bvector_impl
+ idiom that other containers use.
+ * testsuite/23_containers/vector/bool/clear_allocator.cc: New.
+
2004-04-16 Paolo Carlini <pcarlini@suse.de>
PR libstdc++/14975
$(top_srcdir)/configure $(top_srcdir)/fragment.am \
$(top_srcdir)/scripts/check_survey.in \
$(top_srcdir)/scripts/testsuite_flags.in ../ABOUT-NLS \
- ../COPYING ../COPYING.LIB ../ChangeLog ../README \
+ ../COPYING ../COPYING.LIB ../ChangeLog ../README ../compile \
../config.guess ../config.rpath ../config.sub ../install-sh \
../ltcf-c.sh ../ltcf-cxx.sh ../ltcf-gcj.sh ../ltconfig \
../ltmain.sh ../missing ../mkinstalldirs ../ylwrap ChangeLog \
std::locale::_S_normalize_category*;
std::locale::_[T-Za-z]*;
std::[A-Zm-z]*;
+ std::_List_node_base::hook*;
+ std::_List_node_base::swap*;
+ std::_List_node_base::unhook*;
+ std::_List_node_base::reverse*;
+ std::_List_node_base::transfer*;
std::__throw_*;
std::__basic_file*;
std::__timepunct*;
std::__moneypunct_cache*;
std::__numpunct_cache*;
std::__timepunct_cache*;
- __gnu_norm::*;
__gnu_debug::_Safe_iterator_base*;
__gnu_debug::_Safe_sequence_base*;
- __gnu_debug::_Error_formatter*
+ __gnu_debug::_Error_formatter*;
+ __gnu_norm::_List_node_base::hook*;
+ __gnu_norm::_List_node_base::swap*;
+ __gnu_norm::_List_node_base::unhook*;
+ __gnu_norm::_List_node_base::reverse*;
+ __gnu_norm::_List_node_base::transfer*
};
# Names not in an 'extern' block are mangled names.
// Predefined symbols and macros -*- C++ -*-
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
# define _GLIBCXX_EXTERN_TEMPLATE 1
#endif
-// To enable debug mode.
-namespace __gnu_norm
-{
- using namespace std;
-}
-
+// Debug mode support. Debug mode basic_string is not allowed to be
+// associated with std, because of locale and exception link
+// dependence.
namespace __gnu_debug_def { }
namespace __gnu_debug
{
- using namespace __gnu_debug_def __attribute__ ((strong));
+ using namespace __gnu_debug_def;
}
+#ifdef _GLIBCXX_DEBUG
+# define _GLIBCXX_STD __gnu_norm
+namespace __gnu_norm
+{
+ using namespace std;
+}
namespace std
{
-#ifdef _GLIBCXX_DEBUG
using namespace __gnu_debug_def __attribute__ ((strong));
+}
#else
- using namespace __gnu_norm __attribute__ ((strong));
+# define _GLIBCXX_STD std
#endif
-}
+
// The remainder of the prewritten config is automatic; all the
// user hooks are listed above.
#ifndef _DEQUE_TCC
#define _DEQUE_TCC 1
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
template <typename _Tp, typename _Alloc>
deque<_Tp,_Alloc>&
this->_M_impl._M_start._M_set_node(__new_nstart);
this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
}
-} // namespace __gnu_norm
+} // namespace std
#endif
#ifndef _LIST_TCC
#define _LIST_TCC 1
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
template<typename _Tp, typename _Alloc>
void
swap( *(__fill-1) );
}
}
-} // namespace __gnu_norm
+} // namespace std
#endif /* _LIST_TCC */
-// bit_vector and vector<bool> specialization -*- C++ -*-
+// vector<bool> specialization -*- C++ -*-
// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
//
#ifndef _BVECTOR_H
#define _BVECTOR_H 1
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
typedef unsigned long _Bit_type;
enum { _S_word_bit = int(CHAR_BIT * sizeof(_Bit_type)) };
return *this;
}
- const_iterator operator+(difference_type __i) const {
+ const_iterator
+ operator+(difference_type __i) const {
const_iterator __tmp = *this;
return __tmp += __i;
}
template<class _Alloc>
class _Bvector_base
- : public _Alloc::template rebind<_Bit_type>::other
{
typedef typename _Alloc::template rebind<_Bit_type>::other
_Bit_alloc_type;
+
+ struct _Bvector_impl : public _Bit_alloc_type
+ {
+ _Bit_iterator _M_start;
+ _Bit_iterator _M_finish;
+ _Bit_type* _M_end_of_storage;
+ _Bvector_impl(const _Bit_alloc_type& __a)
+ : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
+ { }
+ };
public:
typedef _Alloc allocator_type;
allocator_type
get_allocator() const
- { return *static_cast<const _Bit_alloc_type*>(this); }
+ { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
- _Bvector_base(const allocator_type& __a)
- : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0) { }
+ _Bvector_base(const allocator_type& __a) : _M_impl(__a) { }
~_Bvector_base() { this->_M_deallocate(); }
protected:
+ _Bvector_impl _M_impl;
+
_Bit_type*
- _M_bit_alloc(size_t __n)
- { return _Bit_alloc_type::allocate((__n + _S_word_bit - 1)
- / _S_word_bit); }
+ _M_allocate(size_t __n)
+ { return _M_impl.allocate((__n + _S_word_bit - 1) / _S_word_bit); }
void
_M_deallocate()
{
- if (_M_start._M_p)
- _Bit_alloc_type::deallocate(_M_start._M_p,
- _M_end_of_storage - _M_start._M_p);
+ if (_M_impl._M_start._M_p)
+ _M_impl.deallocate(_M_impl._M_start._M_p,
+ _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
}
-
- _Bit_iterator _M_start;
- _Bit_iterator _M_finish;
- _Bit_type* _M_end_of_storage;
};
-} // namespace __gnu_norm
+} // namespace std
// Declare a partial specialization of vector<T, Alloc>.
#include <bits/stl_vector.h>
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
/**
* @brief A specialization of vector for booleans which offers fixed time
{ return _Bvector_base<_Alloc>::get_allocator(); }
protected:
- using _Bvector_base<_Alloc>::_M_bit_alloc;
+ using _Bvector_base<_Alloc>::_M_allocate;
using _Bvector_base<_Alloc>::_M_deallocate;
- using _Bvector_base<_Alloc>::_M_start;
- using _Bvector_base<_Alloc>::_M_finish;
- using _Bvector_base<_Alloc>::_M_end_of_storage;
protected:
void _M_initialize(size_type __n)
{
- _Bit_type* __q = this->_M_bit_alloc(__n);
- this->_M_end_of_storage = __q + (__n + _S_word_bit - 1) / _S_word_bit;
- this->_M_start = iterator(__q, 0);
- this->_M_finish = this->_M_start + difference_type(__n);
+ _Bit_type* __q = this->_M_allocate(__n);
+ this->_M_impl._M_end_of_storage = __q
+ + (__n + _S_word_bit - 1) / _S_word_bit;
+ this->_M_impl._M_start = iterator(__q, 0);
+ this->_M_impl._M_finish = this->_M_start + difference_type(__n);
}
void _M_insert_aux(iterator __position, bool __x)
{
- if (this->_M_finish._M_p != this->_M_end_of_storage)
+ if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
{
- std::copy_backward(__position, this->_M_finish, this->_M_finish + 1);
+ std::copy_backward(__position, this->_M_impl._M_finish,
+ this->_M_impl._M_finish + 1);
*__position = __x;
- ++this->_M_finish;
+ ++this->_M_impl._M_finish;
}
else
{
const size_type __len = size() ? 2 * size()
: static_cast<size_type>(_S_word_bit);
- _Bit_type * __q = this->_M_bit_alloc(__len);
+ _Bit_type * __q = this->_M_allocate(__len);
iterator __i = std::copy(begin(), __position, iterator(__q, 0));
*__i++ = __x;
- this->_M_finish = std::copy(__position, end(), __i);
+ this->_M_impl._M_finish = std::copy(__position, end(), __i);
this->_M_deallocate();
- this->_M_end_of_storage = __q + (__len + _S_word_bit - 1)
+ this->_M_impl._M_end_of_storage = __q + (__len + _S_word_bit - 1)
/ _S_word_bit;
- this->_M_start = iterator(__q, 0);
+ this->_M_impl._M_start = iterator(__q, 0);
}
}
void _M_initialize_range(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
{
- this->_M_start = iterator();
- this->_M_finish = iterator();
- this->_M_end_of_storage = 0;
+ this->_M_impl._M_start = iterator();
+ this->_M_impl._M_finish = iterator();
+ this->_M_impl._M_end_of_storage = 0;
for ( ; __first != __last; ++__first)
push_back(*__first);
}
{
const size_type __n = std::distance(__first, __last);
_M_initialize(__n);
- std::copy(__first, __last, this->_M_start);
+ std::copy(__first, __last, this->_M_impl._M_start);
}
template<class _InputIterator>
- void _M_insert_range(iterator __pos,
- _InputIterator __first, _InputIterator __last,
- input_iterator_tag)
+ void _M_insert_range(iterator __pos, _InputIterator __first,
+ _InputIterator __last, input_iterator_tag)
{
for ( ; __first != __last; ++__first)
{
}
template<class _ForwardIterator>
- void _M_insert_range(iterator __position,
- _ForwardIterator __first, _ForwardIterator __last,
- forward_iterator_tag)
+ void _M_insert_range(iterator __position, _ForwardIterator __first,
+ _ForwardIterator __last, forward_iterator_tag)
{
if (__first != __last)
{
if (capacity() - size() >= __n)
{
std::copy_backward(__position, end(),
- this->_M_finish + difference_type(__n));
+ this->_M_impl._M_finish + difference_type(__n));
std::copy(__first, __last, __position);
- this->_M_finish += difference_type(__n);
+ this->_M_impl._M_finish += difference_type(__n);
}
else
{
const size_type __len = size() + std::max(size(), __n);
- _Bit_type * __q = this->_M_bit_alloc(__len);
+ _Bit_type * __q = this->_M_allocate(__len);
iterator __i = std::copy(begin(), __position, iterator(__q, 0));
__i = std::copy(__first, __last, __i);
- this->_M_finish = std::copy(__position, end(), __i);
+ this->_M_impl._M_finish = std::copy(__position, end(), __i);
this->_M_deallocate();
- this->_M_end_of_storage = __q + (__len + _S_word_bit - 1)
- / _S_word_bit;
- this->_M_start = iterator(__q, 0);
+ this->_M_impl._M_end_of_storage = __q + (__len + _S_word_bit - 1)
+ / _S_word_bit;
+ this->_M_impl._M_start = iterator(__q, 0);
}
}
}
public:
iterator begin()
- { return this->_M_start; }
+ { return this->_M_impl._M_start; }
const_iterator begin() const
- { return this->_M_start; }
+ { return this->_M_impl._M_start; }
iterator end()
- { return this->_M_finish; }
+ { return this->_M_impl._M_finish; }
const_iterator end() const
- { return this->_M_finish; }
+ { return this->_M_impl._M_finish; }
reverse_iterator rbegin()
{ return reverse_iterator(end()); }
{ return size_type(-1); }
size_type capacity() const
- { return size_type(const_iterator(this->_M_end_of_storage, 0)
+ { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
- begin()); }
bool empty() const
{ return begin() == end(); }
explicit vector(const allocator_type& __a = allocator_type())
: _Bvector_base<_Alloc>(__a) { }
- vector(size_type __n, bool __value,
+ vector(size_type __n, bool __value,
const allocator_type& __a = allocator_type())
- : _Bvector_base<_Alloc>(__a)
+ : _Bvector_base<_Alloc>(__a)
{
_M_initialize(__n);
- std::fill(this->_M_start._M_p, this->_M_end_of_storage, __value ? ~0 : 0);
+ std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
+ __value ? ~0 : 0);
}
explicit vector(size_type __n)
- : _Bvector_base<_Alloc>(allocator_type())
+ : _Bvector_base<_Alloc>(allocator_type())
{
_M_initialize(__n);
- std::fill(this->_M_start._M_p, this->_M_end_of_storage, 0);
+ std::fill(this->_M_impl._M_start._M_p,
+ this->_M_impl._M_end_of_storage, 0);
}
vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator())
{
_M_initialize(__x.size());
- std::copy(__x.begin(), __x.end(), this->_M_start);
+ std::copy(__x.begin(), __x.end(), this->_M_impl._M_start);
}
// Check whether it's an integral type. If so, it's not an iterator.
-
template<class _Integer>
void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
{
_M_initialize(__n);
- std::fill(this->_M_start._M_p, this->_M_end_of_storage, __x ? ~0 : 0);
+ std::fill(this->_M_impl._M_start._M_p,
+ this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
}
template<class _InputIterator>
- void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
- __false_type)
- { _M_initialize_range(__first, __last, std::__iterator_category(__first)); }
+ void
+ _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+ __false_type)
+ { _M_initialize_range(__first, __last,
+ std::__iterator_category(__first)); }
template<class _InputIterator>
- vector(_InputIterator __first, _InputIterator __last,
- const allocator_type& __a = allocator_type())
- : _Bvector_base<_Alloc>(__a)
+ vector(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a = allocator_type())
+ : _Bvector_base<_Alloc>(__a)
{
typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
_M_initialize_dispatch(__first, __last, _Integral());
_M_initialize(__x.size());
}
std::copy(__x.begin(), __x.end(), begin());
- this->_M_finish = begin() + difference_type(__x.size());
+ this->_M_impl._M_finish = begin() + difference_type(__x.size());
return *this;
}
{
if (__n > size())
{
- std::fill(this->_M_start._M_p, this->_M_end_of_storage, __x ? ~0 : 0);
+ std::fill(this->_M_impl._M_start._M_p,
+ this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
insert(end(), __n - size(), __x);
}
else
{
erase(begin() + __n, end());
- std::fill(this->_M_start._M_p, this->_M_end_of_storage, __x ? ~0 : 0);
+ std::fill(this->_M_impl._M_start._M_p,
+ this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
}
}
__throw_length_error(__N("vector::reserve"));
if (this->capacity() < __n)
{
- _Bit_type* __q = this->_M_bit_alloc(__n);
- this->_M_finish = std::copy(begin(), end(), iterator(__q, 0));
+ _Bit_type* __q = this->_M_allocate(__n);
+ this->_M_impl._M_finish = std::copy(begin(), end(),
+ iterator(__q, 0));
this->_M_deallocate();
- this->_M_start = iterator(__q, 0);
- this->_M_end_of_storage = __q + (__n + _S_word_bit - 1) / _S_word_bit;
+ this->_M_impl._M_start = iterator(__q, 0);
+ this->_M_impl._M_end_of_storage = __q + (__n + _S_word_bit - 1) / _S_word_bit;
}
}
void push_back(bool __x)
{
- if (this->_M_finish._M_p != this->_M_end_of_storage)
- *this->_M_finish++ = __x;
+ if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
+ *this->_M_impl._M_finish++ = __x;
else
_M_insert_aux(end(), __x);
}
void swap(vector<bool, _Alloc>& __x)
{
- std::swap(this->_M_start, __x._M_start);
- std::swap(this->_M_finish, __x._M_finish);
- std::swap(this->_M_end_of_storage, __x._M_end_of_storage);
+ std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+ std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+ std::swap(this->_M_impl._M_end_of_storage,
+ __x._M_impl._M_end_of_storage);
}
// [23.2.5]/1, third-to-last entry in synopsis listing
iterator insert(iterator __position, bool __x = bool())
{
const difference_type __n = __position - begin();
- if (this->_M_finish._M_p != this->_M_end_of_storage
+ if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
&& __position == end())
- *this->_M_finish++ = __x;
+ *this->_M_impl._M_finish++ = __x;
else
_M_insert_aux(__position, __x);
return begin() + __n;
if (capacity() - size() >= __n)
{
std::copy_backward(__position, end(),
- this->_M_finish + difference_type(__n));
+ this->_M_impl._M_finish + difference_type(__n));
std::fill(__position, __position + difference_type(__n), __x);
- this->_M_finish += difference_type(__n);
+ this->_M_impl._M_finish += difference_type(__n);
}
else
{
const size_type __len = size() + std::max(size(), __n);
- _Bit_type * __q = this->_M_bit_alloc(__len);
+ _Bit_type * __q = this->_M_allocate(__len);
iterator __i = std::copy(begin(), __position, iterator(__q, 0));
std::fill_n(__i, __n, __x);
- this->_M_finish = std::copy(__position, end(),
- __i + difference_type(__n));
+ this->_M_impl._M_finish = std::copy(__position, end(),
+ __i + difference_type(__n));
this->_M_deallocate();
- this->_M_end_of_storage = __q + (__len + _S_word_bit - 1)
- / _S_word_bit;
- this->_M_start = iterator(__q, 0);
+ this->_M_impl._M_end_of_storage = __q + (__len + _S_word_bit - 1)
+ / _S_word_bit;
+ this->_M_impl._M_start = iterator(__q, 0);
}
}
{ _M_fill_insert(__position, __n, __x); }
void pop_back()
- { --this->_M_finish; }
+ { --this->_M_impl._M_finish; }
iterator erase(iterator __position)
{
if (__position + 1 != end())
std::copy(__position + 1, end(), __position);
- --this->_M_finish;
+ --this->_M_impl._M_finish;
return __position;
}
iterator erase(iterator __first, iterator __last)
{
- this->_M_finish = std::copy(__last, end(), __first);
+ this->_M_impl._M_finish = std::copy(__last, end(), __first);
return __first;
}
void flip()
{
- for (_Bit_type * __p = this->_M_start._M_p;
- __p != this->_M_end_of_storage; ++__p)
+ for (_Bit_type * __p = this->_M_impl._M_start._M_p;
+ __p != this->_M_impl._M_end_of_storage; ++__p)
*__p = ~*__p;
}
void clear()
{ erase(begin(), end()); }
};
-} // namespace __gnu_norm
+} // namespace std
#endif
#include <bits/stl_iterator_base_types.h>
#include <bits/stl_iterator_base_funcs.h>
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
/**
* @if maint
inline void
swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
{ __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
#endif /* _DEQUE_H */
#include <bits/concept_check.h>
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
// Supporting structures are split into common and templated types; the
// latter publicly inherits from the former in an effort to reduce code
inline void
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
{ __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
#endif /* _LIST_H */
#include <bits/concept_check.h>
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
/**
* @brief A standard container made up of (key,value) pairs, which can be
inline void
swap(map<_Key,_Tp,_Compare,_Alloc>& __x, map<_Key,_Tp,_Compare,_Alloc>& __y)
{ __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
#endif /* _MAP_H */
#include <bits/concept_check.h>
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
// Forward declaration of operators < and ==, needed for friend declaration.
swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x,
multimap<_Key,_Tp,_Compare,_Alloc>& __y)
{ __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
#endif /* _MULTIMAP_H */
#include <bits/concept_check.h>
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
// Forward declaration of operators < and ==, needed for friend declaration.
multiset<_Key,_Compare,_Alloc>& __y)
{ __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
#endif /* _MULTISET_H */
#include <bits/concept_check.h>
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
// Forward declarations of operators < and ==, needed for friend declaration.
template<class _Key, class _Compare = less<_Key>,
swap(set<_Key,_Compare,_Alloc>& __x, set<_Key,_Compare,_Alloc>& __y)
{ __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
#endif /* _SET_H */
#include <bits/functexcept.h>
#include <bits/concept_check.h>
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
/**
* @if maint
inline void
swap(vector<_Tp,_Alloc>& __x, vector<_Tp,_Alloc>& __y)
{ __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
#endif /* _VECTOR_H */
#ifndef _VECTOR_TCC
#define _VECTOR_TCC 1
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
template<typename _Tp, typename _Alloc>
void
}
}
}
-} // namespace __gnu_norm
+} // namespace std
#endif /* _VECTOR_TCC */
// Debugging bitset implementation -*- C++ -*-
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
{
template<size_t _Nb>
class bitset
- : public __gnu_norm::bitset<_Nb>, public __gnu_debug::_Safe_sequence_base
+ : public _GLIBCXX_STD::bitset<_Nb>,
+ public __gnu_debug::_Safe_sequence_base
{
- typedef __gnu_norm::bitset<_Nb> _Base;
+ typedef _GLIBCXX_STD::bitset<_Nb> _Base;
typedef __gnu_debug::_Safe_sequence_base _Safe_base;
public:
// Debugging deque implementation -*- C++ -*-
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
{
template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
class deque
- : public __gnu_norm::deque<_Tp, _Allocator>,
- public __gnu_debug::_Safe_sequence<deque<_Tp, _Allocator> >
+ : public _GLIBCXX_STD::deque<_Tp, _Allocator>,
+ public __gnu_debug::_Safe_sequence<deque<_Tp, _Allocator> >
{
- typedef __gnu_norm::deque<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD::deque<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<deque> _Safe_base;
public:
// Debug-mode error formatting implementation -*- C++ -*-
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
namespace __gnu_debug
{
- using namespace std;
+ using std::type_info;
/** Determine if the two types are the same. */
template<typename _Type1, typename _Type2>
// Debugging list implementation -*- C++ -*-
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
{
template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
class list
- : public __gnu_norm::list<_Tp, _Allocator>,
+ : public _GLIBCXX_STD::list<_Tp, _Allocator>,
public __gnu_debug::_Safe_sequence<list<_Tp, _Allocator> >
{
- typedef __gnu_norm::list<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD::list<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<list> _Safe_base;
public:
template<class _InputIterator>
list(_InputIterator __first, _InputIterator __last,
const _Allocator& __a = _Allocator())
- : _Base(__gnu_debug::__check_valid_range(__first, __last), __last, __a)
+ : _Base(__gnu_debug::__check_valid_range(__first, __last), __last, __a)
{ }
// Debugging map implementation -*- C++ -*-
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class map
- : public __gnu_norm::map<_Key, _Tp, _Compare, _Allocator>,
+ : public _GLIBCXX_STD::map<_Key, _Tp, _Compare, _Allocator>,
public __gnu_debug::_Safe_sequence<map<_Key, _Tp, _Compare, _Allocator> >
{
- typedef __gnu_norm::map<_Key, _Tp, _Compare, _Allocator> _Base;
+ typedef _GLIBCXX_STD::map<_Key, _Tp, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<map> _Safe_base;
public:
// Debugging multimap implementation -*- C++ -*-
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class multimap
- : public __gnu_norm::multimap<_Key, _Tp, _Compare, _Allocator>,
+ : public _GLIBCXX_STD::multimap<_Key, _Tp, _Compare, _Allocator>,
public __gnu_debug::_Safe_sequence<multimap<_Key,_Tp,_Compare,_Allocator> >
{
- typedef __gnu_norm::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
+ typedef _GLIBCXX_STD::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<multimap> _Safe_base;
public:
// Debugging multiset implementation -*- C++ -*-
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class multiset
- : public __gnu_norm::multiset<_Key, _Compare, _Allocator>,
+ : public _GLIBCXX_STD::multiset<_Key, _Compare, _Allocator>,
public __gnu_debug::_Safe_sequence<multiset<_Key, _Compare, _Allocator> >
{
- typedef __gnu_norm::multiset<_Key, _Compare, _Allocator> _Base;
+ typedef _GLIBCXX_STD::multiset<_Key, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<multiset> _Safe_base;
public:
// Safe iterator implementation -*- C++ -*-
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
namespace __gnu_debug
{
+ using std::iterator_traits;
+ using std::pair;
+
/** Iterators that derive from _Safe_iterator_base but that aren't
* _Safe_iterators can be determined singular or non-singular via
* _Safe_iterator_base.
// Debugging set implementation -*- C++ -*-
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class set
- : public __gnu_norm::set<_Key,_Compare,_Allocator>,
+ : public _GLIBCXX_STD::set<_Key,_Compare,_Allocator>,
public __gnu_debug::_Safe_sequence<set<_Key, _Compare, _Allocator> >
{
- typedef __gnu_norm::set<_Key,_Compare,_Allocator> _Base;
+ typedef _GLIBCXX_STD::set<_Key,_Compare,_Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<set> _Safe_base;
public:
// Debugging vector implementation -*- C++ -*-
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
template<typename _Tp,
typename _Allocator = std::allocator<_Tp> >
class vector
- : public __gnu_norm::vector<_Tp, _Allocator>,
+ : public _GLIBCXX_STD::vector<_Tp, _Allocator>,
public __gnu_debug::_Safe_sequence<vector<_Tp, _Allocator> >
{
- typedef __gnu_norm::vector<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD::vector<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<vector> _Safe_base;
typedef typename _Base::const_iterator _Base_const_iterator;
#include <ostream> // For ostream (operator<<)
#include <istream> // For istream (operator>>)
-
#define _GLIBCXX_BITSET_BITS_PER_WORD numeric_limits<unsigned long>::digits
#define _GLIBCXX_BITSET_WORDS(__n) \
((__n) < 1 ? 0 : ((__n) + _GLIBCXX_BITSET_BITS_PER_WORD - 1)/_GLIBCXX_BITSET_BITS_PER_WORD)
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
/**
* @if maint
return __os << __tmp;
}
//@}
-} // namespace __gnu_norm
+} // namespace std
#undef _GLIBCXX_BITSET_WORDS
#undef _GLIBCXX_BITSET_BITS_PER_WORD
complex_io.cc \
ctype.cc \
debug.cc \
+ debug_list.cc \
functexcept.cc \
globals_locale.cc \
globals_io.cc \
numeric_members.lo time_members.lo
am__objects_2 = basic_file.lo c++locale.lo
am__objects_3 = allocator.lo codecvt.lo complex_io.lo ctype.lo \
- debug.lo functexcept.lo globals_locale.lo globals_io.lo ios.lo \
- ios_failure.lo ios_init.lo ios_locale.lo limits.lo list.lo \
- locale.lo locale_init.lo locale_facets.lo localename.lo \
- stdexcept.lo strstream.lo tree.lo allocator-inst.lo \
- concept-inst.lo fstream-inst.lo ext-inst.lo io-inst.lo \
- istream-inst.lo locale-inst.lo locale-misc-inst.lo \
+ debug.lo debug_list.lo functexcept.lo globals_locale.lo \
+ globals_io.lo ios.lo ios_failure.lo ios_init.lo ios_locale.lo \
+ limits.lo list.lo locale.lo locale_init.lo locale_facets.lo \
+ localename.lo stdexcept.lo strstream.lo tree.lo \
+ allocator-inst.lo concept-inst.lo fstream-inst.lo ext-inst.lo \
+ io-inst.lo istream-inst.lo locale-inst.lo locale-misc-inst.lo \
misc-inst.lo ostream-inst.lo sstream-inst.lo streambuf-inst.lo \
string-inst.lo valarray-inst.lo wlocale-inst.lo \
wstring-inst.lo $(am__objects_1) $(am__objects_2)
complex_io.cc \
ctype.cc \
debug.cc \
+ debug_list.cc \
functexcept.cc \
globals_locale.cc \
globals_io.cc \
--- /dev/null
+// Debugging mode support code for list -*- C++ -*-
+
+// Copyright (C) 2004 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// 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.
+
+#define _GLIBCXX_DEBUG
+
+#include <bits/c++config.h>
+
+#include "list.cc"
#include <list>
-namespace __gnu_norm
+namespace _GLIBCXX_STD
{
void
_List_node_base::swap(_List_node_base& __x, _List_node_base& __y)
}
void
- _List_node_base::hook(_List_node_base * const __position)
+ _List_node_base::hook(_List_node_base* const __position)
{
this->_M_next = __position;
this->_M_prev = __position->_M_prev;
__prev_node->_M_next = __next_node;
__next_node->_M_prev = __prev_node;
}
-} // namespace __gnu_norm
+} // namespace std
--- /dev/null
+// Copyright (C) 2004 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#include <vector>
+#include <ext/new_allocator.h>
+
+using namespace std;
+using __gnu_cxx::new_allocator;
+
+template<typename T>
+ class clear_alloc : public new_allocator<T>
+ {
+ public:
+
+ template <typename T1>
+ struct rebind
+ { typedef clear_alloc<T1> other; };
+
+ virtual void clear() throw()
+ { }
+
+ clear_alloc() throw()
+ { }
+
+ clear_alloc(clear_alloc const& _wa) throw()
+ { }
+
+ template<typename T1>
+ clear_alloc(clear_alloc<T1> const& _wa) throw()
+ { }
+
+ virtual ~clear_alloc() throw()
+ { this->clear(); }
+
+ T* allocate(typename new_allocator<T>::size_type n, const void *hint = 0)
+ {
+ this->clear();
+ return new_allocator<T>::allocate(n, hint);
+ }
+
+ void deallocate(T *ptr, typename new_allocator<T>::size_type n)
+ {
+ this->clear();
+ new_allocator<T>::deallocate(ptr, n);
+ }
+ };
+
+template<typename Container>
+ void Check_Container()
+ {
+ Container* pic = new Container;
+ int x = 230;
+
+ while (x--)
+ {
+ pic->push_back(x);
+ }
+
+ pic->get_allocator();
+
+ // The following has led to infinite recursions or cores.
+ pic->clear();
+
+ delete pic;
+ }
+
+
+int main()
+{
+ Check_Container<std::vector<bool, clear_alloc<bool> > >();
+ return 0;
+}
+
projects / thirdparty / gcc.git / commitdiff
