mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-03-12 11:17:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

c++config (_GLIBCXX_STD): New.

Browse Source 
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.

From-SVN: r80763
This commit is contained in:
Benjamin Kosnik 2004-04-16 19:04:07 +00:00 committed by Benjamin Kosnik
parent 31e632d3e4
commit 390e4c0dbe
31 changed files with 362 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,41 @@
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

2
libstdc++-v3/Makefile.in
View File

@ -44,7 +44,7 @@ DIST_COMMON = README $(am__configure_deps) $(srcdir)/../config.guess \
$(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 \

13
libstdc++-v3/config/linker-map.gnu
View File

@ -55,6 +55,11 @@ GLIBCXX_3.4 {
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*;
@ -66,10 +71,14 @@ GLIBCXX_3.4 {
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.

27
libstdc++-v3/include/bits/c++config
View File

@ -1,6 +1,6 @@
// 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
@ -51,27 +51,30 @@
# 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));
#endif
}
#else
# define _GLIBCXX_STD std
#endif
// The remainder of the prewritten config is automatic; all the
// user hooks are listed above.

4
libstdc++-v3/include/bits/deque.tcc
View File

@ -61,7 +61,7 @@
#ifndef _DEQUE_TCC
#define _DEQUE_TCC 1
namespace __gnu_norm
namespace _GLIBCXX_STD
{
template <typename _Tp, typename _Alloc>
deque<_Tp,_Alloc>&
@ -714,6 +714,6 @@ namespace __gnu_norm
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

4
libstdc++-v3/include/bits/list.tcc
View File

@ -61,7 +61,7 @@
#ifndef _LIST_TCC
#define _LIST_TCC 1
namespace __gnu_norm
namespace _GLIBCXX_STD
{
template<typename _Tp, typename _Alloc>
void
@ -371,7 +371,7 @@ namespace __gnu_norm
swap( *(__fill-1) );
}
}
} // namespace __gnu_norm
} // namespace std
#endif /* _LIST_TCC */

207
libstdc++-v3/include/bits/stl_bvector.h
View File

@ -1,4 +1,4 @@
// bit_vector and vector<bool> specialization -*- C++ -*-
// vector<bool> specialization -*- C++ -*-
// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
//
@ -61,7 +61,7 @@
#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)) };
@ -322,7 +322,8 @@ namespace __gnu_norm
return *this;
}
const_iterator operator+(difference_type __i) const {
const_iterator
operator+(difference_type __i) const {
const_iterator __tmp = *this;
return __tmp += __i;
}
@ -345,47 +346,52 @@ namespace __gnu_norm
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
@ -429,41 +435,40 @@ template<typename _Alloc>
{ 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);
}
}
@ -471,9 +476,9 @@ template<typename _Alloc>
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);
}
@ -484,13 +489,12 @@ template<typename _Alloc>
{
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)
{
@ -500,9 +504,8 @@ template<typename _Alloc>
}
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)
{
@ -510,37 +513,37 @@ template<typename _Alloc>
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()); }
@ -561,7 +564,7 @@ template<typename _Alloc>
{ 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(); }
@ -587,45 +590,49 @@ template<typename _Alloc>
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());
@ -643,7 +650,7 @@ template<typename _Alloc>
_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;
}
@ -656,13 +663,15 @@ template<typename _Alloc>
{
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);
}
}
@ -720,11 +729,12 @@ template<typename _Alloc>
__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;
}
}
@ -742,17 +752,18 @@ template<typename _Alloc>
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
@ -766,9 +777,9 @@ template<typename _Alloc>
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;
@ -803,22 +814,22 @@ template<typename _Alloc>
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);
}
}
@ -826,19 +837,19 @@ template<typename _Alloc>
{ _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;
}
@ -852,14 +863,14 @@ template<typename _Alloc>
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

4
libstdc++-v3/include/bits/stl_deque.h
View File

@ -65,7 +65,7 @@
#include <bits/stl_iterator_base_types.h>
#include <bits/stl_iterator_base_funcs.h>
namespace __gnu_norm
namespace _GLIBCXX_STD
{
/**
* @if maint
@ -1496,6 +1496,6 @@ namespace __gnu_norm
inline void
swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
{ __x.swap(__y); }
} // namespace __gnu_norm
} // namespace std
#endif /* _DEQUE_H */

4
libstdc++-v3/include/bits/stl_list.h
View File

@ -63,7 +63,7 @@
#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
@ -1247,7 +1247,7 @@ namespace __gnu_norm
inline void
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
{ __x.swap(__y); }
} // namespace __gnu_norm
} // namespace std
#endif /* _LIST_H */

4
libstdc++-v3/include/bits/stl_map.h
View File

@ -63,7 +63,7 @@
#include <bits/concept_check.h>
namespace __gnu_norm
namespace _GLIBCXX_STD
{
/**
* @brief A standard container made up of (key,value) pairs, which can be
@ -689,6 +689,6 @@ namespace __gnu_norm
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 */

4
libstdc++-v3/include/bits/stl_multimap.h
View File

@ -63,7 +63,7 @@
#include <bits/concept_check.h>
namespace __gnu_norm
namespace _GLIBCXX_STD
{
// Forward declaration of operators < and ==, needed for friend declaration.
@ -673,6 +673,6 @@ namespace __gnu_norm
swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x,
multimap<_Key,_Tp,_Compare,_Alloc>& __y)
{ __x.swap(__y); }
} // namespace __gnu_norm
} // namespace std
#endif /* _MULTIMAP_H */

4
libstdc++-v3/include/bits/stl_multiset.h
View File

@ -63,7 +63,7 @@
#include <bits/concept_check.h>
namespace __gnu_norm
namespace _GLIBCXX_STD
{
// Forward declaration of operators < and ==, needed for friend declaration.
@ -580,6 +580,6 @@ namespace __gnu_norm
multiset<_Key,_Compare,_Alloc>& __y)
{ __x.swap(__y); }
} // namespace __gnu_norm
} // namespace std
#endif /* _MULTISET_H */

4
libstdc++-v3/include/bits/stl_set.h
View File

@ -63,7 +63,7 @@
#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>,
@ -588,6 +588,6 @@ namespace __gnu_norm
swap(set<_Key,_Compare,_Alloc>& __x, set<_Key,_Compare,_Alloc>& __y)
{ __x.swap(__y); }
} // namespace __gnu_norm
} // namespace std
#endif /* _SET_H */

4
libstdc++-v3/include/bits/stl_vector.h
View File

@ -65,7 +65,7 @@
#include <bits/functexcept.h>
#include <bits/concept_check.h>
namespace __gnu_norm
namespace _GLIBCXX_STD
{
/**
* @if maint
@ -927,6 +927,6 @@ namespace __gnu_norm
inline void
swap(vector<_Tp,_Alloc>& __x, vector<_Tp,_Alloc>& __y)
{ __x.swap(__y); }
} // namespace __gnu_norm
} // namespace std
#endif /* _VECTOR_H */

4
libstdc++-v3/include/bits/vector.tcc
View File

@ -61,7 +61,7 @@
#ifndef _VECTOR_TCC
#define _VECTOR_TCC 1
namespace __gnu_norm
namespace _GLIBCXX_STD
{
template<typename _Tp, typename _Alloc>
void
@ -409,6 +409,6 @@ namespace __gnu_norm
}
}
}
} // namespace __gnu_norm
} // namespace std
#endif /* _VECTOR_TCC */

7
libstdc++-v3/include/debug/bitset
View File

@ -1,6 +1,6 @@
// 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
@ -39,9 +39,10 @@ namespace __gnu_debug_def
{
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:

8
libstdc++-v3/include/debug/deque
View File

@ -1,6 +1,6 @@
// 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
@ -39,10 +39,10 @@ namespace __gnu_debug_def
{
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:

4
libstdc++-v3/include/debug/formatter.h
View File

@ -1,6 +1,6 @@
// 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
@ -36,7 +36,7 @@
namespace __gnu_debug
{
using namespace std;
using std::type_info;
/** Determine if the two types are the same. */
template<typename _Type1, typename _Type2>

8
libstdc++-v3/include/debug/list
View File

@ -1,6 +1,6 @@
// 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
@ -40,10 +40,10 @@ namespace __gnu_debug_def
{
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:
@ -76,7 +76,7 @@ namespace __gnu_debug_def
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)
{ }

6
libstdc++-v3/include/debug/map.h
View File

@ -1,6 +1,6 @@
// 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
@ -40,10 +40,10 @@ namespace __gnu_debug_def
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:

6
libstdc++-v3/include/debug/multimap.h
View File

@ -1,6 +1,6 @@
// 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
@ -40,10 +40,10 @@ namespace __gnu_debug_def
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:

6
libstdc++-v3/include/debug/multiset.h
View File

@ -1,6 +1,6 @@
// 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
@ -40,10 +40,10 @@ namespace __gnu_debug_def
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:

5
libstdc++-v3/include/debug/safe_iterator.h
View File

@ -1,6 +1,6 @@
// 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
@ -38,6 +38,9 @@
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.

6
libstdc++-v3/include/debug/set.h
View File

@ -1,6 +1,6 @@
// 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
@ -40,10 +40,10 @@ namespace __gnu_debug_def
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:

6
libstdc++-v3/include/debug/vector
View File

@ -1,6 +1,6 @@
// 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
@ -41,10 +41,10 @@ namespace __gnu_debug_def
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;

5
libstdc++-v3/include/std/std_bitset.h
View File

@ -59,12 +59,11 @@
#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
@ -1218,7 +1217,7 @@ namespace __gnu_norm
return __os << __tmp;
}
//@}
} // namespace __gnu_norm
} // namespace std
#undef _GLIBCXX_BITSET_WORDS
#undef _GLIBCXX_BITSET_BITS_PER_WORD

1
libstdc++-v3/src/Makefile.am
View File

@ -101,6 +101,7 @@ sources = \
complex_io.cc \
ctype.cc \
debug.cc \
debug_list.cc \
functexcept.cc \
globals_locale.cc \
globals_io.cc \

13
libstdc++-v3/src/Makefile.in
View File

@ -59,12 +59,12 @@ am__objects_1 = atomicity.lo codecvt_members.lo collate_members.lo \
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)
@ -299,6 +299,7 @@ sources = \
complex_io.cc \
ctype.cc \
debug.cc \
debug_list.cc \
functexcept.cc \
globals_locale.cc \
globals_io.cc \

34
libstdc++-v3/src/debug_list.cc Normal file
View File

@ -0,0 +1,34 @@
// 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"

6
libstdc++-v3/src/list.cc
View File

@ -55,7 +55,7 @@
#include <list>
namespace __gnu_norm
namespace _GLIBCXX_STD
{
void
_List_node_base::swap(_List_node_base& __x, _List_node_base& __y)
@ -121,7 +121,7 @@ namespace __gnu_norm
}
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;
@ -137,5 +137,5 @@ namespace __gnu_norm
__prev_node->_M_next = __next_node;
__next_node->_M_prev = __prev_node;
}
} // namespace __gnu_norm
} // namespace std

88
libstdc++-v3/testsuite/23_containers/vector/bool/clear_allocator.cc Normal file
View File

@ -0,0 +1,88 @@
// 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;
}