From patchwork Tue Sep 24 16:13:44 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Marc Glisse X-Patchwork-Id: 277534 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 5499E2C00AD for ; Wed, 25 Sep 2013 02:14:10 +1000 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:reply-to:to:cc:subject:message-id:mime-version :content-type; q=dns; s=default; b=DcXve72e/eG1TgvsQWpyNm6uUIwN9 4D9lk5NnN3vmtv/rx6tKpJ4Kc9nPk+nNS1ZxNIP51uOVPa3h2l8iVva/0lDlAnI0 0W2fPoIagF8wYlkK/SWAzAvwFRxwwpjLUka0PQk56ipd3zIXqAKAGF6Mkdo8m+w2 JghmKighNloElk= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:reply-to:to:cc:subject:message-id:mime-version :content-type; s=default; bh=turWn44UqKllIcTwbjE3+kAk4k8=; b=HjZ TTysHsrQK6hX3/2s5owwO7Ne+d1RNkNFz19ibgJZd4cfQdkteNA4Htmxn1ps/W+H 6y/wrUpST6z9jaiy70CcR3G3P3ha62E1S0RiivuOSNA7o6qdCOEAfmnJa+EB0ZBq WaCraxJZKNInXws3q3nx2BcY+oQ0FagrZehs8fhY= Received: (qmail 22585 invoked by alias); 24 Sep 2013 16:13:52 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 22564 invoked by uid 89); 24 Sep 2013 16:13:52 -0000 Received: from mail2-relais-roc.national.inria.fr (HELO mail2-relais-roc.national.inria.fr) (192.134.164.83) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (CAMELLIA256-SHA encrypted) ESMTPS; Tue, 24 Sep 2013 16:13:52 +0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-3.7 required=5.0 tests=AWL, BAYES_00, RDNS_NONE autolearn=no version=3.3.2 X-Spam-User: qpsmtpd, 2 recipients X-HELO: mail2-relais-roc.national.inria.fr Received: from stedding.saclay.inria.fr ([193.55.250.194]) by mail2-relais-roc.national.inria.fr with ESMTP/TLS/DHE-RSA-AES128-SHA; 24 Sep 2013 18:13:43 +0200 Received: from glisse (helo=localhost) by stedding.saclay.inria.fr with local-esmtp (Exim 4.80) (envelope-from ) id 1VOVFA-0002Qg-5y; Tue, 24 Sep 2013 18:13:44 +0200 Date: Tue, 24 Sep 2013 18:13:44 +0200 (CEST) From: Marc Glisse Reply-To: libstdc++@gcc.gnu.org To: libstdc++@gcc.gnu.org cc: gcc-patches@gcc.gnu.org Subject: [v3] More noexcept -- 6th Message-ID: User-Agent: Alpine 2.02 (DEB 1266 2009-07-14) MIME-Version: 1.0 Hello, bootstrap+testsuite ok. I think all container iterators are done, but not the containers themselves. 2013-09-25 Marc Glisse 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. Index: include/bits/forward_list.h =================================================================== --- include/bits/forward_list.h (revision 202868) +++ include/bits/forward_list.h (working copy) @@ -51,21 +51,21 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER * There are purely list shuffling utility methods here. */ struct _Fwd_list_node_base { _Fwd_list_node_base() = default; _Fwd_list_node_base* _M_next = nullptr; _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) { __begin->_M_next = __end->_M_next; __end->_M_next = _M_next; } else __begin->_M_next = 0; _M_next = __keep; @@ -121,60 +121,60 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER { typedef _Fwd_list_iterator<_Tp> _Self; typedef _Fwd_list_node<_Tp> _Node; typedef _Tp value_type; typedef _Tp* pointer; typedef _Tp& reference; 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; return __tmp; } 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); else return _Fwd_list_iterator(0); } _Fwd_list_node_base* _M_node; }; @@ -189,89 +189,89 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER typedef _Fwd_list_const_iterator<_Tp> _Self; typedef const _Fwd_list_node<_Tp> _Node; typedef _Fwd_list_iterator<_Tp> iterator; typedef _Tp value_type; typedef const _Tp* pointer; typedef const _Tp& reference; typedef ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; - _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; return __tmp; } 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); else return _Fwd_list_const_iterator(0); } const _Fwd_list_node_base* _M_node; }; /** * @brief Forward list iterator equality comparison. */ template 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; } /** * @brief Forward list iterator inequality comparison. */ template 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; } /** * @brief Base class for %forward_list. */ template struct _Fwd_list_base { protected: typedef typename __gnu_cxx::__alloc_traits<_Alloc> _Alloc_traits; Index: include/bits/hashtable_policy.h =================================================================== --- include/bits/hashtable_policy.h (revision 202868) +++ include/bits/hashtable_policy.h (working copy) @@ -223,23 +223,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * * Nodes, used to wrap elements stored in the hash table. A policy * template parameter of class template _Hashtable controls whether * nodes also store a hash code. In some cases (e.g. strings) this * may be a performance win. */ struct _Hash_node_base { _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) { } }; /** * struct _Hash_node_value_base * * Node type with the value to store. */ template struct _Hash_node_value_base : _Hash_node_base { @@ -274,61 +274,65 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * Specialization for nodes with caches, struct _Hash_node. * * Base class is __detail::_Hash_node_value_base. */ template struct _Hash_node<_Value, true> : _Hash_node_value_base<_Value> { 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); } }; /** * Specialization for nodes without caches, struct _Hash_node. * * Base class is __detail::_Hash_node_value_base. */ template 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. template struct _Node_iterator_base { using __node_type = _Hash_node<_Value, _Cache_hash_code>; __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(); } }; template 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 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. template struct _Node_iterator : public _Node_iterator_base<_Value, __cache> { private: using __base_type = _Node_iterator_base<_Value, __cache>; using __node_type = typename __base_type::__node_type; @@ -337,44 +341,44 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typedef _Value value_type; typedef std::ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; using pointer = typename std::conditional<__constant_iterators, const _Value*, _Value*>::type; 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(); return __tmp; } }; /// Node const_iterators, used to iterate through all the hashtable. template struct _Node_const_iterator @@ -385,48 +389,48 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using __node_type = typename __base_type::__node_type; public: typedef _Value value_type; typedef std::ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; 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(); return __tmp; } }; // Many of class template _Hashtable's template parameters are policy // classes. These are defaults for the policies. Index: include/debug/safe_iterator.h =================================================================== --- include/debug/safe_iterator.h (revision 202868) +++ include/debug/safe_iterator.h (working copy) @@ -132,58 +132,59 @@ namespace __gnu_debug public: typedef _Iterator iterator_type; typedef typename _Traits::iterator_category iterator_category; typedef typename _Traits::value_type value_type; typedef typename _Traits::difference_type difference_type; typedef typename _Traits::reference reference; 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 * its sequence. * * @pre @p seq is not NULL * @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(), _M_message(__msg_init_singular) ._M_iterator(*this, "this")); } /** * @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 // DR 408. Is vector > forbidden? _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() || __x._M_current == _Iterator(), _M_message(__msg_init_copy_singular) ._M_iterator(*this, "this") ._M_iterator(__x, "other")); } #if __cplusplus >= 201103L /** * @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(), _M_message(__msg_init_copy_singular) ._M_iterator(*this, "this") ._M_iterator(__x, "other")); std::swap(_M_current, __x._M_current); this->_M_attach(__x._M_sequence); __x._M_detach(); } @@ -191,57 +192,57 @@ namespace __gnu_debug /** * @brief Converting constructor from a mutable iterator to a * constant iterator. */ template _Safe_iterator( 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 // DR 408. Is vector > forbidden? _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() || __x.base() == _Iterator(), _M_message(__msg_init_const_singular) ._M_iterator(*this, "this") ._M_iterator(__x, "other")); } /** * @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 > forbidden? _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() || __x._M_current == _Iterator(), _M_message(__msg_copy_singular) ._M_iterator(*this, "this") ._M_iterator(__x, "other")); _M_current = __x._M_current; this->_M_attach(__x._M_sequence); return *this; } #if __cplusplus >= 201103L /** * @brief Move assignment. * @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) ._M_iterator(*this, "this")); _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() || __x._M_current == _Iterator(), _M_message(__msg_copy_singular) ._M_iterator(*this, "this") ._M_iterator(__x, "other")); _M_current = __x._M_current; @@ -250,162 +251,162 @@ namespace __gnu_debug __x._M_current = _Iterator(); return *this; } #endif /** * @brief Iterator dereference. * @pre iterator is dereferenceable */ reference - operator*() const + operator*() const _GLIBCXX_NOEXCEPT { _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(), _M_message(__msg_bad_deref) ._M_iterator(*this, "this")); return *_M_current; } /** * @brief Iterator dereference. * @pre iterator is dereferenceable * @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) ._M_iterator(*this, "this")); return std::__addressof(*_M_current); } // ------ Input iterator requirements ------ /** * @brief Iterator preincrement * @pre iterator is incrementable */ _Safe_iterator& - operator++() + operator++() _GLIBCXX_NOEXCEPT { _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(), _M_message(__msg_bad_inc) ._M_iterator(*this, "this")); ++_M_current; return *this; } /** * @brief Iterator postincrement * @pre iterator is incrementable */ _Safe_iterator - operator++(int) + operator++(int) _GLIBCXX_NOEXCEPT { _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(), _M_message(__msg_bad_inc) ._M_iterator(*this, "this")); _Safe_iterator __tmp(*this); ++_M_current; return __tmp; } // ------ Bidirectional iterator requirements ------ /** * @brief Iterator predecrement * @pre iterator is decrementable */ _Safe_iterator& - operator--() + operator--() _GLIBCXX_NOEXCEPT { _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(), _M_message(__msg_bad_dec) ._M_iterator(*this, "this")); --_M_current; return *this; } /** * @brief Iterator postdecrement * @pre iterator is decrementable */ _Safe_iterator - operator--(int) + operator--(int) _GLIBCXX_NOEXCEPT { _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(), _M_message(__msg_bad_dec) ._M_iterator(*this, "this")); _Safe_iterator __tmp(*this); --_M_current; return __tmp; } // ------ 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), _M_message(__msg_iter_subscript_oob) ._M_iterator(*this)._M_integer(__n)); return _M_current[__n]; } _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) ._M_iterator(*this)._M_integer(__n)); _M_current += __n; return *this; } _Safe_iterator - operator+(const difference_type& __n) const + operator+(const difference_type& __n) const _GLIBCXX_NOEXCEPT { _Safe_iterator __tmp(*this); __tmp += __n; return __tmp; } _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) ._M_iterator(*this)._M_integer(__n)); _M_current += -__n; return *this; } _Safe_iterator - operator-(const difference_type& __n) const + operator-(const difference_type& __n) const _GLIBCXX_NOEXCEPT { _Safe_iterator __tmp(*this); __tmp -= __n; return __tmp; } // ------ Utilities ------ /** * @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 _M_attach(_Safe_sequence_base* __seq) { _Safe_iterator_base::_M_attach(__seq, _M_constant()); } /** Likewise, but not thread-safe. */ void @@ -475,244 +476,258 @@ namespace __gnu_debug { return _BeforeBeginHelper<_Sequence>::_S_Is_Beginnest(base(), _M_get_sequence()); } }; template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_compare_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() == __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_compare_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() == __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_compare_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() != __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_compare_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() != __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_order_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() < __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_order_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() < __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_order_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() <= __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_order_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() <= __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_order_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() > __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_order_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() > __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_order_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() >= __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_order_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() >= __rhs.base(); } // _GLIBCXX_RESOLVE_LIB_DEFECTS // According to the resolution of DR179 not only the various comparison // operators but also operator- must accept mixed iterator/const_iterator // parameters. template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_distance_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() - __rhs.base(); } template 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) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), _M_message(__msg_distance_different) ._M_iterator(__lhs, "lhs") ._M_iterator(__rhs, "rhs")); return __lhs.base() - __rhs.base(); } template 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 #include #endif Index: include/profile/iterator_tracker.h =================================================================== --- include/profile/iterator_tracker.h (revision 202868) +++ include/profile/iterator_tracker.h (working copy) @@ -49,226 +49,242 @@ namespace __profile typedef std::iterator_traits<_Iterator> _Traits; public: typedef _Iterator _Base_iterator; typedef typename _Traits::iterator_category iterator_category; typedef typename _Traits::value_type value_type; typedef typename _Traits::difference_type difference_type; 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 __iterator_tracker(const __iterator_tracker<_MutableIterator, 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; return *this; } __iterator_tracker - operator++(int) + operator++(int) _GLIBCXX_NOEXCEPT { _M_ds->_M_profile_iterate(); __iterator_tracker __tmp(*this); ++_M_current; return __tmp; } __iterator_tracker& - operator--() + operator--() _GLIBCXX_NOEXCEPT { _M_ds->_M_profile_iterate(1); --_M_current; return *this; } __iterator_tracker - operator--(int) + operator--(int) _GLIBCXX_NOEXCEPT { _M_ds->_M_profile_iterate(1); __iterator_tracker __tmp(*this); --_M_current; return __tmp; } __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; return __tmp; } __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; return __tmp; } void _M_find() { _M_ds->_M_profile_find(); } const _Sequence* _M_get_sequence() const { return static_cast(_M_ds); } }; template inline bool operator==(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT { return __lhs.base() == __rhs.base(); } template inline bool operator==(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT { return __lhs.base() == __rhs.base(); } template inline bool operator!=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT { return __lhs.base() != __rhs.base(); } template inline bool operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT { return __lhs.base() != __rhs.base(); } template inline bool operator<(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT { return __lhs.base() < __rhs.base(); } template inline bool operator<(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT { return __lhs.base() < __rhs.base(); } template inline bool operator<=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT { return __lhs.base() <= __rhs.base(); } template inline bool operator<=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT { return __lhs.base() <= __rhs.base(); } template inline bool operator>(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT { return __lhs.base() > __rhs.base(); } template inline bool operator>(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT { return __lhs.base() > __rhs.base(); } template inline bool operator>=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT { return __lhs.base() >= __rhs.base(); } template 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 // According to the resolution of DR179 not only the various comparison // operators but also operator- must accept mixed iterator/const_iterator // parameters. template 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 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 inline __iterator_tracker<_Iterator, _Sequence> operator+(typename __iterator_tracker<_Iterator,_Sequence>::difference_type __n, const __iterator_tracker<_Iterator, _Sequence>& __i) + _GLIBCXX_NOEXCEPT { return __i + __n; } } // namespace __profile } // namespace std #endif