Index: include/list =================================================================== --- include/list +++ include/list @@ -805,14 +805,14 @@ class _LIBCPP_TEMPLATE_VIS list : private __list_imp<_Tp, _Alloc> { - typedef __list_imp<_Tp, _Alloc> base; - typedef typename base::__node __node; - typedef typename base::__node_allocator __node_allocator; - typedef typename base::__node_pointer __node_pointer; - typedef typename base::__node_alloc_traits __node_alloc_traits; - typedef typename base::__node_base __node_base; - typedef typename base::__node_base_pointer __node_base_pointer; - typedef typename base::__link_pointer __link_pointer; + typedef __list_imp<_Tp, _Alloc> __base; + typedef typename __base::__node __node; + typedef typename __base::__node_allocator __node_allocator; + typedef typename __base::__node_pointer __node_pointer; + typedef typename __base::__node_alloc_traits __node_alloc_traits; + typedef typename __base::__node_base __node_base; + typedef typename __base::__node_base_pointer __node_base_pointer; + typedef typename __base::__link_pointer __link_pointer; public: typedef _Tp value_type; @@ -821,14 +821,14 @@ "Invalid allocator::value_type"); typedef value_type& reference; typedef const value_type& const_reference; - typedef typename base::pointer pointer; - typedef typename base::const_pointer const_pointer; - typedef typename base::size_type size_type; - typedef typename base::difference_type difference_type; - typedef typename base::iterator iterator; - typedef typename base::const_iterator const_iterator; - typedef _VSTD::reverse_iterator reverse_iterator; - typedef _VSTD::reverse_iterator const_reverse_iterator; + typedef typename __base::pointer pointer; + typedef typename __base::const_pointer const_pointer; + typedef typename __base::size_type size_type; + typedef typename __base::difference_type difference_type; + typedef typename __base::iterator iterator; + typedef typename __base::const_iterator const_iterator; + typedef _VSTD::reverse_iterator reverse_iterator; + typedef _VSTD::reverse_iterator const_reverse_iterator; _LIBCPP_INLINE_VISIBILITY list() @@ -839,7 +839,7 @@ #endif } _LIBCPP_INLINE_VISIBILITY - explicit list(const allocator_type& __a) : base(__a) + explicit list(const allocator_type& __a) : __base(__a) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -895,29 +895,29 @@ allocator_type get_allocator() const _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY - size_type size() const _NOEXCEPT {return base::__sz();} + size_type size() const _NOEXCEPT {return __base::__sz();} _LIBCPP_INLINE_VISIBILITY - bool empty() const _NOEXCEPT {return base::empty();} + bool empty() const _NOEXCEPT {return __base::empty();} _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT { return std::min( - base::__node_alloc_max_size(), + __base::__node_alloc_max_size(), numeric_limits::max()); } _LIBCPP_INLINE_VISIBILITY - iterator begin() _NOEXCEPT {return base::begin();} + iterator begin() _NOEXCEPT {return __base::begin();} _LIBCPP_INLINE_VISIBILITY - const_iterator begin() const _NOEXCEPT {return base::begin();} + const_iterator begin() const _NOEXCEPT {return __base::begin();} _LIBCPP_INLINE_VISIBILITY - iterator end() _NOEXCEPT {return base::end();} + iterator end() _NOEXCEPT {return __base::end();} _LIBCPP_INLINE_VISIBILITY - const_iterator end() const _NOEXCEPT {return base::end();} + const_iterator end() const _NOEXCEPT {return __base::end();} _LIBCPP_INLINE_VISIBILITY - const_iterator cbegin() const _NOEXCEPT {return base::begin();} + const_iterator cbegin() const _NOEXCEPT {return __base::begin();} _LIBCPP_INLINE_VISIBILITY - const_iterator cend() const _NOEXCEPT {return base::end();} + const_iterator cend() const _NOEXCEPT {return __base::end();} _LIBCPP_INLINE_VISIBILITY reverse_iterator rbegin() _NOEXCEPT @@ -942,25 +942,25 @@ reference front() { _LIBCPP_ASSERT(!empty(), "list::front called on empty list"); - return base::__end_.__next_->__as_node()->__value_; + return __base::__end_.__next_->__as_node()->__value_; } _LIBCPP_INLINE_VISIBILITY const_reference front() const { _LIBCPP_ASSERT(!empty(), "list::front called on empty list"); - return base::__end_.__next_->__as_node()->__value_; + return __base::__end_.__next_->__as_node()->__value_; } _LIBCPP_INLINE_VISIBILITY reference back() { _LIBCPP_ASSERT(!empty(), "list::back called on empty list"); - return base::__end_.__prev_->__as_node()->__value_; + return __base::__end_.__prev_->__as_node()->__value_; } _LIBCPP_INLINE_VISIBILITY const_reference back() const { _LIBCPP_ASSERT(!empty(), "list::back called on empty list"); - return base::__end_.__prev_->__as_node()->__value_; + return __base::__end_.__prev_->__as_node()->__value_; } #ifndef _LIBCPP_CXX03_LANG @@ -1006,9 +1006,9 @@ _NOEXCEPT_DEBUG_(!__node_alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<__node_allocator>::value) #endif - {base::swap(__c);} + {__base::swap(__c);} _LIBCPP_INLINE_VISIBILITY - void clear() _NOEXCEPT {base::clear();} + void clear() _NOEXCEPT {__base::clear();} void pop_front(); void pop_back(); @@ -1105,10 +1105,10 @@ void list<_Tp, _Alloc>::__link_nodes_at_front(__link_pointer __f, __link_pointer __l) { - __f->__prev_ = base::__end_as_link(); - __l->__next_ = base::__end_.__next_; + __f->__prev_ = __base::__end_as_link(); + __l->__next_ = __base::__end_.__next_; __l->__next_->__prev_ = __l; - base::__end_.__next_ = __f; + __base::__end_.__next_ = __f; } // Link in nodes [__f, __l] at the front of the list @@ -1117,10 +1117,10 @@ void list<_Tp, _Alloc>::__link_nodes_at_back(__link_pointer __f, __link_pointer __l) { - __l->__next_ = base::__end_as_link(); - __f->__prev_ = base::__end_.__prev_; + __l->__next_ = __base::__end_as_link(); + __f->__prev_ = __base::__end_.__prev_; __f->__prev_->__next_ = __f; - base::__end_.__prev_ = __l; + __base::__end_.__prev_ = __l; } @@ -1129,8 +1129,8 @@ typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>::__iterator(size_type __n) { - return __n <= base::__sz() / 2 ? _VSTD::next(begin(), __n) - : _VSTD::prev(end(), base::__sz() - __n); + return __n <= __base::__sz() / 2 ? _VSTD::next(begin(), __n) + : _VSTD::prev(end(), __base::__sz() - __n); } template @@ -1149,7 +1149,7 @@ #if _LIBCPP_STD_VER > 11 template -list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : base(__a) +list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : __base(__a) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1171,7 +1171,7 @@ template list<_Tp, _Alloc>::list(size_type __n, const value_type& __x, const allocator_type& __a) - : base(__a) + : __base(__a) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1196,7 +1196,7 @@ template list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l, const allocator_type& __a, typename enable_if<__is_input_iterator<_InpIter>::value>::type*) - : base(__a) + : __base(__a) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1207,9 +1207,9 @@ template list<_Tp, _Alloc>::list(const list& __c) - : base(allocator_type( - __node_alloc_traits::select_on_container_copy_construction( - __c.__node_alloc()))) + : __base(allocator_type( + __node_alloc_traits::select_on_container_copy_construction( + __c.__node_alloc()))) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1220,7 +1220,7 @@ template list<_Tp, _Alloc>::list(const list& __c, const allocator_type& __a) - : base(__a) + : __base(__a) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1233,7 +1233,7 @@ template list<_Tp, _Alloc>::list(initializer_list __il, const allocator_type& __a) - : base(__a) + : __base(__a) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1258,7 +1258,7 @@ inline list<_Tp, _Alloc>::list(list&& __c) _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value) - : base(allocator_type(_VSTD::move(__c.__node_alloc()))) + : __base(allocator_type(_VSTD::move(__c.__node_alloc()))) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1269,7 +1269,7 @@ template inline list<_Tp, _Alloc>::list(list&& __c, const allocator_type& __a) - : base(__a) + : __base(__a) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1300,7 +1300,7 @@ void list<_Tp, _Alloc>::__move_assign(list& __c, false_type) { - if (base::__node_alloc() != __c.__node_alloc()) + if (__base::__node_alloc() != __c.__node_alloc()) { typedef move_iterator _Ip; assign(_Ip(__c.begin()), _Ip(__c.end())); @@ -1315,7 +1315,7 @@ _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value) { clear(); - base::__move_assign_alloc(__c); + __base::__move_assign_alloc(__c); splice(end(), __c); } @@ -1328,7 +1328,7 @@ { if (this != &__c) { - base::__copy_assign_alloc(__c); + __base::__copy_assign_alloc(__c); assign(__c.begin(), __c.end()); } return *this; @@ -1375,7 +1375,7 @@ _Alloc list<_Tp, _Alloc>::get_allocator() const _NOEXCEPT { - return allocator_type(base::__node_alloc()); + return allocator_type(__base::__node_alloc()); } template @@ -1387,13 +1387,13 @@ "list::insert(iterator, x) called with an iterator not" " referring to this list"); #endif - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __hold->__prev_ = 0; __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); __link_nodes(__p.__ptr_, __hold->__as_link(), __hold->__as_link()); - ++base::__sz(); + ++__base::__sz(); #if _LIBCPP_DEBUG_LEVEL >= 2 return iterator(__hold.release()->__as_link(), this); #else @@ -1416,7 +1416,7 @@ if (__n > 0) { size_type __ds = 0; - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __hold->__prev_ = 0; @@ -1462,7 +1462,7 @@ } #endif // _LIBCPP_NO_EXCEPTIONS __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_); - base::__sz() += __ds; + __base::__sz() += __ds; } return __r; } @@ -1484,7 +1484,7 @@ if (__f != __l) { size_type __ds = 0; - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __hold->__prev_ = 0; @@ -1530,7 +1530,7 @@ } #endif // _LIBCPP_NO_EXCEPTIONS __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_); - base::__sz() += __ds; + __base::__sz() += __ds; } return __r; } @@ -1539,13 +1539,13 @@ void list<_Tp, _Alloc>::push_front(const value_type& __x) { - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); __link_pointer __nl = __hold->__as_link(); __link_nodes_at_front(__nl, __nl); - ++base::__sz(); + ++__base::__sz(); __hold.release(); } @@ -1553,12 +1553,12 @@ void list<_Tp, _Alloc>::push_back(const value_type& __x) { - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link()); - ++base::__sz(); + ++__base::__sz(); __hold.release(); } @@ -1568,12 +1568,12 @@ void list<_Tp, _Alloc>::push_front(value_type&& __x) { - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x)); __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link()); - ++base::__sz(); + ++__base::__sz(); __hold.release(); } @@ -1581,12 +1581,12 @@ void list<_Tp, _Alloc>::push_back(value_type&& __x) { - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x)); __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link()); - ++base::__sz(); + ++__base::__sz(); __hold.release(); } @@ -1599,12 +1599,12 @@ #endif list<_Tp, _Alloc>::emplace_front(_Args&&... __args) { - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...); __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link()); - ++base::__sz(); + ++__base::__sz(); #if _LIBCPP_STD_VER > 14 return __hold.release()->__value_; #else @@ -1621,13 +1621,13 @@ #endif list<_Tp, _Alloc>::emplace_back(_Args&&... __args) { - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...); __link_pointer __nl = __hold->__as_link(); __link_nodes_at_back(__nl, __nl); - ++base::__sz(); + ++__base::__sz(); #if _LIBCPP_STD_VER > 14 return __hold.release()->__value_; #else @@ -1645,14 +1645,14 @@ "list::emplace(iterator, args...) called with an iterator not" " referring to this list"); #endif - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __hold->__prev_ = 0; __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...); __link_pointer __nl = __hold.get()->__as_link(); __link_nodes(__p.__ptr_, __nl, __nl); - ++base::__sz(); + ++__base::__sz(); __hold.release(); #if _LIBCPP_DEBUG_LEVEL >= 2 return iterator(__nl, this); @@ -1670,14 +1670,14 @@ "list::insert(iterator, x) called with an iterator not" " referring to this list"); #endif - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __hold->__prev_ = 0; __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x)); __link_pointer __nl = __hold->__as_link(); __link_nodes(__p.__ptr_, __nl, __nl); - ++base::__sz(); + ++__base::__sz(); __hold.release(); #if _LIBCPP_DEBUG_LEVEL >= 2 return iterator(__nl, this); @@ -1693,10 +1693,10 @@ list<_Tp, _Alloc>::pop_front() { _LIBCPP_ASSERT(!empty(), "list::pop_front() called with empty list"); - __node_allocator& __na = base::__node_alloc(); - __link_pointer __n = base::__end_.__next_; - base::__unlink_nodes(__n, __n); - --base::__sz(); + __node_allocator& __na = __base::__node_alloc(); + __link_pointer __n = __base::__end_.__next_; + __base::__unlink_nodes(__n, __n); + --__base::__sz(); #if _LIBCPP_DEBUG_LEVEL >= 2 __c_node* __c = __get_db()->__find_c_and_lock(this); for (__i_node** __p = __c->end_; __p != __c->beg_; ) @@ -1722,10 +1722,10 @@ list<_Tp, _Alloc>::pop_back() { _LIBCPP_ASSERT(!empty(), "list::pop_back() called with empty list"); - __node_allocator& __na = base::__node_alloc(); - __link_pointer __n = base::__end_.__prev_; - base::__unlink_nodes(__n, __n); - --base::__sz(); + __node_allocator& __na = __base::__node_alloc(); + __link_pointer __n = __base::__end_.__prev_; + __base::__unlink_nodes(__n, __n); + --__base::__sz(); #if _LIBCPP_DEBUG_LEVEL >= 2 __c_node* __c = __get_db()->__find_c_and_lock(this); for (__i_node** __p = __c->end_; __p != __c->beg_; ) @@ -1757,11 +1757,11 @@ #endif _LIBCPP_ASSERT(__p != end(), "list::erase(iterator) called with a non-dereferenceable iterator"); - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); __link_pointer __n = __p.__ptr_; __link_pointer __r = __n->__next_; - base::__unlink_nodes(__n, __n); - --base::__sz(); + __base::__unlink_nodes(__n, __n); + --__base::__sz(); #if _LIBCPP_DEBUG_LEVEL >= 2 __c_node* __c = __get_db()->__find_c_and_lock(this); for (__i_node** __ip = __c->end_; __ip != __c->beg_; ) @@ -1801,13 +1801,13 @@ #endif if (__f != __l) { - __node_allocator& __na = base::__node_alloc(); - base::__unlink_nodes(__f.__ptr_, __l.__ptr_->__prev_); + __node_allocator& __na = __base::__node_alloc(); + __base::__unlink_nodes(__f.__ptr_, __l.__ptr_->__prev_); while (__f != __l) { __link_pointer __n = __f.__ptr_; ++__f; - --base::__sz(); + --__base::__sz(); #if _LIBCPP_DEBUG_LEVEL >= 2 __c_node* __c = __get_db()->__find_c_and_lock(this); for (__i_node** __p = __c->end_; __p != __c->beg_; ) @@ -1839,13 +1839,13 @@ void list<_Tp, _Alloc>::resize(size_type __n) { - if (__n < base::__sz()) + if (__n < __base::__sz()) erase(__iterator(__n), end()); - else if (__n > base::__sz()) + else if (__n > __base::__sz()) { - __n -= base::__sz(); + __n -= __base::__sz(); size_type __ds = 0; - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __hold->__prev_ = 0; @@ -1890,7 +1890,7 @@ } #endif // _LIBCPP_NO_EXCEPTIONS __link_nodes_at_back(__r.__ptr_, __e.__ptr_); - base::__sz() += __ds; + __base::__sz() += __ds; } } @@ -1898,13 +1898,13 @@ void list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x) { - if (__n < base::__sz()) + if (__n < __base::__sz()) erase(__iterator(__n), end()); - else if (__n > base::__sz()) + else if (__n > __base::__sz()) { - __n -= base::__sz(); + __n -= __base::__sz(); size_type __ds = 0; - __node_allocator& __na = base::__node_alloc(); + __node_allocator& __na = __base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); __hold->__prev_ = 0; @@ -1949,8 +1949,8 @@ throw; } #endif // _LIBCPP_NO_EXCEPTIONS - __link_nodes(base::__end_as_link(), __r.__ptr_, __e.__ptr_); - base::__sz() += __ds; + __link_nodes(__base::__end_as_link(), __r.__ptr_, __e.__ptr_); + __base::__sz() += __ds; } } @@ -1969,9 +1969,9 @@ { __link_pointer __f = __c.__end_.__next_; __link_pointer __l = __c.__end_.__prev_; - base::__unlink_nodes(__f, __l); + __base::__unlink_nodes(__f, __l); __link_nodes(__p.__ptr_, __f, __l); - base::__sz() += __c.__sz(); + __base::__sz() += __c.__sz(); __c.__sz() = 0; #if _LIBCPP_DEBUG_LEVEL >= 2 __libcpp_db* __db = __get_db(); @@ -2012,10 +2012,10 @@ if (__p.__ptr_ != __i.__ptr_ && __p.__ptr_ != __i.__ptr_->__next_) { __link_pointer __f = __i.__ptr_; - base::__unlink_nodes(__f, __f); + __base::__unlink_nodes(__f, __f); __link_nodes(__p.__ptr_, __f, __f); --__c.__sz(); - ++base::__sz(); + ++__base::__sz(); #if _LIBCPP_DEBUG_LEVEL >= 2 __libcpp_db* __db = __get_db(); __c_node* __cn1 = __db->__find_c_and_lock(this); @@ -2063,12 +2063,12 @@ { size_type __s = _VSTD::distance(__f, __l); __c.__sz() -= __s; - base::__sz() += __s; + __base::__sz() += __s; } __link_pointer __first = __f.__ptr_; --__l; __link_pointer __last = __l.__ptr_; - base::__unlink_nodes(__first, __last); + __base::__unlink_nodes(__first, __last); __link_nodes(__p.__ptr_, __first, __last); #if _LIBCPP_DEBUG_LEVEL >= 2 __libcpp_db* __db = __get_db(); @@ -2188,12 +2188,12 @@ iterator __m2 = _VSTD::next(__f2); for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, ++__ds) ; - base::__sz() += __ds; + __base::__sz() += __ds; __c.__sz() -= __ds; __link_pointer __f = __f2.__ptr_; __link_pointer __l = __m2.__ptr_->__prev_; __f2 = __m2; - base::__unlink_nodes(__f, __l); + __base::__unlink_nodes(__f, __l); __m2 = _VSTD::next(__f1); __link_nodes(__f1.__ptr_, __f, __l); __f1 = __m2; @@ -2237,7 +2237,7 @@ void list<_Tp, _Alloc>::sort(_Comp __comp) { - __sort(begin(), end(), base::__sz(), __comp); + __sort(begin(), end(), __base::__sz(), __comp); } template @@ -2254,7 +2254,7 @@ if (__comp(*--__e2, *__f1)) { __link_pointer __f = __e2.__ptr_; - base::__unlink_nodes(__f, __f); + __base::__unlink_nodes(__f, __f); __link_nodes(__f1.__ptr_, __f, __f); return __e2; } @@ -2273,7 +2273,7 @@ __link_pointer __l = __m2.__ptr_->__prev_; __r = __f2; __e1 = __f2 = __m2; - base::__unlink_nodes(__f, __l); + __base::__unlink_nodes(__f, __l); __m2 = _VSTD::next(__f1); __link_nodes(__f1.__ptr_, __f, __l); __f1 = __m2; @@ -2292,7 +2292,7 @@ if (__e1 == __f2) __e1 = __m2; __f2 = __m2; - base::__unlink_nodes(__f, __l); + __base::__unlink_nodes(__f, __l); __m2 = _VSTD::next(__f1); __link_nodes(__f1.__ptr_, __f, __l); __f1 = __m2; @@ -2307,7 +2307,7 @@ void list<_Tp, _Alloc>::reverse() _NOEXCEPT { - if (base::__sz() > 1) + if (__base::__sz() > 1) { iterator __e = end(); for (iterator __i = begin(); __i.__ptr_ != __e.__ptr_;) @@ -2339,7 +2339,7 @@ bool list<_Tp, _Alloc>::__decrementable(const const_iterator* __i) const { - return !empty() && __i->__ptr_ != base::__end_.__next_; + return !empty() && __i->__ptr_ != __base::__end_.__next_; } template