re PR libstdc++/58338 (Add noexcept to functions with a narrow contract)

2013-09-25  Marc Glisse  <marc.glisse@inria.fr>

	PR libstdc++/58338
	* include/bits/forward_list.h (_Fwd_list_node_base::_M_transfer_after):
	Mark as noexcept.
	(_Fwd_list_iterator) [_Fwd_list_iterator, operator*, operator->,
	operator++, operator==, operator!=, _M_next]: Likewise.
	(_Fwd_list_const_iterator) [_Fwd_list_const_iterator, operator*,
	operator->, operator++, operator==, operator!=, _M_next]: Likewise.
	(operator==(const _Fwd_list_iterator&, const _Fwd_list_const_iterator&),
	operator!=(const _Fwd_list_iterator&, const _Fwd_list_const_iterator&)):
	Likewise.
	* include/bits/hashtable_policy.h (_Hash_node_base::_Hash_node_base,
	_Hash_node::_M_next, _Node_iterator_base::_Node_iterator_base,
	_Node_iterator_base::_M_incr, operator==(const _Node_iterator_base&,
	const _Node_iterator_base&), operator!=(const _Node_iterator_base&,
	const _Node_iterator_base&)): Likewise.
	(_Node_iterator) [_Node_iterator, operator*, operator->, operator++]:
	Likewise.
	(_Node_const_iterator) [_Node_const_iterator, operator*, operator->,
	operator++]: Likewise.
	* include/debug/safe_iterator.h (_Safe_iterator) [_Safe_iterator,
	operator=, operator*, operator->, operator++, operator--, operator[],
	operator+=, operator+, operator-=, operator-, base, operator _Iterator]:
	Likewise.
	(operator==(const _Safe_iterator&, const _Safe_iterator&),
	operator!=(const _Safe_iterator&, const _Safe_iterator&),
	operator<(const _Safe_iterator&, const _Safe_iterator&),
	operator<=(const _Safe_iterator&, const _Safe_iterator&),
	operator>(const _Safe_iterator&, const _Safe_iterator&),
	operator>=(const _Safe_iterator&, const _Safe_iterator&),
	operator-(const _Safe_iterator&, const _Safe_iterator&),
	operator+(difference_type, const _Safe_iterator&)): Likewise.
	* include/profile/iterator_tracker.h (__iterator_tracker)
	[__iterator_tracker, base, operator _Iterator, operator->, operator++,
	operator--, operator=, operator*, operator[], operator+=, operator+,
	operator-=, operator-]: Likewise.
	(operator==(const __iterator_tracker&, const __iterator_tracker&),
	operator!=(const __iterator_tracker&, const __iterator_tracker&),
	operator<(const __iterator_tracker&, const __iterator_tracker&),
	operator<=(const __iterator_tracker&, const __iterator_tracker&),
	operator>(const __iterator_tracker&, const __iterator_tracker&),
	operator>=(const __iterator_tracker&, const __iterator_tracker&),
	operator-(const __iterator_tracker&, const __iterator_tracker&),
	operator+(difference_type, const __iterator_tracker&)): Likewise.

From-SVN: r202924

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 2cff0aba190fb88bb9323853f0248b7eff2f1ff2..ae914b969aa81b890fdc83222bb710aadd2894c0 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,49 @@
+2013-09-25  Marc Glisse  <marc.glisse@inria.fr>
+
+       PR libstdc++/58338
+       * include/bits/forward_list.h (_Fwd_list_node_base::_M_transfer_after):
+       Mark as noexcept.
+       (_Fwd_list_iterator) [_Fwd_list_iterator, operator*, operator->,
+       operator++, operator==, operator!=, _M_next]: Likewise.
+       (_Fwd_list_const_iterator) [_Fwd_list_const_iterator, operator*,
+       operator->, operator++, operator==, operator!=, _M_next]: Likewise.
+       (operator==(const _Fwd_list_iterator&, const _Fwd_list_const_iterator&),
+       operator!=(const _Fwd_list_iterator&, const _Fwd_list_const_iterator&)):
+       Likewise.
+       * include/bits/hashtable_policy.h (_Hash_node_base::_Hash_node_base,
+       _Hash_node::_M_next, _Node_iterator_base::_Node_iterator_base,
+       _Node_iterator_base::_M_incr, operator==(const _Node_iterator_base&,
+       const _Node_iterator_base&), operator!=(const _Node_iterator_base&,
+       const _Node_iterator_base&)): Likewise.
+       (_Node_iterator) [_Node_iterator, operator*, operator->, operator++]:
+       Likewise.
+       (_Node_const_iterator) [_Node_const_iterator, operator*, operator->,
+       operator++]: Likewise.
+       * include/debug/safe_iterator.h (_Safe_iterator) [_Safe_iterator,
+       operator=, operator*, operator->, operator++, operator--, operator[],
+       operator+=, operator+, operator-=, operator-, base, operator _Iterator]:
+       Likewise.
+       (operator==(const _Safe_iterator&, const _Safe_iterator&),
+       operator!=(const _Safe_iterator&, const _Safe_iterator&),
+       operator<(const _Safe_iterator&, const _Safe_iterator&),
+       operator<=(const _Safe_iterator&, const _Safe_iterator&),
+       operator>(const _Safe_iterator&, const _Safe_iterator&),
+       operator>=(const _Safe_iterator&, const _Safe_iterator&),
+       operator-(const _Safe_iterator&, const _Safe_iterator&),
+       operator+(difference_type, const _Safe_iterator&)): Likewise.
+       * include/profile/iterator_tracker.h (__iterator_tracker)
+       [__iterator_tracker, base, operator _Iterator, operator->, operator++,
+       operator--, operator=, operator*, operator[], operator+=, operator+,
+       operator-=, operator-]: Likewise.
+       (operator==(const __iterator_tracker&, const __iterator_tracker&),
+       operator!=(const __iterator_tracker&, const __iterator_tracker&),
+       operator<(const __iterator_tracker&, const __iterator_tracker&),
+       operator<=(const __iterator_tracker&, const __iterator_tracker&),
+       operator>(const __iterator_tracker&, const __iterator_tracker&),
+       operator>=(const __iterator_tracker&, const __iterator_tracker&),
+       operator-(const __iterator_tracker&, const __iterator_tracker&),
+       operator+(difference_type, const __iterator_tracker&)): Likewise.
+
 2013-09-24  Marc Glisse  <marc.glisse@inria.fr>
 
        PR libstdc++/58338

diff --git a/libstdc++-v3/include/bits/forward_list.h b/libstdc++-v3/include/bits/forward_list.h
index c3cee971399ae34fdece64cbfd1ae253bd17cdfe..9ac9d22523b8fde95663bcd3b83e03ddb60145f9 100644 (file)
--- a/libstdc++-v3/include/bits/forward_list.h
+++ b/libstdc++-v3/include/bits/forward_list.h
@@ -58,7 +58,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 
     _Fwd_list_node_base*
     _M_transfer_after(_Fwd_list_node_base* __begin,
-                     _Fwd_list_node_base* __end)
+                     _Fwd_list_node_base* __end) noexcept
     {
       _Fwd_list_node_base* __keep = __begin->_M_next;
       if (__end)
@@ -128,30 +128,30 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       typedef ptrdiff_t                          difference_type;
       typedef std::forward_iterator_tag          iterator_category;
 
-      _Fwd_list_iterator()
+      _Fwd_list_iterator() noexcept
       : _M_node() { }
 
       explicit
-      _Fwd_list_iterator(_Fwd_list_node_base* __n) 
+      _Fwd_list_iterator(_Fwd_list_node_base* __n) noexcept
       : _M_node(__n) { }
 
       reference
-      operator*() const
+      operator*() const noexcept
       { return *static_cast<_Node*>(this->_M_node)->_M_valptr(); }
 
       pointer
-      operator->() const
+      operator->() const noexcept
       { return static_cast<_Node*>(this->_M_node)->_M_valptr(); }
 
       _Self&
-      operator++()
+      operator++() noexcept
       {
         _M_node = _M_node->_M_next;
         return *this;
       }
 
       _Self
-      operator++(int)
+      operator++(int) noexcept
       {
         _Self __tmp(*this);
         _M_node = _M_node->_M_next;
@@ -159,15 +159,15 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       }
 
       bool
-      operator==(const _Self& __x) const
+      operator==(const _Self& __x) const noexcept
       { return _M_node == __x._M_node; }
 
       bool
-      operator!=(const _Self& __x) const
+      operator!=(const _Self& __x) const noexcept
       { return _M_node != __x._M_node; }
 
       _Self
-      _M_next() const
+      _M_next() const noexcept
       {
         if (_M_node)
           return _Fwd_list_iterator(_M_node->_M_next);
@@ -196,33 +196,33 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       typedef ptrdiff_t                          difference_type;
       typedef std::forward_iterator_tag          iterator_category;
 
-      _Fwd_list_const_iterator()
+      _Fwd_list_const_iterator() noexcept
       : _M_node() { }
 
       explicit
-      _Fwd_list_const_iterator(const _Fwd_list_node_base* __n) 
+      _Fwd_list_const_iterator(const _Fwd_list_node_base* __n)  noexcept
       : _M_node(__n) { }
 
-      _Fwd_list_const_iterator(const iterator& __iter)
+      _Fwd_list_const_iterator(const iterator& __iter) noexcept
       : _M_node(__iter._M_node) { }
 
       reference
-      operator*() const
+      operator*() const noexcept
       { return *static_cast<_Node*>(this->_M_node)->_M_valptr(); }
 
       pointer
-      operator->() const
+      operator->() const noexcept
       { return static_cast<_Node*>(this->_M_node)->_M_valptr(); }
 
       _Self&
-      operator++()
+      operator++() noexcept
       {
         _M_node = _M_node->_M_next;
         return *this;
       }
 
       _Self
-      operator++(int)
+      operator++(int) noexcept
       {
         _Self __tmp(*this);
         _M_node = _M_node->_M_next;
@@ -230,15 +230,15 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       }
 
       bool
-      operator==(const _Self& __x) const
+      operator==(const _Self& __x) const noexcept
       { return _M_node == __x._M_node; }
 
       bool
-      operator!=(const _Self& __x) const
+      operator!=(const _Self& __x) const noexcept
       { return _M_node != __x._M_node; }
 
       _Self
-      _M_next() const
+      _M_next() const noexcept
       {
         if (this->_M_node)
           return _Fwd_list_const_iterator(_M_node->_M_next);
@@ -255,7 +255,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
   template<typename _Tp>
     inline bool
     operator==(const _Fwd_list_iterator<_Tp>& __x,
-               const _Fwd_list_const_iterator<_Tp>& __y)
+               const _Fwd_list_const_iterator<_Tp>& __y) noexcept
     { return __x._M_node == __y._M_node; }
 
   /**
@@ -264,7 +264,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
   template<typename _Tp>
     inline bool
     operator!=(const _Fwd_list_iterator<_Tp>& __x,
-               const _Fwd_list_const_iterator<_Tp>& __y)
+               const _Fwd_list_const_iterator<_Tp>& __y) noexcept
     { return __x._M_node != __y._M_node; }
 
   /**

diff --git a/libstdc++-v3/include/bits/hashtable_policy.h b/libstdc++-v3/include/bits/hashtable_policy.h
index 61b852f62df43200dd6002016259f6a908893494..ed9e9dd870a98479f0298462c9f14d596092b566 100644 (file)
--- a/libstdc++-v3/include/bits/hashtable_policy.h
+++ b/libstdc++-v3/include/bits/hashtable_policy.h
@@ -230,9 +230,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   {
     _Hash_node_base* _M_nxt;
 
-    _Hash_node_base() : _M_nxt() { }
+    _Hash_node_base() noexcept : _M_nxt() { }
 
-    _Hash_node_base(_Hash_node_base* __next) : _M_nxt(__next) { }
+    _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { }
   };
 
   /**
@@ -281,7 +281,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       std::size_t  _M_hash_code;
 
       _Hash_node*
-      _M_next() const { return static_cast<_Hash_node*>(this->_M_nxt); }
+      _M_next() const noexcept
+      { return static_cast<_Hash_node*>(this->_M_nxt); }
     };
 
   /**
@@ -293,7 +294,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct _Hash_node<_Value, false> : _Hash_node_value_base<_Value>
     {
       _Hash_node*
-      _M_next() const { return static_cast<_Hash_node*>(this->_M_nxt); }
+      _M_next() const noexcept
+      { return static_cast<_Hash_node*>(this->_M_nxt); }
     };
 
   /// Base class for node iterators.
@@ -304,11 +306,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       __node_type*  _M_cur;
 
-      _Node_iterator_base(__node_type* __p)
+      _Node_iterator_base(__node_type* __p) noexcept
       : _M_cur(__p) { }
 
       void
-      _M_incr()
+      _M_incr() noexcept
       { _M_cur = _M_cur->_M_next(); }
     };
 
@@ -316,12 +318,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline bool
     operator==(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
               const _Node_iterator_base<_Value, _Cache_hash_code >& __y)
+    noexcept
     { return __x._M_cur == __y._M_cur; }
 
   template<typename _Value, bool _Cache_hash_code>
     inline bool
     operator!=(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
               const _Node_iterator_base<_Value, _Cache_hash_code>& __y)
+    noexcept
     { return __x._M_cur != __y._M_cur; }
 
   /// Node iterators, used to iterate through all the hashtable.
@@ -344,30 +348,30 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       using reference = typename std::conditional<__constant_iterators,
                                                  const _Value&, _Value&>::type;
 
-      _Node_iterator()
+      _Node_iterator() noexcept
       : __base_type(0) { }
 
       explicit
-      _Node_iterator(__node_type* __p)
+      _Node_iterator(__node_type* __p) noexcept
       : __base_type(__p) { }
 
       reference
-      operator*() const
+      operator*() const noexcept
       { return this->_M_cur->_M_v(); }
 
       pointer
-      operator->() const
+      operator->() const noexcept
       { return this->_M_cur->_M_valptr(); }
 
       _Node_iterator&
-      operator++()
+      operator++() noexcept
       {
        this->_M_incr();
        return *this;
       }
 
       _Node_iterator
-      operator++(int)
+      operator++(int) noexcept
       {
        _Node_iterator __tmp(*this);
        this->_M_incr();
@@ -392,34 +396,34 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef const _Value*                            pointer;
       typedef const _Value&                            reference;
 
-      _Node_const_iterator()
+      _Node_const_iterator() noexcept
       : __base_type(0) { }
 
       explicit
-      _Node_const_iterator(__node_type* __p)
+      _Node_const_iterator(__node_type* __p) noexcept
       : __base_type(__p) { }
 
       _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators,
-                          __cache>& __x)
+                          __cache>& __x) noexcept
       : __base_type(__x._M_cur) { }
 
       reference
-      operator*() const
+      operator*() const noexcept
       { return this->_M_cur->_M_v(); }
 
       pointer
-      operator->() const
+      operator->() const noexcept
       { return this->_M_cur->_M_valptr(); }
 
       _Node_const_iterator&
-      operator++()
+      operator++() noexcept
       {
        this->_M_incr();
        return *this;
       }
 
       _Node_const_iterator
-      operator++(int)
+      operator++(int) noexcept
       {
        _Node_const_iterator __tmp(*this);
        this->_M_incr();

diff --git a/libstdc++-v3/include/debug/safe_iterator.h b/libstdc++-v3/include/debug/safe_iterator.h
index a1f7651b1bd329e79399057cc6216d9ed0f515bd..d5adefd0ace9550c8c93243ef2cba7830cbaa7ad 100644 (file)
--- a/libstdc++-v3/include/debug/safe_iterator.h
+++ b/libstdc++-v3/include/debug/safe_iterator.h
@@ -139,7 +139,7 @@ namespace __gnu_debug
       typedef typename _Traits::pointer           pointer;
 
       /// @post the iterator is singular and unattached
-      _Safe_iterator() : _M_current() { }
+      _Safe_iterator() _GLIBCXX_NOEXCEPT : _M_current() { }
 
       /**
        * @brief Safe iterator construction from an unsafe iterator and
@@ -149,6 +149,7 @@ namespace __gnu_debug
        * @post this is not singular
        */
       _Safe_iterator(const _Iterator& __i, const _Sequence* __seq)
+      _GLIBCXX_NOEXCEPT
       : _Safe_iterator_base(__seq, _M_constant()), _M_current(__i)
       {
        _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
@@ -159,7 +160,7 @@ namespace __gnu_debug
       /**
        * @brief Copy construction.
        */
-      _Safe_iterator(const _Safe_iterator& __x)
+      _Safe_iterator(const _Safe_iterator& __x) _GLIBCXX_NOEXCEPT
       : _Safe_iterator_base(__x, _M_constant()), _M_current(__x._M_current)
       {
        // _GLIBCXX_RESOLVE_LIB_DEFECTS
@@ -176,7 +177,7 @@ namespace __gnu_debug
        * @brief Move construction.
        * @post __x is singular and unattached
        */
-      _Safe_iterator(_Safe_iterator&& __x) : _M_current()
+      _Safe_iterator(_Safe_iterator&& __x) noexcept : _M_current()
       {
        _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
                              || __x._M_current == _Iterator(),
@@ -198,7 +199,7 @@ namespace __gnu_debug
           const _Safe_iterator<_MutableIterator,
           typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator,
                       typename _Sequence::iterator::iterator_type>::__value),
-                   _Sequence>::__type>& __x)
+                   _Sequence>::__type>& __x) _GLIBCXX_NOEXCEPT
        : _Safe_iterator_base(__x, _M_constant()), _M_current(__x.base())
         {
          // _GLIBCXX_RESOLVE_LIB_DEFECTS
@@ -214,7 +215,7 @@ namespace __gnu_debug
        * @brief Copy assignment.
        */
       _Safe_iterator&
-      operator=(const _Safe_iterator& __x)
+      operator=(const _Safe_iterator& __x) _GLIBCXX_NOEXCEPT
       {
        // _GLIBCXX_RESOLVE_LIB_DEFECTS
        // DR 408. Is vector<reverse_iterator<char*> > forbidden?
@@ -234,7 +235,7 @@ namespace __gnu_debug
        * @post __x is singular and unattached
        */
       _Safe_iterator&
-      operator=(_Safe_iterator&& __x)
+      operator=(_Safe_iterator&& __x) noexcept
       {
        _GLIBCXX_DEBUG_VERIFY(this != &__x,
                              _M_message(__msg_self_move_assign)
@@ -257,7 +258,7 @@ namespace __gnu_debug
        *  @pre iterator is dereferenceable
        */
       reference
-      operator*() const
+      operator*() const _GLIBCXX_NOEXCEPT
       {
        _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
                              _M_message(__msg_bad_deref)
@@ -271,7 +272,7 @@ namespace __gnu_debug
        *  @todo Make this correct w.r.t. iterators that return proxies
        */
       pointer
-      operator->() const
+      operator->() const _GLIBCXX_NOEXCEPT
       {
        _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
                              _M_message(__msg_bad_deref)
@@ -285,7 +286,7 @@ namespace __gnu_debug
        *  @pre iterator is incrementable
        */
       _Safe_iterator&
-      operator++()
+      operator++() _GLIBCXX_NOEXCEPT
       {
        _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
                              _M_message(__msg_bad_inc)
@@ -299,7 +300,7 @@ namespace __gnu_debug
        *  @pre iterator is incrementable
        */
       _Safe_iterator
-      operator++(int)
+      operator++(int) _GLIBCXX_NOEXCEPT
       {
        _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
                              _M_message(__msg_bad_inc)
@@ -315,7 +316,7 @@ namespace __gnu_debug
        *  @pre iterator is decrementable
        */
       _Safe_iterator&
-      operator--()
+      operator--() _GLIBCXX_NOEXCEPT
       {
        _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
                              _M_message(__msg_bad_dec)
@@ -329,7 +330,7 @@ namespace __gnu_debug
        *  @pre iterator is decrementable
        */
       _Safe_iterator
-      operator--(int)
+      operator--(int) _GLIBCXX_NOEXCEPT
       {
        _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
                              _M_message(__msg_bad_dec)
@@ -341,7 +342,7 @@ namespace __gnu_debug
 
       // ------ Random access iterator requirements ------
       reference
-      operator[](const difference_type& __n) const
+      operator[](const difference_type& __n) const _GLIBCXX_NOEXCEPT
       {
        _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n)
                              && this->_M_can_advance(__n+1),
@@ -352,7 +353,7 @@ namespace __gnu_debug
       }
 
       _Safe_iterator&
-      operator+=(const difference_type& __n)
+      operator+=(const difference_type& __n) _GLIBCXX_NOEXCEPT
       {
        _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n),
                              _M_message(__msg_advance_oob)
@@ -362,7 +363,7 @@ namespace __gnu_debug
       }
 
       _Safe_iterator
-      operator+(const difference_type& __n) const
+      operator+(const difference_type& __n) const _GLIBCXX_NOEXCEPT
       {
        _Safe_iterator __tmp(*this);
        __tmp += __n;
@@ -370,7 +371,7 @@ namespace __gnu_debug
       }
 
       _Safe_iterator&
-      operator-=(const difference_type& __n)
+      operator-=(const difference_type& __n) _GLIBCXX_NOEXCEPT
       {
        _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(-__n),
                              _M_message(__msg_retreat_oob)
@@ -380,7 +381,7 @@ namespace __gnu_debug
       }
 
       _Safe_iterator
-      operator-(const difference_type& __n) const
+      operator-(const difference_type& __n) const _GLIBCXX_NOEXCEPT
       {
        _Safe_iterator __tmp(*this);
        __tmp -= __n;
@@ -392,13 +393,13 @@ namespace __gnu_debug
        * @brief Return the underlying iterator
        */
       _Iterator
-      base() const { return _M_current; }
+      base() const _GLIBCXX_NOEXCEPT { return _M_current; }
 
       /**
        * @brief Conversion to underlying non-debug iterator to allow
        * better interaction with non-debug containers.
        */
-      operator _Iterator() const { return _M_current; }
+      operator _Iterator() const _GLIBCXX_NOEXCEPT { return _M_current; }
 
       /** Attach iterator to the given sequence. */
       void
@@ -482,6 +483,7 @@ namespace __gnu_debug
     inline bool
     operator==(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
               const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_compare_bad)
@@ -498,6 +500,7 @@ namespace __gnu_debug
     inline bool
     operator==(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_compare_bad)
@@ -514,6 +517,7 @@ namespace __gnu_debug
     inline bool
     operator!=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
               const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_compare_bad)
@@ -530,6 +534,7 @@ namespace __gnu_debug
     inline bool
     operator!=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_compare_bad)
@@ -546,6 +551,7 @@ namespace __gnu_debug
     inline bool
     operator<(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
              const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_order_bad)
@@ -562,6 +568,7 @@ namespace __gnu_debug
     inline bool
     operator<(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
              const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_order_bad)
@@ -578,6 +585,7 @@ namespace __gnu_debug
     inline bool
     operator<=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
               const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_order_bad)
@@ -594,6 +602,7 @@ namespace __gnu_debug
     inline bool
     operator<=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_order_bad)
@@ -610,6 +619,7 @@ namespace __gnu_debug
     inline bool
     operator>(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
              const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_order_bad)
@@ -626,6 +636,7 @@ namespace __gnu_debug
     inline bool
     operator>(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
              const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_order_bad)
@@ -642,6 +653,7 @@ namespace __gnu_debug
     inline bool
     operator>=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
               const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_order_bad)
@@ -658,6 +670,7 @@ namespace __gnu_debug
     inline bool
     operator>=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_iter_order_bad)
@@ -678,6 +691,7 @@ namespace __gnu_debug
     inline typename _Safe_iterator<_IteratorL, _Sequence>::difference_type
     operator-(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
              const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                            _M_message(__msg_distance_bad)
@@ -694,6 +708,7 @@ namespace __gnu_debug
      inline typename _Safe_iterator<_Iterator, _Sequence>::difference_type
      operator-(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
               const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
      {
        _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
                             _M_message(__msg_distance_bad)
@@ -709,7 +724,7 @@ namespace __gnu_debug
   template<typename _Iterator, typename _Sequence>
     inline _Safe_iterator<_Iterator, _Sequence>
     operator+(typename _Safe_iterator<_Iterator,_Sequence>::difference_type __n,
-             const _Safe_iterator<_Iterator, _Sequence>& __i)
+             const _Safe_iterator<_Iterator, _Sequence>& __i) _GLIBCXX_NOEXCEPT
     { return __i + __n; }
 } // namespace __gnu_debug
 

diff --git a/libstdc++-v3/include/profile/iterator_tracker.h b/libstdc++-v3/include/profile/iterator_tracker.h
index 251eff7355f18c87857ed4fa836091d9ba6f1722..c016f20db8ba83ef25f21769d91ffbedcebce503 100644 (file)
--- a/libstdc++-v3/include/profile/iterator_tracker.h
+++ b/libstdc++-v3/include/profile/iterator_tracker.h
@@ -56,13 +56,14 @@ namespace __profile
       typedef typename _Traits::reference         reference;
       typedef typename _Traits::pointer           pointer;
 
-      __iterator_tracker()
+      __iterator_tracker() _GLIBCXX_NOEXCEPT
       : _M_current(), _M_ds(0) { }
 
-      __iterator_tracker(const _Iterator& __i, const _Sequence* __seq) 
+      __iterator_tracker(const _Iterator& __i, const _Sequence* __seq)
+      _GLIBCXX_NOEXCEPT
       : _M_current(__i), _M_ds(__seq) { }
 
-      __iterator_tracker(const __iterator_tracker& __x) 
+      __iterator_tracker(const __iterator_tracker& __x) _GLIBCXX_NOEXCEPT
       : _M_current(__x._M_current), _M_ds(__x._M_ds) { }
 
       template<typename _MutableIterator>
@@ -70,23 +71,23 @@ namespace __profile
                           typename __gnu_cxx::__enable_if
                           <(std::__are_same<_MutableIterator, typename
                             _Sequence::iterator::_Base_iterator>::__value),
-                          _Sequence>::__type>& __x)
+                          _Sequence>::__type>& __x) _GLIBCXX_NOEXCEPT
        :  _M_current(__x.base()), _M_ds(__x._M_get_sequence()) { }
 
       _Iterator
-      base() const { return _M_current; }
+      base() const _GLIBCXX_NOEXCEPT { return _M_current; }
   
       /**
        * @brief Conversion to underlying non-debug iterator to allow
        * better interaction with non-profile containers.
        */
-      operator _Iterator() const { return _M_current; }
+      operator _Iterator() const _GLIBCXX_NOEXCEPT { return _M_current; }
 
       pointer
-      operator->() const { return &*_M_current; }
+      operator->() const _GLIBCXX_NOEXCEPT { return &*_M_current; }
 
       __iterator_tracker&
-      operator++()
+      operator++() _GLIBCXX_NOEXCEPT
       {
        _M_ds->_M_profile_iterate();
        ++_M_current;
@@ -94,7 +95,7 @@ namespace __profile
       }
 
       __iterator_tracker
-      operator++(int)
+      operator++(int) _GLIBCXX_NOEXCEPT
       {
        _M_ds->_M_profile_iterate();
        __iterator_tracker __tmp(*this);
@@ -103,7 +104,7 @@ namespace __profile
       }
 
       __iterator_tracker&
-      operator--()
+      operator--() _GLIBCXX_NOEXCEPT
       {
        _M_ds->_M_profile_iterate(1);
        --_M_current;
@@ -111,7 +112,7 @@ namespace __profile
       }
 
       __iterator_tracker
-      operator--(int)
+      operator--(int) _GLIBCXX_NOEXCEPT
       {
        _M_ds->_M_profile_iterate(1);
        __iterator_tracker __tmp(*this);
@@ -120,30 +121,30 @@ namespace __profile
       }
 
       __iterator_tracker&
-      operator=(const __iterator_tracker& __x)
+      operator=(const __iterator_tracker& __x) _GLIBCXX_NOEXCEPT
       {
        _M_current = __x._M_current;
        return *this;
       }
 
       reference
-      operator*() const
+      operator*() const _GLIBCXX_NOEXCEPT
       { return *_M_current; }
 
       // ------ Random access iterator requirements ------
       reference
-      operator[](const difference_type& __n) const 
+      operator[](const difference_type& __n) const  _GLIBCXX_NOEXCEPT
       { return _M_current[__n]; }
 
       __iterator_tracker&
-      operator+=(const difference_type& __n)
+      operator+=(const difference_type& __n) _GLIBCXX_NOEXCEPT
       {
        _M_current += __n;
        return *this;
       }
 
       __iterator_tracker
-      operator+(const difference_type& __n) const
+      operator+(const difference_type& __n) const _GLIBCXX_NOEXCEPT
       {
        __iterator_tracker __tmp(*this);
        __tmp += __n;
@@ -151,14 +152,14 @@ namespace __profile
       }
 
       __iterator_tracker&
-      operator-=(const difference_type& __n)
+      operator-=(const difference_type& __n) _GLIBCXX_NOEXCEPT
       {
        _M_current += -__n;
        return *this;
       }
 
       __iterator_tracker
-      operator-(const difference_type& __n) const
+      operator-(const difference_type& __n) const _GLIBCXX_NOEXCEPT
       {
        __iterator_tracker __tmp(*this);
        __tmp -= __n;
@@ -178,72 +179,84 @@ namespace __profile
     inline bool
     operator==(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
               const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() == __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator==(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
               const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() == __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator!=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
               const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() != __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
                const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() != __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator<(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
              const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() < __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator<(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
              const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() < __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator<=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
               const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() <= __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator<=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
               const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() <= __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator>(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
              const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() > __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator>(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
              const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() > __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator>=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
               const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() >= __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator>=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
               const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() >= __rhs.base(); }
 
   // _GLIBCXX_RESOLVE_LIB_DEFECTS
@@ -254,12 +267,14 @@ namespace __profile
     inline typename __iterator_tracker<_IteratorL, _Sequence>::difference_type
     operator-(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
              const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() - __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline typename __iterator_tracker<_Iterator, _Sequence>::difference_type
     operator-(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
              const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
     { return __lhs.base() - __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
@@ -267,6 +282,7 @@ namespace __profile
     operator+(typename __iterator_tracker<_Iterator,_Sequence>::difference_type
              __n,
              const __iterator_tracker<_Iterator, _Sequence>& __i)
+    _GLIBCXX_NOEXCEPT
     { return __i + __n; }
        
 }  // namespace __profile